|
private TranslateToIL ( ILGenerator il, |
||
| il | ILGenerator | |
| rtype | ||
| Résultat | void | |
internal virtual void TranslateToILPreSetPlusGet(ILGenerator il, ASTList args, bool inBrackets)
{
il.Emit(OpCodes.Ldnull);
this.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Dup);
LocalBuilder local = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, local);
args.TranslateToIL(il, Typeob.ArrayOfObject);
il.Emit(OpCodes.Dup);
LocalBuilder builder2 = il.DeclareLocal(Typeob.ArrayOfObject);
il.Emit(OpCodes.Stloc, builder2);
il.Emit(OpCodes.Ldc_I4_0);
if (inBrackets)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
LocalBuilder builder3 = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, builder3);
il.Emit(OpCodes.Ldloc, local);
il.Emit(OpCodes.Ldloc, builder2);
il.Emit(OpCodes.Ldloc, builder3);
}
internal virtual void TranslateToILPreSetPlusGet(ILGenerator il, ASTList args, bool inBrackets)
{
il.Emit(OpCodes.Ldnull); //Put a dummy this obj on the stack for CallValue's sake
this.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Dup);
LocalBuilder savedOb = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, savedOb);
args.TranslateToIL(il, typeof(Object[]));
il.Emit(OpCodes.Dup);
LocalBuilder savedArgs = il.DeclareLocal(typeof(Object[]));
il.Emit(OpCodes.Stloc, savedArgs);
il.Emit(OpCodes.Ldc_I4_0);
if (inBrackets)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
LocalBuilder savedResult = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, savedResult);
il.Emit(OpCodes.Ldloc, savedOb);
il.Emit(OpCodes.Ldloc, savedArgs);
il.Emit(OpCodes.Ldloc, savedResult);
}
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);
}
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);
}
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets)
{
if (base.isFullyResolved)
{
base.TranslateToILCall(il, rtype, argList, construct, brackets);
}
else
{
Label label = il.DefineLabel();
Label label2 = il.DefineLabel();
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.scriptObjectStackTopMethod);
il.Emit(OpCodes.Castclass, Typeob.IActivationObject);
il.Emit(OpCodes.Ldstr, base.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, label);
il.Emit(OpCodes.Pop);
base.TranslateToILCall(il, Typeob.Object, argList, construct, brackets);
il.Emit(OpCodes.Br, label2);
il.MarkLabel(label);
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);
}
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValue2Method);
il.MarkLabel(label2);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
}
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets)
{
if (((base.defaultMember != null) && construct) && brackets)
{
base.TranslateToILCall(il, rtype, argList, construct, brackets);
}
else
{
JSGlobalField member = base.member as JSGlobalField;
if (((member != null) && member.IsLiteral) && (argList.count == 1))
{
Type type = Microsoft.JScript.Convert.ToType((IReflect)member.value);
argList[0].TranslateToIL(il, type);
Microsoft.JScript.Convert.Emit(this, il, type, rtype);
}
else
{
this.TranslateToILWithDupOfThisOb(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);
}
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
}
}
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets)
{
if (((base.defaultMember != null) && construct) && brackets)
{
base.TranslateToILCall(il, rtype, argList, construct, brackets);
}
else
{
JSGlobalField member = base.member as JSGlobalField;
if (((member != null) && member.IsLiteral) && (argList.count == 1))
{
Type type = Microsoft.JScript.Convert.ToType((IReflect) member.value);
argList[0].TranslateToIL(il, type);
Microsoft.JScript.Convert.Emit(this, il, type, rtype);
}
else
{
this.TranslateToILWithDupOfThisOb(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);
}
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
}
}
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);
}
internal virtual void TranslateToILPreSet(ILGenerator il, ASTList args)
{
this.TranslateToIL(il, Typeob.Object);
args.TranslateToIL(il, typeof(Object[]));
}
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, typeof(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, 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.callValue2Method);
il.MarkLabel(done);
Convert.Emit(this, il, Typeob.Object, rtype);
}
internal virtual void TranslateToILPreSetPlusGet(ILGenerator il, ASTList args, bool inBrackets)
{
il.Emit(OpCodes.Ldnull);
this.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Dup);
LocalBuilder local = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, local);
args.TranslateToIL(il, Typeob.ArrayOfObject);
il.Emit(OpCodes.Dup);
LocalBuilder builder2 = il.DeclareLocal(Typeob.ArrayOfObject);
il.Emit(OpCodes.Stloc, builder2);
il.Emit(OpCodes.Ldc_I4_0);
if (inBrackets)
{
il.Emit(OpCodes.Ldc_I4_1);
}
else
{
il.Emit(OpCodes.Ldc_I4_0);
}
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
LocalBuilder builder3 = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, builder3);
il.Emit(OpCodes.Ldloc, local);
il.Emit(OpCodes.Ldloc, builder2);
il.Emit(OpCodes.Ldloc, builder3);
}
internal virtual void TranslateToILPreSet(ILGenerator il, ASTList args)
{
this.TranslateToIL(il, Typeob.Object);
args.TranslateToIL(il, Typeob.ArrayOfObject);
}
internal virtual void TranslateToILPreSetPlusGet(ILGenerator il, ASTList args, bool inBrackets){
il.Emit(OpCodes.Ldnull); //Put a dummy this obj on the stack for CallValue's sake
this.TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Dup);
LocalBuilder savedOb = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, savedOb);
args.TranslateToIL(il, typeof(Object[]));
il.Emit(OpCodes.Dup);
LocalBuilder savedArgs = il.DeclareLocal(typeof(Object[]));
il.Emit(OpCodes.Stloc, savedArgs);
il.Emit(OpCodes.Ldc_I4_0);
if (inBrackets)
il.Emit(OpCodes.Ldc_I4_1);
else
il.Emit(OpCodes.Ldc_I4_0);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.callValueMethod);
LocalBuilder savedResult = il.DeclareLocal(Typeob.Object);
il.Emit(OpCodes.Stloc, savedResult);
il.Emit(OpCodes.Ldloc, savedOb);
il.Emit(OpCodes.Ldloc, savedArgs);
il.Emit(OpCodes.Ldloc, savedResult);
}
internal override void TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, bool construct, bool brackets){
MemberInfo member = this.member;
if (this.defaultMember != null){
if (this.isArrayConstructor){
TypedArray tArr = (TypedArray)this.defaultMemberReturnIR;
Type eType = Convert.ToType(tArr.elementType);
Debug.Assert(tArr.rank == argList.count);
int r = tArr.rank;
if (r == 1){
argList[0].TranslateToIL(il, Typeob.Int32);
il.Emit(OpCodes.Newarr, eType);
}else{
Type aType = tArr.ToType();
Type[] dTypes = new Type[r];
for (int i = 0; i < r; i++) dTypes[i] = Typeob.Int32;
for (int i = 0, n = argList.count; i < n; i++)
argList[i].TranslateToIL(il, Typeob.Int32);
TypeBuilder eTypeB = eType as TypeBuilder;
if (eTypeB != null){
MethodInfo cons = ((ModuleBuilder)aType.Module).GetArrayMethod(aType, ".ctor", CallingConventions.HasThis, Typeob.Void, dTypes);
il.Emit(OpCodes.Newobj, cons);
}else{
ConstructorInfo cons = aType.GetConstructor(dTypes);
il.Emit(OpCodes.Newobj, cons);
}
}
Convert.Emit(this, il, tArr.ToType(), rtype);
return;
}
this.member = this.defaultMember;
IReflect defIR = this.defaultMemberReturnIR;
Type defType = defIR is Type ? (Type)defIR : Convert.ToType(defIR);
this.TranslateToIL(il, defType);
if (this.isArrayElementAccess){
Debug.Assert(defType.IsArray);
for (int i = 0, m = argList.count; i < m; i++)
argList[i].TranslateToIL(il, Typeob.Int32);
Type etype = defType.GetElementType();
int n = defType.GetArrayRank();
if (n == 1){
Binding.TranslateToLdelem(il, etype);
}else{
Type[] indexTypes = new Type[n];
for (int i = 0; i < n; i++) indexTypes[i] = Typeob.Int32;
MethodInfo getter = defType.GetMethod("Get", indexTypes);
il.Emit(OpCodes.Call, getter);
}
Convert.Emit(this, il, etype, rtype);
return;
}
this.member = member;
}
if (member is MethodInfo){
MethodInfo meth = (MethodInfo)member;
Type dt = meth.DeclaringType;
Type rt = meth.ReflectedType;
ParameterInfo[] pars = meth.GetParameters();
bool isStatic = meth.IsStatic;
if (!isStatic && this.defaultMember == null)
this.TranslateToILObject(il, dt, true);
if (meth is JSClosureMethod)
this.TranslateToILObject(il, dt, false);
ConstantWrapper missing = null;
int offset = 0;
if (meth is JSFieldMethod || meth.IsDefined(Typeob.JSFunctionAttribute, false)){
offset = this.PlaceValuesForHiddenParametersOnStack(il, meth, pars);
missing = Binding.JScriptMissingCW;
}else
missing = Binding.ReflectionMissingCW;
if (argList.count == 1 && missing == Binding.JScriptMissingCW && this.defaultMember is PropertyInfo){
//Dealing with the CreateInstance method of a constructor function
Debug.Assert(meth.Name == "CreateInstance" || meth.Name == "Invoke");
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Newarr, Typeob.Object);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldc_I4_0);
argList[0].TranslateToIL(il, Typeob.Object);
il.Emit(OpCodes.Stelem_Ref);
}else
Binding.PlaceArgumentsOnStack(il, pars, argList, offset, 0, missing);
if (meth is JSMethod)
meth = ((JSMethod)meth).GetMethodInfo(compilerGlobals);
else if (meth is JSMethodInfo)
meth = ((JSMethodInfo)meth).method;
if (!this.isNonVirtual && meth.IsVirtual && !meth.IsFinal && !rt.IsSealed)
il.Emit(OpCodes.Callvirt, meth);
else
il.Emit(OpCodes.Call, meth);
Convert.Emit(this, il, meth.ReturnType, rtype);
return;
}
if (member is ConstructorInfo){
Debug.Assert(construct);
ConstructorInfo cons = (ConstructorInfo)member;
ParameterInfo[] pars = cons.GetParameters();
bool instanceNestedClassConstructor = false;
if (cons.IsDefined(Typeob.JSFunctionAttribute, false)){
Object[] attrs = cons.GetCustomAttributes(Typeob.JSFunctionAttribute, false);
instanceNestedClassConstructor = (((JSFunctionAttribute)attrs[0]).attributeValue & JSFunctionAttributeEnum.IsInstanceNestedClassConstructor) != 0;
}
if (instanceNestedClassConstructor){
Binding.PlaceArgumentsOnStack(il, pars, argList, 0, 1, Binding.ReflectionMissingCW);
this.TranslateToILObject(il, pars[pars.Length-1].ParameterType, false);
}else
Binding.PlaceArgumentsOnStack(il, pars, argList, 0, 0, Binding.ReflectionMissingCW);
Type outerClass = null;
if (member is JSConstructor && (outerClass = ((JSConstructor)member).OuterClassType()) != null)
this.TranslateToILObject(il, outerClass, false);
bool needEngine = false;
Type t = cons.DeclaringType;
if (cons is JSConstructor){
cons = ((JSConstructor)cons).GetConstructorInfo(compilerGlobals);
needEngine = true;
}else
needEngine = typeof(INeedEngine).IsAssignableFrom(t);
il.Emit(OpCodes.Newobj, cons);
if (needEngine){
il.Emit(OpCodes.Dup);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Callvirt, CompilerGlobals.setEngineMethod);
}
Convert.Emit(this, il, t, rtype);
return;
}
Type mt = member as Type;
if (mt != null){
Debug.Assert(!construct && !brackets);
Debug.Assert(argList.count == 1);
AST arg0 = argList[0];
if (arg0 is NullLiteral){
il.Emit(OpCodes.Ldnull);
return;
}
IReflect arg0ir = arg0.InferType(null);
if (arg0ir == Typeob.ScriptFunction && typeof(Delegate).IsAssignableFrom(mt))
arg0.TranslateToIL(il, mt);
else{
Type argType = Convert.ToType(arg0ir);
arg0.TranslateToIL(il, argType);
Convert.Emit(this, il, argType, mt, true);
}
Convert.Emit(this, il, mt, rtype);
return;
}
if (member is FieldInfo && ((FieldInfo)member).IsLiteral){
Object val = member is JSVariableField ? ((JSVariableField)member).value : ((FieldInfo)member).GetValue(null);
if (val is Type || val is ClassScope || val is TypedArray){
Debug.Assert(argList.count == 1);
AST arg0 = argList[0];
if (arg0 is NullLiteral){
il.Emit(OpCodes.Ldnull);
return;
}
ClassScope csc = val as ClassScope;
if (csc != null){
EnumDeclaration ed = csc.owner as EnumDeclaration;
if (ed != null)
val = ed.baseType.ToType();
}
Type argType = Convert.ToType(arg0.InferType(null));
arg0.TranslateToIL(il, argType);
Type t = val is Type ? (Type)val : val is ClassScope ? Convert.ToType((ClassScope)val) : ((TypedArray)val).ToType();
Convert.Emit(this, il, argType, t, true);
if (!rtype.IsEnum)
Convert.Emit(this, il, t, rtype);
return;
}
}
LocalBuilder loc = null;
for (int i = 0, n = argList.count; i < n; i++){
if (argList[i] is AddressOf){
loc = il.DeclareLocal(typeof(Object[]));
break;
}
}
Object done = null;
if (member == null && (this.members == null || this.members.Length == 0)){
if (this is Lookup)
((Lookup)this).TranslateToLateBinding(il);
else{
done = this.TranslateToSpeculativeEarlyBoundCalls(il, rtype, argList, construct, brackets);
((Member)this).TranslateToLateBinding(il, done != null);
}
argList.TranslateToIL(il, typeof(Object[]));
if (loc != null){
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, loc);
}
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.callMethod);
Convert.Emit(this, il, Typeob.Object, rtype);
if (loc != null){
for (int i = 0, n = argList.count; i < n; i++){
AddressOf addr = argList[i] as AddressOf;
if (addr != null){
addr.TranslateToILPreSet(il);
il.Emit(OpCodes.Ldloc, loc);
ConstantWrapper.TranslateToILInt(il, i);
il.Emit(OpCodes.Ldelem_Ref);
Convert.Emit(this, il, Typeob.Object, Convert.ToType(addr.InferType(null)));
addr.TranslateToILSet(il, null);
}
}
}
if (done != null)
il.MarkLabel((Label)done);
return;
}
this.TranslateToILWithDupOfThisOb(il);
argList.TranslateToIL(il, typeof(Object[]));
if (loc != null){
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, loc);
}
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);
if (loc != null){
for (int i = 0, n = argList.count; i < n; i++){
AddressOf addr = argList[i] as AddressOf;
if (addr != null){
addr.TranslateToILPreSet(il);
il.Emit(OpCodes.Ldloc, loc);
ConstantWrapper.TranslateToILInt(il, i);
il.Emit(OpCodes.Ldelem_Ref);
Convert.Emit(this, il, Typeob.Object, Convert.ToType(addr.InferType(null)));
addr.TranslateToILSet(il, null);
}
}
}
}
