зеркало из https://github.com/mozilla/pluotsorbet.git
275 строки
8.1 KiB
TypeScript
275 строки
8.1 KiB
TypeScript
//
|
|
//var Classes = function() {
|
|
// if (this instanceof Classes) {
|
|
// this.classFiles = [];
|
|
// this.mainclass = [];
|
|
// this.classes = {};
|
|
// } else {
|
|
// return new Classes();
|
|
// }
|
|
//}
|
|
module J2ME {
|
|
declare var ZipFile;
|
|
declare var ACCESS_FLAGS;
|
|
declare var snarf;
|
|
|
|
export class ClassRegistry {
|
|
/**
|
|
* List of directories to look for source files in.
|
|
*/
|
|
sourceDirectories: string [];
|
|
|
|
/**
|
|
* All source code, only ever used for debugging.
|
|
*/
|
|
sourceFiles: Map<string, string []>;
|
|
|
|
/**
|
|
* List of classes whose sources files were not found. We keep track
|
|
* of them so we don't have to search for them over and over.
|
|
*/
|
|
missingSourceFiles: Map<string, string []>;
|
|
|
|
classFiles: Map<string, any>;
|
|
classes: Map<string, ClassInfo>;
|
|
|
|
java_lang_Object: ClassInfo;
|
|
java_lang_Class: ClassInfo;
|
|
java_lang_String: ClassInfo;
|
|
java_lang_Thread: ClassInfo;
|
|
|
|
constructor() {
|
|
this.sourceDirectories = [];
|
|
this.sourceFiles = Object.create(null);
|
|
this.missingSourceFiles = Object.create(null);
|
|
|
|
this.classFiles = Object.create(null);
|
|
this.classes = Object.create(null);
|
|
}
|
|
|
|
initializeBuiltinClasses() {
|
|
// These classes are guaranteed to not have a static initializer.
|
|
this.java_lang_Object = this.loadClass("java/lang/Object");
|
|
this.java_lang_Class = this.loadClass("java/lang/Class");
|
|
this.java_lang_String = this.loadClass("java/lang/String");
|
|
this.java_lang_Thread = this.loadClass("java/lang/Thread");
|
|
|
|
// Link primitive values and primitive arrays.
|
|
for (var i = 0; i < "ZCFDBSIJ".length; i++) {
|
|
var typeName = "ZCFDBSIJ"[i];
|
|
linkKlass(PrimitiveClassInfo[typeName]);
|
|
this.getClass("[" + typeName);
|
|
}
|
|
}
|
|
|
|
addPath(name: string, buffer: ArrayBuffer) {
|
|
if (name.substr(-4) === ".jar") {
|
|
this.classFiles[name] = new ZipFile(buffer);
|
|
} else {
|
|
this.classFiles[name] = buffer;
|
|
}
|
|
}
|
|
|
|
addSourceDirectory(name: string) {
|
|
this.sourceDirectories.push(name);
|
|
}
|
|
|
|
getSourceLine(sourceLocation: SourceLocation): string {
|
|
if (typeof snarf === "undefined") {
|
|
// Sorry, no snarf in the browser. Do async loading instead.
|
|
return null;
|
|
}
|
|
var source = this.sourceFiles[sourceLocation.className];
|
|
if (!source && !this.missingSourceFiles[sourceLocation.className]) {
|
|
for (var i = 0; i < this.sourceDirectories.length; i++) {
|
|
try {
|
|
var path = this.sourceDirectories[i] + "/" + sourceLocation.className + ".java";
|
|
var file = snarf(path);
|
|
if (file) {
|
|
source = this.sourceFiles[sourceLocation.className] = file.split("\n");
|
|
}
|
|
} catch (x) {
|
|
// Keep looking.
|
|
//stderrWriter.writeLn("" + x);
|
|
}
|
|
}
|
|
}
|
|
if (source) {
|
|
return source[sourceLocation.lineNumber - 1];
|
|
}
|
|
this.missingSourceFiles[sourceLocation.className] = true;
|
|
return null;
|
|
}
|
|
|
|
loadFileFromJar(jarName: string, fileName: string): ArrayBuffer {
|
|
var classFiles = this.classFiles;
|
|
var zip = classFiles[jarName];
|
|
if (!zip)
|
|
return null;
|
|
if (!(fileName in zip.directory))
|
|
return null;
|
|
var bytes = zip.read(fileName);
|
|
return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
}
|
|
|
|
loadFile(fileName: string): ArrayBuffer {
|
|
var classFiles = this.classFiles;
|
|
var data = classFiles[fileName];
|
|
if (data)
|
|
return data;
|
|
Object.keys(classFiles).every(function (name) {
|
|
if (name.substr(-4) !== ".jar")
|
|
return true;
|
|
var zip = classFiles[name];
|
|
if (fileName in zip.directory) {
|
|
var bytes = zip.read(fileName);
|
|
data = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
}
|
|
return !data;
|
|
});
|
|
if (data)
|
|
classFiles[fileName] = data;
|
|
return data;
|
|
}
|
|
|
|
loadClassBytes(bytes: ArrayBuffer): ClassInfo {
|
|
var classInfo = new ClassInfo(bytes);
|
|
this.classes[classInfo.className] = classInfo;
|
|
return classInfo;
|
|
}
|
|
|
|
loadClassFile(fileName: string): ClassInfo {
|
|
var bytes = this.loadFile(fileName);
|
|
if (!bytes)
|
|
throw new (ClassNotFoundException)(fileName);
|
|
var self = this;
|
|
var classInfo = this.loadClassBytes(bytes);
|
|
if (classInfo.superClassName)
|
|
classInfo.superClass = this.loadClass(classInfo.superClassName);
|
|
var classes = classInfo.classes;
|
|
classes.forEach(function (c, n) {
|
|
classes[n] = self.loadClass(c);
|
|
});
|
|
if (J2ME.phase === J2ME.ExecutionPhase.Runtime) {
|
|
J2ME.linkKlass(classInfo);
|
|
}
|
|
return classInfo;
|
|
}
|
|
|
|
loadClass (className: string): ClassInfo {
|
|
var classInfo = this.classes[className];
|
|
if (classInfo)
|
|
return classInfo;
|
|
return this.loadClassFile(className + ".class");
|
|
}
|
|
|
|
getEntryPoint(classInfo: ClassInfo): MethodInfo {
|
|
var methods = classInfo.methods;
|
|
for (var i=0; i<methods.length; i++) {
|
|
var method = methods[i];
|
|
if (method.isPublic && method.isStatic && !method.isNative &&
|
|
method.name === "main" &&
|
|
method.signature === "([Ljava/lang/String;)V") {
|
|
return method;
|
|
}
|
|
}
|
|
}
|
|
|
|
getClass(className: string): ClassInfo {
|
|
var classInfo = this.classes[className];
|
|
if (!classInfo) {
|
|
if (className[0] === "[") {
|
|
classInfo = this.createArrayClass(className);
|
|
} else {
|
|
classInfo = this.loadClass(className);
|
|
}
|
|
if (!classInfo)
|
|
return null;
|
|
}
|
|
return classInfo;
|
|
}
|
|
|
|
createArrayClass(typeName: string): ArrayClassInfo {
|
|
var elementType = typeName.substr(1);
|
|
var constructor = getArrayConstructor(elementType);
|
|
var classInfo;
|
|
if (constructor) {
|
|
classInfo = PrimitiveArrayClassInfo[elementType];
|
|
} else {
|
|
if (elementType[0] === "L") {
|
|
elementType = elementType.substr(1).replace(";", "");
|
|
}
|
|
classInfo = new ArrayClassInfo(typeName, this.getClass(elementType));
|
|
}
|
|
if (J2ME.phase === J2ME.ExecutionPhase.Runtime) {
|
|
J2ME.linkKlass(classInfo);
|
|
}
|
|
return this.classes[typeName] = classInfo;
|
|
}
|
|
|
|
|
|
getField(classInfo, fieldKey) {
|
|
if (classInfo.vfc[fieldKey]) {
|
|
return classInfo.vfc[fieldKey];
|
|
}
|
|
|
|
do {
|
|
var fields = classInfo.fields;
|
|
for (var i=0; i<fields.length; ++i) {
|
|
var field = fields[i];
|
|
if (!field.key) {
|
|
field.key = (ACCESS_FLAGS.isStatic(field.access_flags) ? "S" : "I") + "." + field.name + "." + field.signature;
|
|
}
|
|
if (field.key === fieldKey) {
|
|
return classInfo.vfc[fieldKey] = field;
|
|
}
|
|
}
|
|
|
|
if (fieldKey[0] === 'S') {
|
|
for (var n = 0; n < classInfo.interfaces.length; ++n) {
|
|
var field = this.getField(classInfo.interfaces[n], fieldKey);
|
|
if (field) {
|
|
return classInfo.vfc[fieldKey] = field;
|
|
}
|
|
}
|
|
}
|
|
|
|
classInfo = classInfo.superClass;
|
|
} while (classInfo);
|
|
}
|
|
|
|
getMethod(classInfo, methodKey) {
|
|
var c = classInfo;
|
|
do {
|
|
var methods = c.methods;
|
|
for (var i=0; i<methods.length; ++i) {
|
|
var method = methods[i];
|
|
if (method.key === methodKey) {
|
|
return classInfo.vmc[methodKey] = method;
|
|
}
|
|
}
|
|
c = c.superClass;
|
|
} while (c);
|
|
|
|
if (ACCESS_FLAGS.isInterface(classInfo.access_flags)) {
|
|
for (var n = 0; n < classInfo.interfaces.length; ++n) {
|
|
var method = this.getMethod(classInfo.interfaces[n], methodKey);
|
|
if (method) {
|
|
return classInfo.vmc[methodKey] = method;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
export var ClassNotFoundException = function(message) {
|
|
this.message = message;
|
|
};
|
|
|
|
ClassNotFoundException.prototype = Object.create(Error.prototype);
|
|
ClassNotFoundException.prototype.name = "ClassNotFoundException";
|
|
ClassNotFoundException.prototype.constructor = ClassNotFoundException;
|
|
}
|
|
|