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 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); } } } }