mozilla
/
pluotsorbet
зеркало из https://github.com/mozilla/pluotsorbet.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Fix merge

This commit is contained in:
Marco Castelluccio 2015-03-06 16:22:30 +01:00
Родитель a70ccbda0c
Коммит 129c49a5d9
1 изменённых файлов: 0 добавлений и 597 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

597
actors.ts
Просмотреть файл

@ -1,597 +0,0 @@
module J2ME {
declare var Native, Override;
declare var missingNativeImpl;
declare var CC;
declare var Signature;
declare var classObjects;
declare var util;
export interface ConstantPoolEntry {
tag: TAGS;
name_index: number;
bytes: string;
class_index: number;
name_and_type_index: number;
signature_index: number;
string_index: number;
integer: number;
float: number;
double: number;
highBits: number;
lowBits: number;
}
export interface ExceptionHandler {
start_pc: number;
end_pc: number;
handler_pc: number;
catch_type: number;
}
export class SourceLocation {
constructor(public className: string, public sourceFile: string, public lineNumber: number) {
// ...
}
toString() {
return this.sourceFile + ":" + this.lineNumber;
}
equals(other: SourceLocation): boolean {
if (!other) {
return false;
}
return this.sourceFile === other.sourceFile &&
this.lineNumber === other.lineNumber;
}
}
export class FieldInfo {
private static _nextiId = 0;
id: number;
isStatic: boolean ;
constantValue: any;
mangledName: string;
key: string;
kind: Kind;
constructor(public classInfo: ClassInfo, public access_flags: number, public name: string, public signature: string) {
this.id = FieldInfo._nextiId++;
this.isStatic = AccessFlags.isStatic(access_flags);
this.constantValue = undefined;
this.mangledName = undefined;
this.key = undefined;
this.kind = getSignatureKind(signature);
}
get(object: java.lang.Object) {
return object[this.mangledName];
}
set(object: java.lang.Object, value: any) {
object[this.mangledName] = value
}
getStatic() {
return this.get(this.classInfo.getStaticObject($.ctx));
}
setStatic(value: any) {
return this.set(this.classInfo.getStaticObject($.ctx), value);
}
toString() {
return "[field " + this.name + "]";
}
}
/**
* Required params:
* - name
* - signature
* - classInfo
*
* Optional params:
* - attributes (defaults to [])
* - code (if not provided, pulls from attributes)
* - isNative, isPublic, isStatic, isSynchronized
*/
export class MethodInfo {
name: string;
classInfo: ClassInfo;
code: Uint8Array;
isNative: boolean;
isPublic: boolean;
isStatic: boolean;
isSynchronized: boolean;
isAbstract: boolean;
isFinal: boolean;
/**
* There is a compiled version of this method.?
*/
state: MethodState;
exception_table: ExceptionHandler [];
max_locals: number;
max_stack: number;
argumentSlots: number;
/**
* The number of arguments to pop of the stack when calling this function.
*/
consumeArgumentSlots: number;
hasTwoSlotArguments: boolean;
signatureDescriptor: SignatureDescriptor;
signature: string;
implKey: string;
key: string;
alternateImpl: {()};
fn: {()};
attributes: any [];
mangledName: string;
mangledClassAndMethodName: string;
onStackReplacementEntryPoints: number [];
line_number_table: {start_pc: number; line_number: number} [];
/**
* Approximate number of bytecodes executed in this method.
*/
bytecodeCount: number;
/**
* Approximate number of times this method was called.
*/
callCount: number;
/**
* Approximate number of times this method was called.
*/
interpreterCallCount: number;
/**
* Approximate number of times a backward branch was taken.
*/
backwardsBranchCount: number;
/**
* Number of times this method's counters were reset.
*/
resetCount: number;
/**
* Whether this method's bytecode has been optimized for quicker interpretation.
*/
isOptimized: boolean;
constructor(opts) {
this.name = opts.name;
this.signature = opts.signature;
this.classInfo = opts.classInfo;
this.attributes = opts.attributes || [];
// Use code if provided, otherwise search for the code within attributes.
if (opts.code) {
this.code = opts.code;
this.exception_table = [];
this.max_locals = undefined; // Unused for now.
} else {
for (var i = 0; i < this.attributes.length; i++) {
var a = this.attributes[i];
if (a.info.type === ATTRIBUTE_TYPES.Code) {
this.code = new Uint8Array(a.info.code);
this.exception_table = a.info.exception_table;
this.max_locals = a.info.max_locals;
this.max_stack = a.info.max_stack;
var codeAttributes = a.info.attributes;
for (var j = 0; j < codeAttributes.length; j++) {
var b = codeAttributes[j];
if (b.info.type === ATTRIBUTE_TYPES.LineNumberTable) {
this.line_number_table = b.info.line_number_table;
}
}
break;
}
}
}
this.isNative = opts.isNative;
this.isPublic = opts.isPublic;
this.isStatic = opts.isStatic;
this.isSynchronized = opts.isSynchronized;
this.isAbstract = opts.isAbstract;
this.isFinal = opts.isFinal;
this.state = MethodState.Cold;
this.key = (this.isStatic ? "S." : "I.") + this.name + "." + this.signature;
this.implKey = this.classInfo.className + "." + this.name + "." + this.signature;
this.mangledName = mangleMethod(this);
this.mangledClassAndMethodName = mangleClassAndMethod(this);
this.signatureDescriptor = SignatureDescriptor.makeSignatureDescriptor(this.signature);
this.hasTwoSlotArguments = this.signatureDescriptor.hasTwoSlotArguments();
this.argumentSlots = this.signatureDescriptor.getArgumentSlotCount();
this.consumeArgumentSlots = this.argumentSlots;
if (!this.isStatic) {
this.consumeArgumentSlots ++;
}
this.callCount = 0;
this.resetCount = 0;
this.interpreterCallCount = 0;
this.backwardsBranchCount = 0;
this.bytecodeCount = 0;
this.isOptimized = false;
this.onStackReplacementEntryPoints = null;
}
public getReturnKind(): Kind {
return this.signatureDescriptor.typeDescriptors[0].kind;
}
getSourceLocationForPC(pc: number): SourceLocation {
var sourceFile = this.classInfo.sourceFile || null;
if (!sourceFile) {
return null;
}
var lineNumber = -1;
if (this.line_number_table && this.line_number_table.length) {
var table = this.line_number_table;
for (var i = 0; i < table.length; i++) {
if (pc >= table[i].start_pc) {
lineNumber = table[i].line_number;
} else if (pc < table[i].start_pc) {
break;
}
}
}
return new SourceLocation(this.classInfo.className, sourceFile, lineNumber)
}
}
var classID = 0;
export class ClassInfo {
className: string;
c: string;
superClass: ClassInfo;
superClassName: string;
interfaces: ClassInfo [];
fields: FieldInfo [];
methods: MethodInfo [];
staticInitializer: MethodInfo;
classes: any [];
subClasses: ClassInfo [];
allSubClasses: ClassInfo [];
constant_pool: ConstantPoolEntry [];
resolved_constant_pool: any [];
isArrayClass: boolean;
elementClass: ClassInfo;
klass: Klass;
access_flags: number;
vmc: any;
vfc: any;
mangledName: string;
thread: any;
id: number;
sourceFile: string;
static createFromObject(object) {
var classInfo = Object.create(ClassInfo.prototype, object);
classInfo.resolved_constant_pool = new Array(classInfo.constant_pool.length);
classInfo.mangledName = mangleClass(classInfo);
return classInfo;
}
constructor(classBytes) {
this.id = classID ++;
enterTimeline("getClassImage");
var classImage = getClassImage(classBytes);
leaveTimeline("getClassImage");
var cp = classImage.constant_pool;
this.className = cp[cp[classImage.this_class].name_index].bytes;
this.superClassName = classImage.super_class ? cp[cp[classImage.super_class].name_index].bytes : null;
this.access_flags = classImage.access_flags;
this.constant_pool = cp;
this.resolved_constant_pool = new Array(cp.length);
this.subClasses = [];
this.allSubClasses = [];
// Cache for virtual methods and fields
this.vmc = {};
this.vfc = {};
this.mangledName = mangleClass(this);
var self = this;
this.interfaces = [];
for (var i = 0; i < classImage.interfaces.length; i++) {
var j = classImage.interfaces[i];
var int = CLASSES.loadClass(cp[cp[j].name_index].bytes);
self.interfaces.push(int);
self.interfaces = self.interfaces.concat(int.interfaces);
}
this.fields = [];
for (var i = 0; i < classImage.fields.length; i++) {
var f = classImage.fields[i];
var field = new FieldInfo(self, f.access_flags, cp[f.name_index].bytes, cp[f.descriptor_index].bytes);
f.attributes.forEach(function (attribute) {
if (cp[attribute.attribute_name_index].bytes === "ConstantValue")
field.constantValue = new DataView(attribute.info).getUint16(0, false);
});
self.fields.push(field);
}
enterTimeline("methods");
this.methods = [];
for (var i = 0; i < classImage.methods.length; i++) {
var m = classImage.methods[i];
var methodInfo = new MethodInfo({
name: cp[m.name_index].bytes,
signature: cp[m.signature_index].bytes,
classInfo: self,
attributes: m.attributes,
isNative: AccessFlags.isNative(m.access_flags),
isPublic: AccessFlags.isPublic(m.access_flags),
isStatic: AccessFlags.isStatic(m.access_flags),
isSynchronized: AccessFlags.isSynchronized(m.access_flags),
isAbstract: AccessFlags.isAbstract(m.access_flags),
isFinal: AccessFlags.isFinal(m.access_flags)
});
this.methods.push(methodInfo);
if (methodInfo.name === "<clinit>") {
this.staticInitializer = methodInfo;
}
}
leaveTimeline("methods");
var classes = this.classes = [];
for (var i = 0; i < classImage.attributes.length; i++) {
var a = classImage.attributes[i];
if (a.info.type === ATTRIBUTE_TYPES.InnerClasses) {
a.info.classes.forEach(function (c) {
classes.push(cp[cp[c.inner_class_info_index].name_index].bytes);
if (c.outer_class_info_index)
classes.push(cp[cp[c.outer_class_info_index].name_index].bytes);
});
} else if (a.info.type === ATTRIBUTE_TYPES.SourceFile) {
self.sourceFile = cp[a.info.sourcefile_index].bytes;
}
}
}
public complete() {
enterTimeline("mangleFields");
this._mangleFields();
leaveTimeline("mangleFields");
}
/**
* Gets the class hierarchy in derived -> base order.
*/
private _getClassHierarchy(): ClassInfo [] {
var classHierarchy = [];
var classInfo = this;
do {
classHierarchy.push(classInfo);
classInfo = classInfo.superClass;
} while (classInfo);
return classHierarchy;
}
private _mangleFields() {
// Keep track of how many times a field name was used and resolve conflicts by
// prefixing filed names with numbers.
var classInfo: ClassInfo;
var classHierarchy = this._getClassHierarchy();
var count = Object.create(null);
for (var i = classHierarchy.length - 1; i >= 0; i--) {
classInfo = classHierarchy[i];
var fields = classInfo.fields;
for (var j = 0; j < fields.length; j++) {
var field = fields[j];
var fieldName = field.name;
if (count[field.name] === undefined) {
count[fieldName] = 0;
}
var fieldCount = count[fieldName];
// Only mangle this classInfo's fields.
if (i === 0) {
field.mangledName = "$" + (fieldCount ? "$" + fieldCount : "") + field.name;
}
count[fieldName] ++;
}
}
}
get isInterface() : boolean {
return AccessFlags.isInterface(this.access_flags);
}
get isFinal() : boolean {
return AccessFlags.isFinal(this.access_flags);
}
implementsInterface(iface) : boolean {
var classInfo = this;
do {
var interfaces = classInfo.interfaces;
for (var n = 0; n < interfaces.length; ++n) {
if (interfaces[n] === iface)
return true;
}
classInfo = classInfo.superClass;
} while (classInfo);
return false;
}
isAssignableTo(toClass: ClassInfo) : boolean {
if (this === toClass || toClass === CLASSES.java_lang_Object)
return true;
if (AccessFlags.isInterface(toClass.access_flags) && this.implementsInterface(toClass))
return true;
if (this.elementClass && toClass.elementClass)
return this.elementClass.isAssignableTo(toClass.elementClass);
return this.superClass ? this.superClass.isAssignableTo(toClass) : false;
}
/**
* java.lang.Class object for this class info. This is a not where static properties
* are stored for this class.
*/
getClassObject(): java.lang.Class {
return $.getRuntimeKlass(this.klass).classObject;
}
/**
* Object that holds static properties for this class.
*/
getStaticObject(ctx: Context): java.lang.Object {
return <java.lang.Object><any>ctx.runtime.getRuntimeKlass(this.klass);
}
getField(fieldKey: string) : FieldInfo {
return CLASSES.getField(this, fieldKey);
}
toString() {
return "[class " + this.className + "]";
}
/**
* Resolves a constant pool reference.
*/
resolve(index: number, isStatic: boolean) {
var rp = this.resolved_constant_pool;
var constant: any = rp[index];
if (constant !== undefined) {
return constant;
}
var cp = this.constant_pool;
var entry = this.constant_pool[index];
switch (entry.tag) {
case TAGS.CONSTANT_Integer:
constant = entry.integer;
break;
case TAGS.CONSTANT_Float:
constant = entry.float;
break;
case TAGS.CONSTANT_String:
constant = $.newStringConstant(cp[entry.string_index].bytes);
break;
case TAGS.CONSTANT_Long:
constant = Long.fromBits(entry.lowBits, entry.highBits);
break;
case TAGS.CONSTANT_Double:
constant = entry.double;
break;
case TAGS.CONSTANT_Class:
constant = CLASSES.getClass(cp[entry.name_index].bytes);
break;
case TAGS.CONSTANT_Fieldref:
var classInfo = this.resolve(entry.class_index, isStatic);
var fieldName = cp[cp[entry.name_and_type_index].name_index].bytes;
var signature = cp[cp[entry.name_and_type_index].signature_index].bytes;
constant = CLASSES.getField(classInfo, (isStatic ? "S" : "I") + "." + fieldName + "." + signature);
if (!constant) {
throw $.newRuntimeException(
classInfo.className + "." + fieldName + "." + signature + " not found");
}
break;
case TAGS.CONSTANT_Methodref:
case TAGS.CONSTANT_InterfaceMethodref:
var classInfo = this.resolve(entry.class_index, isStatic);
var methodName = cp[cp[entry.name_and_type_index].name_index].bytes;
var signature = cp[cp[entry.name_and_type_index].signature_index].bytes;
constant = CLASSES.getMethod(classInfo, (isStatic ? "S" : "I") + "." + methodName + "." + signature);
if (!constant) {
constant = CLASSES.getMethod(classInfo, (isStatic ? "S" : "I") + "." + methodName + "." + signature);
throw $.newRuntimeException(
classInfo.className + "." + methodName + "." + signature + " not found");
}
break;
default:
throw new Error("not support constant type");
}
return rp[index] = constant;
}
}
export class ArrayClassInfo extends ClassInfo {
constructor(className: string, elementClass: ClassInfo, mangledName?: string) {
false && super(null);
this.className = className;
// TODO this may need to change for compiled code.
this.mangledName = mangledName || mangleClassName(className);
this.superClass = CLASSES.java_lang_Object;
this.superClassName = "java/lang/Object";
this.access_flags = 0;
this.elementClass = elementClass;
this.vmc = {};
this.vfc = {};
}
implementsInterface(iface) {
return false;
}
}
ArrayClassInfo.prototype.fields = [];
ArrayClassInfo.prototype.methods = [];
ArrayClassInfo.prototype.interfaces = [];
ArrayClassInfo.prototype.isArrayClass = true;
export class PrimitiveClassInfo extends ClassInfo {
constructor(className: string, mangledName: string) {
false && super(null);
this.className = className;
this.mangledName = mangledName;
}
static Z = new PrimitiveClassInfo("Z", "boolean");
static C = new PrimitiveClassInfo("C", "char");
static F = new PrimitiveClassInfo("F", "float");
static D = new PrimitiveClassInfo("D", "double");
static B = new PrimitiveClassInfo("B", "byte");
static S = new PrimitiveClassInfo("S", "short");
static I = new PrimitiveClassInfo("I", "int");
static J = new PrimitiveClassInfo("J", "long");
}
PrimitiveClassInfo.prototype.fields = [];
PrimitiveClassInfo.prototype.methods = [];
PrimitiveClassInfo.prototype.interfaces = [];
export class PrimitiveArrayClassInfo extends ArrayClassInfo {
constructor(className: string, elementClass: ClassInfo, mangledName: string) {
super(className, elementClass, mangledName);
}
get superClass() {
return CLASSES.java_lang_Object;
}
static Z = new PrimitiveArrayClassInfo("[Z", PrimitiveClassInfo.Z, "Uint8Array");
static C = new PrimitiveArrayClassInfo("[C", PrimitiveClassInfo.C, "Uint16Array");
static F = new PrimitiveArrayClassInfo("[F", PrimitiveClassInfo.F, "Float32Array");
static D = new PrimitiveArrayClassInfo("[D", PrimitiveClassInfo.D, "Float64Array");
static B = new PrimitiveArrayClassInfo("[B", PrimitiveClassInfo.B, "Int8Array");
static S = new PrimitiveArrayClassInfo("[S", PrimitiveClassInfo.S, "Int16Array");
static I = new PrimitiveArrayClassInfo("[I", PrimitiveClassInfo.I, "Int32Array");
static J = new PrimitiveArrayClassInfo("[J", PrimitiveClassInfo.J, "Int64Array");
}
PrimitiveClassInfo.prototype.fields = [];
PrimitiveClassInfo.prototype.methods = [];
PrimitiveClassInfo.prototype.interfaces = [];
}
var FieldInfo = J2ME.FieldInfo;
var MethodInfo = J2ME.MethodInfo;
var ClassInfo = J2ME.ClassInfo;