|
static private Emit ( |
||
| ast | ||
| il | ILGenerator | |
| source_type | ||
| target_type | ||
| return | void | |
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets)
{
MethodInfo meth = this.method;
if (meth != null)
{
Type t = meth.ReflectedType;
if (!meth.IsStatic)
{
this.method = null;
this.TranslateToIL(il, t);
this.method = meth;
}
ParameterInfo[] pars = meth.GetParameters();
Binding.PlaceArgumentsOnStack(il, pars, argList, 0, 0, Binding.ReflectionMissingCW);
if (meth.IsVirtual && !meth.IsFinal && !t.IsSealed)
{
il.Emit(OpCodes.Callvirt, meth);
}
else
{
il.Emit(OpCodes.Call, meth);
}
Convert.Emit(this, il, meth.ReturnType, rtype);
}
else
{
base.TranslateToILCall(il, rtype, argList, construct, brackets);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (rtype == Typeob.Void)
{
return;
}
IReflect ir = this.InferType(null);
if (ir is GlobalScope)
{
this.EmitILToLoadEngine(il);
if (rtype == Typeob.LenientGlobalObject)
{
il.Emit(OpCodes.Call, CompilerGlobals.getLenientGlobalObjectMethod);
}
else
{
il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod);
il.Emit(OpCodes.Castclass, CompilerGlobals.iActivationObjectClass);
il.Emit(OpCodes.Callvirt, CompilerGlobals.getDefaultThisObjectMethod);
}
return;
}
il.Emit(OpCodes.Ldarg_0);
Convert.Emit(this, il, Convert.ToType(this.InferType(null)), rtype);
}
internal virtual void TranslateToConditionalBranch(ILGenerator il, bool branchIfTrue, Label label, bool shortForm)
{
//This method is overridden in all interesting cases.
IReflect ir = this.InferType(null);
if (ir != Typeob.Object && ir is Type)
{
String op = branchIfTrue ? "op_True" : "op_False";
MethodInfo meth = ir.GetMethod(op, BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static, null, new Type[] { (Type)ir }, null);
if (meth != null)
{
this.TranslateToIL(il, (Type)ir);
il.Emit(OpCodes.Call, meth);
il.Emit(OpCodes.Brtrue, label);
return;
}
}
Type t = Convert.ToType(ir);
this.TranslateToIL(il, t);
Convert.Emit(this, il, t, Typeob.Boolean, true);
if (branchIfTrue)
{
il.Emit(shortForm ? OpCodes.Brtrue_S : OpCodes.Brtrue, label);
}
else
{
il.Emit(shortForm ? OpCodes.Brfalse_S : OpCodes.Brfalse, label);
}
}
internal override void TranslateToILDelete(ILGenerator il, Type rtype)
{
IReflect ir = this.func.InferType(null);
Type obType = Convert.ToType(ir);
this.func.TranslateToIL(il, obType);
this.args.TranslateToIL(il, Typeob.ArrayOfObject);
if (this.func is Binding)
{
MethodInfo deleteOp;
if (ir is ClassScope)
{
deleteOp = ((ClassScope)ir).owner.deleteOpMethod;
}
else
{
deleteOp = ir.GetMethod("op_Delete", BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static,
null, new Type[] { obType, Typeob.ArrayOfObject }, null);
}
if (deleteOp != null && (deleteOp.Attributes & MethodAttributes.SpecialName) != 0 && deleteOp.ReturnType == Typeob.Boolean)
{
il.Emit(OpCodes.Call, deleteOp);
Convert.Emit(this, il, Typeob.Boolean, rtype);
return;
}
}
ConstantWrapper.TranslateToILInt(il, this.args.count - 1);
il.Emit(OpCodes.Ldelem_Ref);
Convert.Emit(this, il, Typeob.Object, Typeob.String);
il.Emit(OpCodes.Call, CompilerGlobals.deleteMemberMethod);
Convert.Emit(this, il, Typeob.Boolean, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
this.operand1.TranslateToIL(il, Typeob.Object);
this.operand2.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Call, CompilerGlobals.jScriptInMethod);
Convert.Emit(this, il, Typeob.Boolean, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
//This assumes that rtype == Void.class.
this.context.EmitLineInfo(il);
if (this.operand != null)
{
this.operand.TranslateToIL(il, this.enclosingFunctionScope.returnVar.FieldType);
}
else if (this.enclosingFunctionScope.returnVar != null)
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.undefinedField);
Convert.Emit(this, il, Typeob.Object, this.enclosingFunctionScope.returnVar.FieldType);
}
if (this.enclosingFunctionScope.returnVar != null)
{
il.Emit(OpCodes.Stloc, (LocalBuilder)this.enclosingFunctionScope.returnVar.GetMetaData());
}
if (this.leavesFinally)
{
il.Emit(OpCodes.Newobj, CompilerGlobals.returnOutOfFinallyConstructor);
il.Emit(OpCodes.Throw);
}
else if (compilerGlobals.InsideProtectedRegion)
{
il.Emit(OpCodes.Leave, this.enclosingFunctionScope.owner.returnLabel);
}
else
{
il.Emit(OpCodes.Br, this.enclosingFunctionScope.owner.returnLabel);
}
}
internal virtual void TranslateToILDelete(ILGenerator il, Type rtype)
{
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Ldc_I4_1); //This is according to spec, but not backwards compatible with JS5. The latter throws an exception.
Convert.Emit(this, il, Typeob.Boolean, rtype);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (this.metaData == null)
{
TranslateToILForNoOverloadCase(il, rtype);
return;
}
if (this.metaData is MethodInfo)
{
Object result = null;
MethodInfo oper = (MethodInfo)this.metaData;
Type type = Convert.ToType(this.operand1.InferType(null));
ParameterInfo[] pars = oper.GetParameters();
this.operand1.TranslateToILPreSetPlusGet(il);
Convert.Emit(this, il, type, pars[0].ParameterType);
this.operand2.TranslateToIL(il, pars[1].ParameterType);
il.Emit(OpCodes.Call, oper);
if (rtype != Typeob.Void)
{
result = il.DeclareLocal(rtype);
il.Emit(OpCodes.Dup);
Convert.Emit(this, il, type, rtype);
il.Emit(OpCodes.Stloc, (LocalBuilder)result);
}
Convert.Emit(this, il, oper.ReturnType, type);
this.operand1.TranslateToILSet(il);
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Ldloc, (LocalBuilder)result);
}
}
else
{
//Getting here is just too bad. We do not know until the code runs whether or not to call an overloaded operator method.
//Compile operands to objects and devolve the decision making to run time thunks
Type type = Convert.ToType(this.operand1.InferType(null));
LocalBuilder result = il.DeclareLocal(Typeob.Object);
this.operand1.TranslateToILPreSetPlusGet(il);
Convert.Emit(this, il, type, Typeob.Object);
il.Emit(OpCodes.Stloc, result);
il.Emit(OpCodes.Ldloc, (LocalBuilder)this.metaData);
il.Emit(OpCodes.Ldloc, result);
this.operand2.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Call, CompilerGlobals.evaluatePlusMethod);
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, result);
}
Convert.Emit(this, il, Typeob.Object, type);
this.operand1.TranslateToILSet(il);
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Ldloc, result);
Convert.Emit(this, il, Typeob.Object, rtype);
}
}
}
private void TranslateToILForNoOverloadCase(ILGenerator il, Type rtype)
{
Type lhtype = Convert.ToType(this.operand1.InferType(null));
Type operand2type = Convert.ToType(this.operand2.InferType(null));
Type bbrType = BitwiseBinary.ResultType(lhtype, operand2type, this.operatorTok);
this.operand1.TranslateToILPreSetPlusGet(il);
Convert.Emit(this, il, lhtype, bbrType, true);
this.operand2.TranslateToIL(il, operand2type);
Convert.Emit(this, il, operand2type, BitwiseBinary.Operand2Type(this.operatorTok, bbrType), true);
switch (this.operatorTok)
{
case JSToken.BitwiseAnd:
il.Emit(OpCodes.And);
break;
case JSToken.BitwiseOr:
il.Emit(OpCodes.Or);
break;
case JSToken.BitwiseXor:
il.Emit(OpCodes.Xor);
break;
case JSToken.LeftShift:
BitwiseBinary.TranslateToBitCountMask(il, bbrType, this.operand2);
il.Emit(OpCodes.Shl);
break;
case JSToken.RightShift:
BitwiseBinary.TranslateToBitCountMask(il, bbrType, this.operand2);
il.Emit(OpCodes.Shr);
break;
case JSToken.UnsignedRightShift:
BitwiseBinary.TranslateToBitCountMask(il, bbrType, this.operand2);
il.Emit(OpCodes.Shr_Un);
break;
default:
throw new JScriptException(JSError.InternalError, this.context);
}
if (rtype != Typeob.Void)
{
LocalBuilder result = il.DeclareLocal(bbrType);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, result);
Convert.Emit(this, il, bbrType, lhtype);
this.operand1.TranslateToILSet(il);
il.Emit(OpCodes.Ldloc, result);
Convert.Emit(this, il, bbrType, rtype);
}
else
{
Convert.Emit(this, il, bbrType, lhtype);
this.operand1.TranslateToILSet(il);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
Type t1 = Convert.ToType(this.operand1.InferType(null));
Type t2 = Convert.ToType(this.operand2.InferType(null));
if (t1 != t2)
{
t1 = Typeob.Object;
}
MethodInfo opTrue = t1.GetMethod("op_True", BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static, null, new Type[] { t1 }, null);
if (opTrue == null || (opTrue.Attributes & MethodAttributes.SpecialName) == 0 || opTrue.ReturnType != Typeob.Boolean)
{
opTrue = null;
}
MethodInfo bitwiseOr = null;
if (opTrue != null)
{
bitwiseOr = t1.GetMethod("op_BitwiseOr", BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static, null, new Type[] { t1, t1 }, null);
}
if (bitwiseOr == null || (bitwiseOr.Attributes & MethodAttributes.SpecialName) == 0)
{
opTrue = null;
}
Label exit = il.DefineLabel();
this.operand1.TranslateToIL(il, t1);
il.Emit(OpCodes.Dup);
if (opTrue != null)
{
if (t1.IsValueType)
{
Convert.EmitLdloca(il, t1);
}
il.Emit(OpCodes.Call, opTrue);
il.Emit(OpCodes.Brtrue, exit);
this.operand2.TranslateToIL(il, t1);
il.Emit(OpCodes.Call, bitwiseOr);
il.MarkLabel(exit);
Convert.Emit(this, il, bitwiseOr.ReturnType, rtype);
}
else
{
Convert.Emit(this, il, t1, Typeob.Boolean, true);
il.Emit(OpCodes.Brtrue, exit);
il.Emit(OpCodes.Pop);
this.operand2.TranslateToIL(il, t1);
il.MarkLabel(exit);
Convert.Emit(this, il, t1, rtype);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
Label true_label = il.DefineLabel();
Label done_label = il.DefineLabel();
this.TranslateToConditionalBranch(il, true, true_label, true);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Br_S, done_label);
il.MarkLabel(true_label);
il.Emit(OpCodes.Ldc_I4_1);
il.MarkLabel(done_label);
Convert.Emit(this, il, Typeob.Boolean, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
this.operand.TranslateToIL(il, Typeob.Object); //force evaluation
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.undefinedField);
Convert.Emit(this, il, Typeob.Object, rtype);
}
else
{
il.Emit(OpCodes.Pop);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (this.operand is Binding)
{
//Make sure that no exception is thrown if the operand is an undefined identifier
((Binding)this.operand).TranslateToIL(il, Typeob.Object, true);
}
else
{
this.operand.TranslateToIL(il, Typeob.Object);
}
il.Emit(OpCodes.Call, CompilerGlobals.jScriptTypeofMethod);
Convert.Emit(this, il, Typeob.String, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (this.enclosingFunctionScope != null && this.enclosingFunctionScope.owner != null)
{
this.enclosingFunctionScope.owner.TranslateToILToSaveLocals(il);
}
this.operand.TranslateToIL(il, Typeob.Object);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.jScriptEvaluateMethod);
Convert.Emit(this, il, Typeob.Object, rtype);
if (this.enclosingFunctionScope != null && this.enclosingFunctionScope.owner != null)
{
this.enclosingFunctionScope.owner.TranslateToILToRestoreLocals(il);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
foreach (CustomAttributeBuilder ca in this.list.GetCustomAttributeBuilders(false))
{
this.compilerGlobals.assemblyBuilder.SetCustomAttribute(ca);
}
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Ldnull);
if (rtype.IsValueType)
{
Convert.Emit(this, il, Typeob.Object, rtype);
}
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
int n = this.keys.Length;
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.getOriginalObjectConstructorMethod);
il.Emit(OpCodes.Call, CompilerGlobals.constructObjectMethod);
for (int i = 0; i < n; i++)
{
il.Emit(OpCodes.Dup);
this.keys[i].TranslateToIL(il, Typeob.String);
this.values[i].TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Call, CompilerGlobals.setMemberValue2Method);
}
Convert.Emit(this, il, Typeob.Object, rtype);
}
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets)
{
if (this.isFullyResolved)
{
base.TranslateToILCall(il, rtype, argList, construct, brackets);
return;
}
//Need to do a dynamic lookup to see if there is a dynamically introduced (by eval or with) hiding definition.
Label lateBoundCall = il.DefineLabel();
Label done = il.DefineLabel();
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod);
il.Emit(OpCodes.Castclass, Typeob.IActivationObject);
il.Emit(OpCodes.Ldstr, this.name);
ConstantWrapper.TranslateToILInt(il, this.lexLevel);
il.Emit(OpCodes.Callvirt, CompilerGlobals.getMemberValueMethod);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Call, CompilerGlobals.isMissingMethod);
il.Emit(OpCodes.Brfalse, lateBoundCall); //dynamic lookup succeeded, do not call early bound method
il.Emit(OpCodes.Pop); //The dynamic lookup returned Missing.Value, discard it and go on to use the value from the early bound location.
base.TranslateToILCall(il, Typeob.Object, argList, construct, brackets);
il.Emit(OpCodes.Br, done); //Skip over the latebound call sequence
il.MarkLabel(lateBoundCall);
this.TranslateToILDefaultThisObject(il);
argList.TranslateToIL(il, Typeob.ArrayOfObject);
if (construct)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
if (brackets)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValue2Method);
il.MarkLabel(done);
Convert.Emit(this, il, Typeob.Object, rtype);
}
protected override void TranslateToILWithDupOfThisOb(ILGenerator il)
{
IReflect ir = this.rootObject.InferType(null);
Type tempType = Convert.ToType(ir);
this.rootObject.TranslateToIL(il, tempType);
if (ir == Typeob.Object || ir == Typeob.String || ir is TypedArray || (ir == tempType && Typeob.Array.IsAssignableFrom(tempType)))
{
tempType = Typeob.Object;
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
}
il.Emit(OpCodes.Dup);
this.temp = il.DeclareLocal(tempType);
il.Emit(OpCodes.Stloc, temp);
Convert.Emit(this, il, tempType, Typeob.Object);
this.TranslateToIL(il, Typeob.Object);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
//This assumes that rtype == Void.class
Label loop_start = il.DefineLabel();
Label loop_end = il.DefineLabel();
Label body = il.DefineLabel();
compilerGlobals.BreakLabelStack.Push(loop_end);
compilerGlobals.ContinueLabelStack.Push(loop_start);
if (this.initializer != null)
{
this.initializer.TranslateToIL(il, Typeob.Void);
}
this.inExpressionContext.EmitLineInfo(il);
this.collection.TranslateToIL(il, Typeob.Object);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toForInObjectMethod);
il.Emit(OpCodes.Call, CompilerGlobals.jScriptGetEnumeratorMethod);
LocalBuilder enumerator = il.DeclareLocal(Typeob.IEnumerator);
il.Emit(OpCodes.Stloc, enumerator);
il.Emit(OpCodes.Br, loop_start);
il.MarkLabel(body);
this.body.TranslateToIL(il, Typeob.Void);
il.MarkLabel(loop_start);
this.context.EmitLineInfo(il);
il.Emit(OpCodes.Ldloc, enumerator);
il.Emit(OpCodes.Callvirt, CompilerGlobals.moveNextMethod);
il.Emit(OpCodes.Brfalse, loop_end);
il.Emit(OpCodes.Ldloc, enumerator);
il.Emit(OpCodes.Callvirt, CompilerGlobals.getCurrentMethod);
Type vt = Convert.ToType(this.var.InferType(null));
LocalBuilder val = il.DeclareLocal(vt);
Convert.Emit(this, il, Typeob.Object, vt);
il.Emit(OpCodes.Stloc, val);
this.var.TranslateToILPreSet(il);
il.Emit(OpCodes.Ldloc, val);
this.var.TranslateToILSet(il);
il.Emit(OpCodes.Br, body);
il.MarkLabel(loop_end);
compilerGlobals.BreakLabelStack.Pop();
compilerGlobals.ContinueLabelStack.Pop();
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (this.context.document.debugOn)
{
il.Emit(OpCodes.Nop);
}
ASTList astList = this.operand;
int n = astList.count;
for (int i = 0; i < n; i++)
{
AST ast = astList[i];
IReflect ir = ast.InferType(null);
if (ir == Typeob.String)
{
ast.TranslateToIL(il, Typeob.String);
}
else
{
ast.TranslateToIL(il, Typeob.Object);
ConstantWrapper.TranslateToILInt(il, 1);
il.Emit(OpCodes.Call, CompilerGlobals.toStringMethod);
}
if (i == n - 1)
{
il.Emit(OpCodes.Call, CompilerGlobals.writeLineMethod);
}
else
{
il.Emit(OpCodes.Call, CompilerGlobals.writeMethod);
}
}
if (n == 0)
{
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Call, CompilerGlobals.writeLineMethod);
}
if (rtype != Typeob.Void)
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.undefinedField);
Convert.Emit(this, il, Typeob.Object, rtype);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
Type lhtype = Convert.ToType(this.lhside.InferType(null));
this.lhside.TranslateToILPreSet(il);
if (rtype != Typeob.Void)
{
Type rhtype = Convert.ToType(this.rhside.InferType(null));
this.rhside.TranslateToIL(il, rhtype);
LocalBuilder result = il.DeclareLocal(rhtype);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, result);
Convert.Emit(this, il, rhtype, lhtype);
this.lhside.TranslateToILSet(il);
il.Emit(OpCodes.Ldloc, result);
Convert.Emit(this, il, rhtype, rtype);
}
else
{
this.lhside.TranslateToILSet(il, rhside);
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (this.enclosingFunctionScope != null && this.enclosingFunctionScope.owner != null)
{
this.enclosingFunctionScope.owner.TranslateToILToSaveLocals(il);
}
this.operand.TranslateToIL(il, Typeob.Object);
MethodInfo evaluateMethod = null;
ConstantWrapper cw = this.unsafeOption as ConstantWrapper;
if (cw != null)
{
string s = cw.value as string;
if (s != null && s == "unsafe")
{
evaluateMethod = CompilerGlobals.jScriptEvaluateMethod1;
}
}
if (evaluateMethod == null)
{
evaluateMethod = CompilerGlobals.jScriptEvaluateMethod2;
if (this.unsafeOption == null)
{
il.Emit(OpCodes.Ldnull);
}
else
{
this.unsafeOption.TranslateToIL(il, Typeob.Object);
}
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, evaluateMethod);
Convert.Emit(this, il, Typeob.Object, rtype);
if (this.enclosingFunctionScope != null && this.enclosingFunctionScope.owner != null)
{
this.enclosingFunctionScope.owner.TranslateToILToRestoreLocals(il);
}
}
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets)
{
if (this.defaultMember != null && construct && brackets)
{
base.TranslateToILCall(il, rtype, argList, construct, brackets);
return;
}
JSGlobalField gf = this.member as JSGlobalField;
if (gf != null && gf.IsLiteral && argList.count == 1)
{
Type t = Convert.ToType((IReflect)gf.value);
argList[0].TranslateToIL(il, t);
Convert.Emit(this, il, t, rtype);
return;
}
this.TranslateToILWithDupOfThisOb(il);
argList.TranslateToIL(il, typeof(Object[]));
if (construct)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
if (brackets)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
Convert.Emit(this, il, Typeob.Object, rtype);
}
protected override void TranslateToILObject(ILGenerator il, Type obType, bool noValue)
{
if (noValue && obType.IsValueType && obType != Typeob.Enum)
{
if (this.temp == null)
{
this.rootObject.TranslateToILReference(il, obType);
}
else
{
Type tempType = Convert.ToType(this.rootObject.InferType(null));
if (tempType == obType)
{
il.Emit(OpCodes.Ldloca, this.temp);
}
else
{
il.Emit(OpCodes.Ldloc, this.temp);
Convert.Emit(this, il, tempType, obType);
Convert.EmitLdloca(il, obType);
}
}
}
else
{
if (this.temp == null || this.rootObject is ThisLiteral)
{
this.rootObject.TranslateToIL(il, obType);
}
else
{
il.Emit(OpCodes.Ldloc, this.temp);
Type tempType = Convert.ToType(this.rootObject.InferType(null));
Convert.Emit(this, il, tempType, obType);
}
}
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (rtype == Typeob.Array)
{
this.TranslateToILArray(il, Typeob.Object);
return;
}
if (rtype.IsArray && rtype.GetArrayRank() == 1)
{
this.TranslateToILArray(il, rtype.GetElementType());
return;
}
int n = this.elements.count;
MethodInfo constructorMethod = null;
if (this.Engine.Globals.globalObject is LenientGlobalObject)
{
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.getOriginalArrayConstructorMethod);
constructorMethod = CompilerGlobals.constructArrayMethod;
}
else
{
constructorMethod = CompilerGlobals.fastConstructArrayLiteralMethod;
}
ConstantWrapper.TranslateToILInt(il, n);
il.Emit(OpCodes.Newarr, Typeob.Object);
for (int i = 0; i < n; i++)
{
il.Emit(OpCodes.Dup);
ConstantWrapper.TranslateToILInt(il, i);
this.elements[i].TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Stelem_Ref);
}
il.Emit(OpCodes.Call, constructorMethod);
Convert.Emit(this, il, Typeob.ArrayObject, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
this.operand1.TranslateToIL(il, Typeob.Object);
Object val = null;
if (this.operand2 is ConstantWrapper && (val = this.operand2.Evaluate()) is Type && !((Type)val).IsValueType)
{
il.Emit(OpCodes.Isinst, (Type)val);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Cgt_Un);
}
else if (val is ClassScope)
{
il.Emit(OpCodes.Isinst, ((ClassScope)val).GetTypeBuilderOrEnumBuilder());
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Cgt_Un);
}
else
{
this.operand2.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Call, CompilerGlobals.jScriptInstanceofMethod);
}
Convert.Emit(this, il, Typeob.Boolean, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
if (this.isFullyResolved)
{
base.TranslateToIL(il, rtype);
return;
}
//Need to do a dynamic lookup to see if there is a dynamically introduced (by eval or with) hiding definition.
Label done = il.DefineLabel();
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod);
il.Emit(OpCodes.Castclass, Typeob.IActivationObject);
il.Emit(OpCodes.Ldstr, this.name);
ConstantWrapper.TranslateToILInt(il, this.lexLevel);
il.Emit(OpCodes.Callvirt, CompilerGlobals.getMemberValueMethod);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Call, CompilerGlobals.isMissingMethod);
il.Emit(OpCodes.Brfalse, done); //dynamic lookup succeeded, do not use the value from the early bound location.
il.Emit(OpCodes.Pop); //The dynamic lookup returned Missing.Value, discard it and go on to use the value from the early bound location.
base.TranslateToIL(il, Typeob.Object);
il.MarkLabel(done);
Convert.Emit(this, il, Typeob.Object, rtype);
}
internal override void TranslateToIL(ILGenerator il, Type rtype)
{
//This is executed every time the function expression is executed and constructs a new closure for every execution.
if (rtype == Typeob.Void)
{
return;
}
il.Emit(OpCodes.Ldloc, this.func_local);
il.Emit(OpCodes.Newobj, CompilerGlobals.closureConstructor);
Convert.Emit(this, il, Typeob.Closure, rtype);
if (this.field != null)
{
il.Emit(OpCodes.Dup);
Object tok = this.field.GetMetaData();
if (tok is LocalBuilder)
{
il.Emit(OpCodes.Stloc, (LocalBuilder)tok);
}
else
{
il.Emit(OpCodes.Stsfld, (FieldInfo)tok);
}
}
}
private void TranslateToILForNoOverloadCase(ILGenerator il, Type rtype)
{
Type lhtype = Convert.ToType(this.operand1.InferType(null));
Type rhtype = Convert.ToType(this.operand2.InferType(null));
Type rt = Typeob.Object;
if (lhtype == Typeob.String || rhtype == Typeob.String)
{
rt = Typeob.String;
}
else if (rtype == Typeob.Void || rtype == lhtype || Convert.IsPrimitiveNumericType(lhtype) &&
(Convert.IsPromotableTo(rhtype, lhtype) || ((this.operand2 is ConstantWrapper) && ((ConstantWrapper)this.operand2).IsAssignableTo(lhtype))))
{
rt = lhtype;
}
if (rt == Typeob.SByte || rt == Typeob.Int16)
{
rt = Typeob.Int32;
}
else if (rt == Typeob.Byte || rt == Typeob.UInt16)
{
rt = Typeob.UInt32;
}
// If we have "unsigned += signed" or "signed += unsigned" then generating the
// correct code gets quite complicated. Just go late-bound for this edge case.
if (this.operand2 is ConstantWrapper)
{
if (!((ConstantWrapper)this.operand2).IsAssignableTo(rt))
{
// eg: "var u : byte = 123; u += -100;" should go late bound because
// of signed/unsigned mismatch but "u += 1" should not.
rt = Typeob.Object;
}
}
else
{
if ((Convert.IsPrimitiveSignedNumericType(rhtype) && Convert.IsPrimitiveUnsignedIntegerType(lhtype)) ||
(Convert.IsPrimitiveUnsignedIntegerType(rhtype) && Convert.IsPrimitiveSignedIntegerType(lhtype)))
{
rt = Typeob.Object;
}
}
this.operand1.TranslateToILPreSetPlusGet(il);
Convert.Emit(this, il, lhtype, rt);
this.operand2.TranslateToIL(il, rt);
if (rt == Typeob.Object || rt == Typeob.String)
{
il.Emit(OpCodes.Call, CompilerGlobals.plusDoOpMethod);
rt = Typeob.Object;
}
else if (rt == Typeob.Double || rt == Typeob.Single)
{
il.Emit(OpCodes.Add);
}
else if (rt == Typeob.Int32 || rt == Typeob.Int64 || rt == Typeob.Int16 || rt == Typeob.SByte)
{
il.Emit(OpCodes.Add_Ovf);
}
else
{
il.Emit(OpCodes.Add_Ovf_Un);
}
if (rtype != Typeob.Void)
{
LocalBuilder result = il.DeclareLocal(rt);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, result);
Convert.Emit(this, il, rt, lhtype);
this.operand1.TranslateToILSet(il);
il.Emit(OpCodes.Ldloc, result);
Convert.Emit(this, il, rt, rtype);
}
else
{
Convert.Emit(this, il, rt, lhtype);
this.operand1.TranslateToILSet(il);
}
}
internal void TranslateToILSet(ILGenerator il, bool doBoth, AST rhvalue)
{
if (this.isFullyResolved)
{
base.TranslateToILSet(il, rhvalue);
return;
}
if (rhvalue != null)
{
rhvalue.TranslateToIL(il, Typeob.Object);
}
if (this.fieldLoc == null)
{
//There is a callable value plus parameters on the stack
il.Emit(OpCodes.Call, CompilerGlobals.setIndexedPropertyValueStaticMethod);
return;
}
LocalBuilder temp = il.DeclareLocal(Typeob.Object);
if (doBoth)
{
//save copy of rh value
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, temp);
//store it in early bound location
this.isFullyResolved = true;
Convert.Emit(this, il, Typeob.Object, Convert.ToType(this.InferType(null)));
base.TranslateToILSet(il, null);
}
//See if there is a late bound field
Label earlyBound = il.DefineLabel();
il.Emit(OpCodes.Ldloc, this.fieldLoc);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Beq_S, earlyBound); //No late bound field
//store it in the late bound field
Label done = il.DefineLabel();
if (!doBoth)
{
il.Emit(OpCodes.Stloc, temp);
if (this.thereIsAnObjectOnTheStack)
{
il.Emit(OpCodes.Pop);
}
}
il.Emit(OpCodes.Ldloc, this.fieldLoc);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ldloc, temp);
il.Emit(OpCodes.Callvirt, CompilerGlobals.setFieldValueMethod);
il.Emit(OpCodes.Br_S, done);
//Alternative store it in the early bound location
il.MarkLabel(earlyBound);
if (!doBoth)
{
this.isFullyResolved = true;
Convert.Emit(this, il, Typeob.Object, Convert.ToType(this.InferType(null)));
base.TranslateToILSet(il, null);
}
il.MarkLabel(done);
}