Beispiel #1
0
 public void MaybSetLocalName(LocalBuilder lb, string name)
 {
     if (_isDebuggable)
     {
         lb.SetLocalSymInfo(name);
     }
 }
Beispiel #2
0
        private static void EmitGetDefault(ILGenerator il, Type type)
        {
            if (type.IsArray)
            {
                // Create a 0-length array of type
                il.Emit(OpCodes.Ldc_I4_0);
                il.Emit(OpCodes.Newarr, type.GetElementType());

                return;
            }

            if (type.IsValueType)
            {
                // Create default of type
                LocalBuilder defaultVal = il.DeclareLocal(type);

#if DEBUG
                // Debug helpers
                defaultVal.SetLocalSymInfo(nameof(defaultVal));
#endif

                il.Emit(OpCodes.Ldloca_S, defaultVal);
                il.Emit(OpCodes.Initobj, type);
                il.Emit(OpCodes.Ldloc_S, defaultVal);

                return;
            }

            // Create null object
            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Castclass, type);
        }
        /// <summary>
        /// Creates local variable declarations.
        /// </summary>
        /// <param name="il">The IL generator to use.</param>
        /// <param name="method">The method to proxy.</param>
        protected virtual void DeclareLocals(ILGenerator il, MethodInfo method)
        {
            interceptors = il.DeclareLocal(typeof(IList));
            targetType   = il.DeclareLocal(typeof(Type));
            arguments    = il.DeclareLocal(typeof(Object[]));

#if NET_2_0
            if (method.IsGenericMethodDefinition)
            {
                genericTargetMethod        = il.DeclareLocal(typeof(MethodInfo));
                genericOnProxyTargetMethod = il.DeclareLocal(typeof(MethodInfo));
            }
#endif
            if (methodReturnsValue)
            {
                returnValue = il.DeclareLocal(method.ReturnType);
            }

#if DEBUG
            interceptors.SetLocalSymInfo("interceptors");
            targetType.SetLocalSymInfo("targetType");
            arguments.SetLocalSymInfo("arguments");
#if NET_2_0
            if (method.IsGenericMethodDefinition)
            {
                genericTargetMethod.SetLocalSymInfo("genericTargetMethod");
                genericOnProxyTargetMethod.SetLocalSymInfo("genericOnProxyTargetMethod");
            }
#endif
            if (methodReturnsValue)
            {
                returnValue.SetLocalSymInfo("returnValue");
            }
#endif
        }
Beispiel #4
0
        public static void EmitTypedArgs(ObjExpr objx, CljILGen ilg, ParameterInfo[] parms, List <HostArg> args)
        {
            for (int i = 0; i < parms.Length; i++)
            {
                HostArg       ha           = args[i];
                ParameterInfo pi           = parms[i];
                bool          argIsByRef   = ha.ParamType == HostArg.ParameterType.ByRef;
                bool          paramIsByRef = pi.ParameterType.IsByRef;

                if (!paramIsByRef)
                {
                    EmitTypedArg(objx, ilg, pi.ParameterType, ha.ArgExpr);
                }
                else // paramIsByRef
                {
                    if (argIsByRef)
                    {
                        EmitByRefArg(ha, objx, ilg);
                    }
                    else
                    {
                        EmitTypedArg(objx, ilg, parms[i].ParameterType, args[i].ArgExpr);
                        LocalBuilder loc = ilg.DeclareLocal(pi.ParameterType);
                        loc.SetLocalSymInfo("_byRef_temp" + i);
                        ilg.Emit(OpCodes.Stloc, loc);
                        ilg.Emit(OpCodes.Ldloca, loc);
                    }
                }
            }
        }
Beispiel #5
0
        private static IAssessmentAopAdviceProvider CreateInstance(string instanceName, string methodName, string returnValue)
        {
            TypeBuilder typeBuilder = moduleBuilder.DefineType("MvcAdviceProvider.MvcAdviceProviderType", TypeAttributes.Public, typeof(object), new Type[] { typeof(IAssessmentAopAdviceProvider) });

            // typeBuilder.AddInterfaceImplementation(typeof(IAssessmentAopAdviceProvider));

            MethodBuilder beforeMethodBuilder = typeBuilder.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.Virtual, typeof(string), new Type[] { typeof(int) });

            beforeMethodBuilder.DefineParameter(1, ParameterAttributes.None, "value");

            ILGenerator generator1 = beforeMethodBuilder.GetILGenerator();

            LocalBuilder local1 = generator1.DeclareLocal(typeof(string));

            local1.SetLocalSymInfo("param1");

            generator1.Emit(OpCodes.Nop);

            generator1.Emit(OpCodes.Ldstr, returnValue);

            generator1.Emit(OpCodes.Stloc_0);

            generator1.Emit(OpCodes.Ldloc_0);

            generator1.Emit(OpCodes.Ret);

            Type providerType = typeBuilder.CreateType();

            assemblyBuilder.Save("test.dll");

            IAssessmentAopAdviceProvider provider = Activator.CreateInstance(providerType) as IAssessmentAopAdviceProvider;

            return(provider);
        }
Beispiel #6
0
        public override void Compile(ILGenerator il)
        {
            EmitDebugInfo(il, 0, false);

            //Declare at first use
            if (Options.BookVersion && !SymbolTable.IsInScope(Variable.Name))
            {
                SymbolTable.DefineVariable(Variable.Name);
                LocalBuilder lb = il.DeclareLocal(typeof(int));
                if (Options.Debug)
                {
                    lb.SetLocalSymInfo(Variable.Name);
                }
            }

            if (SymbolTable.IsResultArgument(Variable.Name))
            {
                il.Emit(OpCodes.Ldarg, SymbolTable.GetValue(Variable.Name));
                Expression.Compile(il);
                il.Emit(OpCodes.Stind_I4);
            }
            else if (SymbolTable.IsArgument(Variable.Name))
            {
                Expression.Compile(il);
                il.Emit(OpCodes.Starg, SymbolTable.GetValue(Variable.Name));
            }
            else
            {
                Expression.Compile(il);
                il.Emit(OpCodes.Stloc, SymbolTable.GetValue(Variable.Name));
            }
        }
        private static MethodInfo BuildMethodProxy(MethodInfo target)
        {
            TypeBuilder type = module.DefineType(Guid.NewGuid().ToString(), TypeAttributes.Public | TypeAttributes.Class);

            ParameterInfo [] parameters      = target.GetParameters();
            Type []          parameter_types = new Type [parameters.Length + 2];

            parameter_types [0] = parameter_types [1] = typeof(IntPtr);

            for (int i = 0; i < parameters.Length; i++)
            {
                Type parameter_type = parameters [i].ParameterType;

                if (parameter_type.IsSubclassOf(typeof(Object)) || parameter_type == typeof(Object))
                {
                    parameter_types [2 + i] = typeof(IntPtr);
                }
                else if (parameter_type == typeof(System.Object))
                {
                    parameter_types [2 + i] = typeof(IntPtr);
                }
                else
                {
                    parameter_types [2 + i] = parameter_type;
                }
            }

            MethodBuilder method = type.DefineMethod("Dispatch", MethodAttributes.Public | MethodAttributes.Static, typeof(IntPtr), parameter_types);
            ILGenerator   ilg    = method.GetILGenerator();
            LocalBuilder  args   = ilg.DeclareLocal(typeof(object []));

            args.SetLocalSymInfo("args");

            ilg.Emit(OpCodes.Ldc_I4, parameters.Length);
            ilg.Emit(OpCodes.Newarr, typeof(object));
            ilg.Emit(OpCodes.Stloc_0);

            for (int i = 2; i < parameter_types.Length; i++)
            {
                ilg.Emit(OpCodes.Ldloc_0);
                ilg.Emit(OpCodes.Ldc_I4, i - 2);
                ilg.Emit(OpCodes.Ldarg, i);
                if (parameter_types [i].IsValueType)
                {
                    ilg.Emit(OpCodes.Box, parameter_types [i]);
                }

                ilg.Emit(OpCodes.Stelem_I4);
            }

            ilg.Emit(OpCodes.Ldarg_0);
            ilg.Emit(OpCodes.Ldarg_1);
            ilg.Emit(OpCodes.Ldloc_0);

            ilg.Emit(OpCodes.Call, typeof(ObjCInterop).GetMethod("Dispatch", BindingFlags.Public | BindingFlags.Static, null, new Type [] { typeof(IntPtr), typeof(IntPtr), typeof(object []) }, null));
            ilg.Emit(OpCodes.Ret);

            return(type.CreateType().GetMethod("Dispatch", BindingFlags.Public | BindingFlags.Static));
        }
Beispiel #8
0
 public virtual void Declare(ILGenerator il)
 {
     if (_local != null)
     {
         throw new InvalidOperationException("Variable " + Name + " is already declared!");
     }
     _local = il.DeclareLocal(this.Type);
     _local.SetLocalSymInfo(Name);
 }
        /// <summary>
        /// Creates local variable declarations.
        /// </summary>
        /// <param name="il">The IL generator to use.</param>
        /// <param name="method">The method to proxy.</param>
        protected override void DeclareLocals(ILGenerator il, MethodInfo method)
        {
            base.DeclareLocals(il, method);
            target = il.DeclareLocal(typeof(object));

#if DEBUG
            target.SetLocalSymInfo("target");
#endif
        }
Beispiel #10
0
        /// <summary>
        /// Creates local variable declarations.
        /// </summary>
        /// <param name="il">The IL generator to use.</param>
        /// <param name="method">The method to proxy.</param>
        protected override void DeclareLocals(ILGenerator il, MethodInfo method)
        {
            base.DeclareLocals(il, method);
            targetSource = il.DeclareLocal(typeof(ITargetSourceWrapper));

#if DEBUG
            targetSource.SetLocalSymInfo("targetSource");
#endif
        }
Beispiel #11
0
        public void MaybSetLocalName(LocalBuilder lb, string name)
        {
#if NET461
            if (_isDebuggable)
            {
                lb.SetLocalSymInfo(name);
            }
#endif
        }
Beispiel #12
0
        protected override Slot CreateSlot(SymbolId name, Type type)
        {
            LocalBuilder b = _codeGen.DeclareLocal(type);

            if (_codeGen.EmitDebugInfo)
            {
                b.SetLocalSymInfo(SymbolTable.IdToString(Ast.Variable.UnGenSym(name)));
            }
            return(new LocalSlot(b, _codeGen));
        }
Beispiel #13
0
        public override Slot MakeSlot(Name name, Type type)
        {
            LocalBuilder b = codeGen.DeclareLocal(type);

            if (codeGen.EmitDebugInfo)
            {
                b.SetLocalSymInfo(name.GetString());
            }
            return(new LocalSlot(b, codeGen));
        }
Beispiel #14
0
 private static void CreateNoOpMethod(MethodInfo method, ILGenerator generator)
 {
     if (method.ReturnType != typeof(void))
     {
         LocalBuilder local = generator.DeclareLocal(method.ReturnType);
         local.SetLocalSymInfo("FakeReturn");
         generator.Emit(OpCodes.Ldloc, local);
     }
     generator.Emit(OpCodes.Ret);
 }
Beispiel #15
0
        public override void GenerateMSIL(ILGenerator ilGenerator, TypeBuilder typeBuilder)
        {
            LocalBuilder newVar = ilGenerator.DeclareLocal(typeof(int));

            newVar.SetLocalSymInfo(Variable);

            RightHandExpression.GenerateMSIL(ilGenerator, typeBuilder);

            ilGenerator.Emit(OpCodes.Stloc, newVar);
        }
Beispiel #16
0
        public static LocalBuilder CreateArray <T>(this ILGenerator ilg, int size, string name = "")
        {
            LocalBuilder array = ilg.DeclareLocal(typeof(T[]));

            array.SetLocalSymInfo(name);
            Load32BitIntegerConstant(ilg, size);
            ilg.Emit(OpCodes.Newarr, typeof(T));
            ilg.Emit(OpCodes.Stloc, array);
            return(array);
        }
        internal override void TranslateToIL(ILGenerator il, Type rtype)
        {
            //This assumes that rtype == Void.class
            this.context.EmitLineInfo(il);
            Globals.ScopeStack.Push(new WithObject(Globals.ScopeStack.Peek(), new JSObject(null, false)));
            bool savedInsideProtectedRegion = compilerGlobals.InsideProtectedRegion;

            compilerGlobals.InsideProtectedRegion = true;
            Label lab = il.DefineLabel();

            compilerGlobals.BreakLabelStack.Push(lab);
            compilerGlobals.ContinueLabelStack.Push(lab);
            this.obj.TranslateToIL(il, Typeob.Object);
            this.EmitILToLoadEngine(il);
            il.Emit(OpCodes.Call, CompilerGlobals.jScriptWithMethod); // JScriptWith returns the with object as an 'Object' (used by the debugger EE)

            // define a local named 'with()' that the debugger EE will use to bind to the with object
            LocalBuilder withObj = null;

            if (context.document.debugOn)
            {
                il.BeginScope(); // used by the debugger to mark a with block
                withObj = il.DeclareLocal(Typeob.Object);
                withObj.SetLocalSymInfo("with()");
                il.Emit(OpCodes.Stloc, withObj);
            }
            else
            {
                il.Emit(OpCodes.Pop);
            }

            il.BeginExceptionBlock();
            this.block.TranslateToILInitializer(il);
            this.block.TranslateToIL(il, Typeob.Void);
            il.BeginFinallyBlock();
            if (context.document.debugOn)
            {
                // null the local used by the debugger EE
                il.Emit(OpCodes.Ldnull);
                il.Emit(OpCodes.Stloc, withObj);
            }
            this.EmitILToLoadEngine(il);
            il.Emit(OpCodes.Call, CompilerGlobals.popScriptObjectMethod);
            il.Emit(OpCodes.Pop);
            il.EndExceptionBlock();
            if (context.document.debugOn)
            {
                il.EndScope(); // used by the debugger to mark a with block
            }
            il.MarkLabel(lab);
            compilerGlobals.BreakLabelStack.Pop();
            compilerGlobals.ContinueLabelStack.Pop();
            compilerGlobals.InsideProtectedRegion = savedInsideProtectedRegion;
            Globals.ScopeStack.Pop();
        }
Beispiel #18
0
        public override void Compile(ILGenerator il)
        {
            EmitDebugInfo(il, 0, true);
            SymbolTable.DefineVariable(Variable.Name);
            LocalBuilder lb = il.DeclareLocal(typeof(int));

            if (Options.Debug)
            {
                lb.SetLocalSymInfo(Variable.Name);
            }
        }
Beispiel #19
0
        public ILocalVariable EmitLocalVarDeclaration(string localVarName, Type localVarType)
        {
            LocalBuilder localBuilder = ilGenerator.DeclareLocal(localVarType);

//            if (CanInitializeLocation(localVarType)) {
//                // Store the already prepared initializer
//                ilGenerator.Emit(OpCodes.Stloc, localBuilder);
//            }
            localBuilder.SetLocalSymInfo(localVarName);

            return(new CilLocalVariable(ilGenerator, localBuilder));
        }
Beispiel #20
0
        public static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions, ILGenerator generator)
        {
            if (!Configuration.Current.Pickable.IsEnabled)
            {
                return(instructions);
            }

            List <CodeInstruction> il = instructions.ToList();

            LocalBuilder newYieldLocal = null;

            for (int i = 0; i < il.Count; i++)
            {
                if (newYieldLocal == null && i > 0 && il[i].opcode == OpCodes.Stloc_1 && il[i - 1].opcode == OpCodes.Ldc_I4_0)
                {
                    // Step 1: Call calculateYield() and store the result as a new local variable.
                    //
                    // Calling calculateYield takes several instructions:
                    // LdArg.0 (load the "this" pointer), LdFld (load m_itemPrefab from this), LdArg.0 (this), LdFld (load m_amount from this), Call.
                    // We then store the return value as our new local, used in the second patch below.
                    newYieldLocal = generator.DeclareLocal(typeof(int));
                    newYieldLocal.SetLocalSymInfo("newYieldLocal");
                    il.Insert(++i, new CodeInstruction(OpCodes.Ldarg_0));
                    il.Insert(++i, new CodeInstruction(OpCodes.Ldfld, field_ItemPrefab));
                    il.Insert(++i, new CodeInstruction(OpCodes.Ldarg_0));
                    il.Insert(++i, new CodeInstruction(OpCodes.Ldfld, field_amount));
                    il.Insert(++i, new CodeInstruction(new CodeInstruction(OpCodes.Call, method_calculateYield)));
                    il.Insert(++i, new CodeInstruction(OpCodes.Stloc_S, newYieldLocal.LocalIndex));
                }

                if (newYieldLocal != null && il[i].opcode == OpCodes.Ldfld && il[i].operand.ToString().Contains("m_amount"))
                {
                    // Step 2: Patch the for loop to loop calculateYield() iterations instead of m_amount iterations,
                    // by replacing m_amount with our new local variable, created above.
                    //
                    // Get rid of LdArg.1 (i-1) and LdFld (i) and replace them with loading our previously calculated yield.
                    il[i] = new CodeInstruction(OpCodes.Ldloc_S, newYieldLocal.LocalIndex);
                    il.RemoveRange(i - 1, 1);

                    ZLog.Log("Successfully transpiled Pickable.RPC_Pick to patch item yields");

                    // NOTE: This transpiler may be called multiple times, e.g. when starting the game, when connecting to a server and when disconnecting.
                    // We need to re-do the initial setup every time, since the modifier values may have changed (as the server config will be used instead of the client config).
                    initialSetup();

                    return(il.AsEnumerable());
                }
            }

            ZLog.Log("Unable to transpile Pickable.RPC_Pick to patch item yields");
            return(instructions);
        }
Beispiel #21
0
        internal LocalBuilder GetNamedLocal(Type type, string name)
        {
            Assert.NotNull(type);

            if (_emitDebugSymbols && name != null)
            {
                LocalBuilder lb = _ilg.DeclareLocal(type);
                // TODO: we need to set the lexical scope properly, so it can
                // be freed and reused!
                lb.SetLocalSymInfo(name);
                return(lb);
            }
            return(_ilg.GetLocal(type));
        }
Beispiel #22
0
 internal void EmitLocalInfoForFields(ILGenerator il)
 {
     foreach (JSLocalField field in this.localFieldsForDebugInfo)
     {
         ((LocalBuilder)field.metaData).SetLocalSymInfo(field.debuggerName);
     }
     if (this.parent is GlobalScope)
     {
         LocalBuilder loc = il.DeclareLocal(Typeob.Int32);
         loc.SetLocalSymInfo("scopeId for catch block");
         ConstantWrapper.TranslateToILInt(il, this.scopeId);
         il.Emit(OpCodes.Stloc, loc);
     }
 }
        internal override void TranslateToIL(ILGenerator il, Type rtype)
        {
            base.context.EmitLineInfo(il);
            base.Globals.ScopeStack.Push(new WithObject(base.Globals.ScopeStack.Peek(), new JSObject(null, false)));
            bool insideProtectedRegion = base.compilerGlobals.InsideProtectedRegion;

            base.compilerGlobals.InsideProtectedRegion = true;
            Label item = il.DefineLabel();

            base.compilerGlobals.BreakLabelStack.Push(item);
            base.compilerGlobals.ContinueLabelStack.Push(item);
            this.obj.TranslateToIL(il, Typeob.Object);
            base.EmitILToLoadEngine(il);
            il.Emit(OpCodes.Call, CompilerGlobals.jScriptWithMethod);
            LocalBuilder local = null;

            if (base.context.document.debugOn)
            {
                il.BeginScope();
                local = il.DeclareLocal(Typeob.Object);
                local.SetLocalSymInfo("with()");
                il.Emit(OpCodes.Stloc, local);
            }
            else
            {
                il.Emit(OpCodes.Pop);
            }
            il.BeginExceptionBlock();
            this.block.TranslateToILInitializer(il);
            this.block.TranslateToIL(il, Typeob.Void);
            il.BeginFinallyBlock();
            if (base.context.document.debugOn)
            {
                il.Emit(OpCodes.Ldnull);
                il.Emit(OpCodes.Stloc, local);
            }
            base.EmitILToLoadEngine(il);
            il.Emit(OpCodes.Call, CompilerGlobals.popScriptObjectMethod);
            il.Emit(OpCodes.Pop);
            il.EndExceptionBlock();
            if (base.context.document.debugOn)
            {
                il.EndScope();
            }
            il.MarkLabel(item);
            base.compilerGlobals.BreakLabelStack.Pop();
            base.compilerGlobals.ContinueLabelStack.Pop();
            base.compilerGlobals.InsideProtectedRegion = insideProtectedRegion;
            base.Globals.ScopeStack.Pop();
        }
Beispiel #24
0
        public void GenerateDeclaration(VariableDeclaration declNode, ILGenerator ilGenerator)
        {
            LocalBuilder localBuilder = ilGenerator.DeclareLocal(declNode.ReturnType.ConvertToType());

            localBuilder.SetLocalSymInfo(declNode.Name);
            //add our local to dictionary
            varsLocalBuilders.Add(declNode.Name, localBuilder);

            if (declNode.Value != null)
            {
                GenerateExpression(declNode.Value, ilGenerator);
                //pop var from the stack and store in a value
                ilGenerator.Emit(OpCodes.Stloc, localBuilder);
            }
        }
Beispiel #25
0
        /// <summary>
        /// 取值。
        /// </summary>
        /// <param name="ilg">指令。</param>
        public override void Load(ILGenerator ilg)
        {
            if (local is null)
            {
                local = ilg.DeclareLocal(RuntimeType);
#if NET40_OR_GREATER
                if (name?.Length > 0)
                {
                    local.SetLocalSymInfo(name);
                }
#endif
            }

            ilg.Emit(OpCodes.Ldloc, local);
        }
Beispiel #26
0
        public override void Compile(CompileContext context)
        {
            Type        procType = typeof(ProcessBase);
            ILGenerator il       = context.ILGenerator;

            EmitDebug("Preparing to sync now...", context);
            LocalBuilder syncObject = il.DeclareLocal(typeof(ChannelSyncAction));

            il.Emit(OpCodes.Ldarg_0); //this
            il.Emit(OpCodes.Ldstr, Name);
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldc_I4, _children.Count);
            il.Emit(OpCodes.Ldc_I4_1);
            il.Emit(OpCodes.Newobj, typeof(ChannelSyncAction).GetConstructor(new Type[] { typeof(string), typeof(ProcessBase), typeof(int), typeof(bool) }));
            il.Emit(OpCodes.Stloc, syncObject);
            il.Emit(OpCodes.Ldloc, syncObject);
            il.Emit(OpCodes.Call, SyncMethod);
            context.MarkSequencePoint(this.LexicalInfo);

            //Save values to variables
            for (int i = 0; i < _children.Count; i++)
            {
                Variable var = (Variable)_children[i];

                if (context.Options.Optimize && !var.IsUsed)
                {
                    continue;
                }
                //Get the value to assign to it...
                il.Emit(OpCodes.Ldloc, syncObject);
                il.Emit(OpCodes.Ldc_I4, i);
                il.Emit(OpCodes.Call, typeof(ChannelSyncAction).GetMethod("GetValue"));
                //...and assign it
                LocalBuilder local = context.Type.GetLocal(var.Name);
                if (local == null)   //Inactions can be defining occurrences, so just create it...
                {
                    local = context.ILGenerator.DeclareLocal(typeof(object));
                    if (context.Options.Debug)
                    {
                        local.SetLocalSymInfo(var.Name);
                    }
                    context.Type.Locals.Add(var.Name, local);
                }
                il.Emit(OpCodes.Stloc, local);
            }
        }
Beispiel #27
0
        public void LocalVars(VarList v)
        {
            int max = v.Length();

            for (int i = 0; i < max; i++)
            {
                Var          e  = v.FindByIndex(i);
                Type         et = genDataTypeSig(e);
                LocalBuilder t  = il.DeclareLocal(et);
                if (io.getGenDebug())
                {
                    t.SetLocalSymInfo(e.getName());
                }
                e.setLocalToken(t);
            }
            localvars = v;
        }
Beispiel #28
0
        public override void Compile(ILGenerator il)
        {
            EmitDebugInfo(il, 0, false);
            SanityCheck();
            if (this.ChildNodes.Count > 0)
            {
                for (int i = 0; i < ChildNodes.Count - 1; i++)
                {
                    this[i].Compile(il);
                }
                Procedure proc = WhileProgram.Instance.Procedures.GetByName(ProcedureName);
                if (proc.HasResultArgument)
                {
                    Variable v = (Variable)this[ChildNodes.Count - 1];
                    //Create at first use
                    if (Options.BookVersion && !SymbolTable.IsInScope(v.Name))
                    {
                        SymbolTable.DefineVariable(v.Name);
                        LocalBuilder lb = il.DeclareLocal(typeof(int));
                        if (Options.Debug)
                        {
                            lb.SetLocalSymInfo(v.Name);
                        }
                    }

                    if (SymbolTable.IsResultArgument(v.Name))
                    {
                        il.Emit(OpCodes.Ldarg, SymbolTable.GetValue(v.Name));
                    }
                    else if (SymbolTable.IsArgument(v.Name))
                    {
                        il.Emit(OpCodes.Ldarga, SymbolTable.GetValue(v.Name));
                    }
                    else
                    {
                        il.Emit(OpCodes.Ldloca, SymbolTable.GetValue(v.Name));
                    }
                }
                else
                {
                    this[ChildNodes.Count - 1].Compile(il);
                }
            }
            il.Emit(OpCodes.Call, WhileProgram.Instance.Procedures.Compiled[ProcedureName]);
        }
Beispiel #29
0
        public void LocalVars(VarList v)
        {
            int max = v.Length();

            for (int i = 0; i < max; i++)   // loop thru the local params
            {
                Var  e  = v.FindByIndex(i); // indexed by number
                Type et = genDataTypeSig(e);
                //    LocalToken t = emethod.DeclareLocal(et);
                LocalBuilder t = il.DeclareLocal(et);
                if (Io.gendebug)
                {
                    t.SetLocalSymInfo(e.getName());
                }
                e.setLocalToken(t);
            }
            localsdone = true;
        }
Beispiel #30
0
        /// <summary>
        /// 赋值。
        /// </summary>
        /// <param name="ilg">指令。</param>
        /// <param name="value">值。</param>
        protected override void Assign(ILGenerator ilg, AstExpression value)
        {
            if (local is null)
            {
                local = ilg.DeclareLocal(RuntimeType);

#if NET40_OR_GREATER
                if (name?.Length > 0)
                {
                    local.SetLocalSymInfo(name);
                }
#endif
            }

            value.Load(ilg);

            ilg.Emit(OpCodes.Stloc, local);
        }