Inheritance: _ILGenerator
示例#1
1
文件: DecrPtr.cs 项目: paf31/BF
 public void EmitIL(ILGenerator body, FieldInfo tape, FieldInfo ptr)
 {
     body.Emit(OpCodes.Ldsfld, ptr);
     body.Emit(OpCodes.Ldc_I4_1);
     body.Emit(OpCodes.Sub);
     body.Emit(OpCodes.Stsfld, ptr);
 }
		public override void AppendWrite(ILGenerator generator, MessageField field)
		{
			var done = generator.DefineLabel();
			var tmp = generator.DeclareLocal(typeof(Nullable<>).MakeGenericType(FieldType));

			generator.Emit(OpCodes.Ldloc_0);
			generator.Emit(OpCodes.Call, Property.GetGetMethod());
			generator.Emit(OpCodes.Stloc, tmp.LocalIndex);

			generator.Emit(OpCodes.Ldloca, tmp.LocalIndex);
			generator.Emit(OpCodes.Call, typeof(Nullable<>)
				.MakeGenericType(FieldType)
				.GetProperty("HasValue")
				.GetGetMethod());

			generator.Emit(OpCodes.Brfalse_S, done);

			field.AppendGuard(generator, Property.GetGetMethod(), done);
			field.AppendHeader(generator);

			generator.Emit(OpCodes.Ldloca, tmp.LocalIndex);
			generator.Emit(OpCodes.Call, typeof(Nullable<>)
				.MakeGenericType(FieldType)
				.GetProperty("Value")
				.GetGetMethod());

			field.AppendWriteField(generator);
			generator.Emit(OpCodes.Pop);
			generator.MarkLabel(done);
		}
示例#3
0
文件: CodeAnd.cs 项目: nlhepler/mono
		public override void GenerateForBranch (ILGenerator gen, Label label, bool branchCase)
		{
			Label endLabel = gen.DefineLabel ();
			exp1.Generate (gen);
			
			if (exp1 is CodeConditionExpression) {
				if (branchCase)
					((CodeConditionExpression)exp1).GenerateForBranch (gen, endLabel, false);
				else
					((CodeConditionExpression)exp1).GenerateForBranch (gen, label, false);
			}
			else {
				exp1.Generate (gen);
				if (branchCase)
					gen.Emit (OpCodes.Brfalse, endLabel);
				else
					gen.Emit (OpCodes.Brfalse, label);
			}

			if (exp2 is CodeConditionExpression) {
				if (branchCase)
					((CodeConditionExpression)exp2).GenerateForBranch (gen, label, true);
				else
					((CodeConditionExpression)exp2).GenerateForBranch (gen, label, false);
			}
			else {
				exp2.Generate (gen);
				if (branchCase)
					gen.Emit (OpCodes.Brtrue, label);
				else
					gen.Emit (OpCodes.Brfalse, label);
			}
			
			gen.MarkLabel(endLabel);
		}
        internal ArgumentReferenceEmitter(IdentifierExpression identifierExpression, ParameterDefinition parameterDefinition, ILGenerator ilGenerator, IOpCodeIndexer instructionsIndexer)
            : base(ilGenerator, instructionsIndexer) {

            _parameterDefinition = parameterDefinition;
            _identifierExpression = identifierExpression;
            Type = parameterDefinition.ParameterType.GetActualType();
        }
示例#5
0
 public TypeLocalPool(ILGenerator gen, Type t)
 {
     this.Type = t;
     this.stack = new Stack<LocalBuilder>();
     this.queue = new Queue<LocalBuilder>();
     this.ilgen = gen;
 }
示例#6
0
        public override void GenerateCode(ILGenerator generator, TypeBuilder typeBuilder)
        {
            // Declarando la etiqueta.
            Label end = generator.DefineLabel();

            //Generamos el codigo de la izquierda
            Left.GenerateCode(generator, typeBuilder);

            //Devuelve '1' en la pila si el valor de Left es distinto de cero.
            CheckIfEqualToZero(generator);
            //Guardamos el resultado en una variable, por si se salta no perderlo
            var result = generator.DeclareLocal(typeof (int));
            GetValueFromStack(generator, result);

            //Si fue igual a 1 (true), saltamos hacia el final
            generator.Emit(OpCodes.Brtrue, end);

            //Sino, Generamos el codigo de la derecha
            Right.GenerateCode(generator, typeBuilder);

            //Si llegamos aqui, entonces el resultado sera el del operador derecho (si es 1 => 1)
            CheckIfEqualToZero(generator);
            //Guardamos el resultado en la variable
            GetValueFromStack(generator, result);

            //Haciendo 'backpatch'
            generator.MarkLabel(end);

            //Guardamos el resultado en la pila
            generator.Emit(OpCodes.Ldloc, result);
        }
        static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> instructions,
                                                        SRE.ILGenerator generator,
                                                        SR.MethodBase methodInfo)
        {
            if (PatchWriteWorld.Debug)
            {
                printCode(instructions, generator, methodInfo, "Before Transpiler:");
            }

            IEnumerable <CodeInstruction> codes;
            bool fail;

            try
            {
                //Out actual transpiler
                codes = Xpiler(instructions, generator).ToArray();
                fail  = false;
            }
            catch (Exception ex)
            {
                fail = true;
                LogError($"Error in Xpiler: {ex}");
                codes = null;
            }
            if (!fail)
            {
                if (PatchWriteWorld.Debug)
                {
                    printCode(codes, generator, methodInfo, "After Transpiler:");
                }
            }
            return(fail ? instructions : codes);
        }
示例#8
0
 private static void EmitCallMethod(ILGenerator il, MethodInfo methodInfo)
 {
     if (methodInfo.IsStatic)
         il.EmitCall(OpCodes.Call, methodInfo, null);
     else
         il.EmitCall(OpCodes.Callvirt, methodInfo, null);
 }
示例#9
0
        public CodeGenerator(Expression pExpression, String pModuleName, ref LogHandler rLogHandler)
        {
            _symbolTable  = new Dictionary <String, Emit.LocalBuilder>();
            _assemblyName = new Reflect.AssemblyName(Path.GetFileNameWithoutExtension(pModuleName));

            _statement = pExpression;

            //Init Assembly
            _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(_assemblyName, Emit.AssemblyBuilderAccess.Save);
            _moduleBuilder   = _assemblyBuilder.DefineDynamicModule(pModuleName);
            _typeBuilder     = _moduleBuilder.DefineType("PascalCompilerType");
            _methodBuilder   = _typeBuilder.DefineMethod
                               (
                "Main",
                Reflect.MethodAttributes.Static,
                typeof(void),
                Type.EmptyTypes
                               );
            _ilGenerator = _methodBuilder.GetILGenerator();

            //Actual Work
            GenerateStatement(_statement, null);
            _ilGenerator.Emit(Emit.OpCodes.Ret);

            //Finalizing Work
            _typeBuilder.CreateType();
            _moduleBuilder.CreateGlobalFunctions();
            _assemblyBuilder.SetEntryPoint(_methodBuilder);
            _assemblyBuilder.Save(pModuleName);
        }
示例#10
0
 void CopyLabels(ILGenerator Gen, int i, Dictionary<int, Label> LateLabels)
 {
     if(!LateLabels.ContainsKey(i)) return;
     
     Gen.MarkLabel(LateLabels[i]);
     LateLabels.Remove(i);
 }
示例#11
0
		/// <summary>
		/// Emits a load indirect opcode of the appropriate type for a value or object reference.
		/// Pops a pointer off the evaluation stack, dereferences it and loads
		/// a value of the specified type.
		/// </summary>
		/// <param name="gen"></param>
		/// <param name="type"></param>
		public static void EmitLoadIndirectOpCodeForType(ILGenerator gen, Type type)
		{
			if (type.IsEnum)
			{
				EmitLoadIndirectOpCodeForType(gen, GetUnderlyingTypeOfEnum(type));
				return;
			}

			if (type.IsByRef)
			{
				throw new NotSupportedException("Cannot load ByRef values");
			}
			else if (type.IsPrimitive)
			{
				OpCode opCode = LdindOpCodesDictionary.Instance[type];

				if (Object.ReferenceEquals(opCode, LdindOpCodesDictionary.EmptyOpCode))
				{
					throw new ArgumentException("Type " + type + " could not be converted to a OpCode");
				}

				gen.Emit(opCode);
			}
			else if (type.IsValueType)
			{
				gen.Emit(OpCodes.Ldobj, type);
			}
			else
			{
				gen.Emit(OpCodes.Ldind_Ref);
			}
		}
示例#12
0
        private void CompileMainClass(Node ActiveNode)
        {
            Emit.TypeBuilder _TypeBuilder =
                TypeTable[ActiveNode.Nodes[1].Value];

            Emit.MethodBuilder MethBuilder = _TypeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
            this.AssemblerGenerator = MethBuilder.GetILGenerator();
            CurrentType             = _TypeBuilder;
            OpenBlockVariables();
            CreateCode(ActiveNode.Nodes[14]);


            CreateCode(ActiveNode.Nodes[15]);
            CloseBlockVariables();
            // Отладочные команды
            AssemblerGenerator.Emit(Emit.OpCodes.Ldstr, "Programm was finished. Press Enter key to quit...");
            AssemblerGenerator.Emit(Emit.OpCodes.Call,
                                    typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) }));
            AssemblerGenerator.Emit(Emit.OpCodes.Call,
                                    typeof(System.Console).GetMethod("ReadLine", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { }, null));
            AssemblerGenerator.Emit(Emit.OpCodes.Pop);
            AssemblerGenerator.Emit(Emit.OpCodes.Ret);

            CreatedTypeTable[ActiveNode.Nodes[1].Value] = _TypeBuilder.CreateType();

            ModBuilder.CreateGlobalFunctions();
            AsmBuilder.SetEntryPoint(MethBuilder);
        }
示例#13
0
文件: CodeGen.cs 项目: slb1988/cs143
    public CodeGen(Stmt stmt, string moduleName)
    {
        if (IO.Path.GetFileName(moduleName) != moduleName)
        {
            throw new System.Exception("can only output into current directory!");
        }

        Reflect.AssemblyName name        = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(moduleName));
        Emit.AssemblyBuilder asmb        = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save);
        Emit.ModuleBuilder   modb        = asmb.DefineDynamicModule(moduleName);
        Emit.TypeBuilder     typeBuilder = modb.DefineType("Foo");

        Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);

        // CodeGenerator
        this.il          = methb.GetILGenerator();
        this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();

        // Go Compile!
        this.GenStmt(stmt);

        il.Emit(Emit.OpCodes.Ret);
        typeBuilder.CreateType();
        modb.CreateGlobalFunctions();
        asmb.SetEntryPoint(methb);
        asmb.Save(moduleName);
        this.symbolTable = null;
        this.il          = null;
    }
示例#14
0
		public override void LoadReference(ILGenerator gen)
		{
			if (Position == -1)
			{
				throw new ApplicationException("ArgumentReference unitialized");
			}
			switch(Position)
			{
				case 0:
					gen.Emit(OpCodes.Ldarg_0);
					break;
				case 1:
					gen.Emit(OpCodes.Ldarg_1);
					break;
				case 2:
					gen.Emit(OpCodes.Ldarg_2);
					break;
				case 3:
					gen.Emit(OpCodes.Ldarg_3);
					break;
				default:
					gen.Emit(OpCodes.Ldarg, Position);
					break;
			}
		}
示例#15
0
        // Главная функция кодогенератора. Получает на вход синтаксическое дерево, обходит его и в хое его обхода с
        //     помощью библиотеки System.Reflection строит исполняемый файл на MSIL, который потом можно запускать вне компилятора (однако, на компьютере должна быть установлена .Net Framwork)
        //     Путь к файлу задаётся в интерфейсе компилятора
        public bool Proceed(Node Tree, RichTextBox RTB, string FileName)
        {
            _Tree = Tree;
            _RTB  = RTB;
            InitFileName(FileName);

            try
            {
                Reflect.AssemblyName Name = new Reflect.AssemblyName(FileName);
                AsmBuilder       = System.AppDomain.CurrentDomain.DefineDynamicAssembly(Name, Emit.AssemblyBuilderAccess.Save);
                ModBuilder       = AsmBuilder.DefineDynamicModule(FileName);
                TypeTable        = new Collections.Dictionary <string, Emit.TypeBuilder>();
                CreatedTypeTable = new Collections.Dictionary <string, System.Type>();
                SymbolTable      = new Collections.List <Collections.Dictionary <string, Emit.LocalBuilder> >();

                BeforeCompile(Tree);
                CreateCode(Tree);

                AsmBuilder.Save(FileName);
                this.SymbolTable        = null;
                this.AssemblerGenerator = null;
                this.TypeTable          = null;

                File.Move(FileName, FileName + ".exe");
                File.Delete(FileName);

                return(true);
            }
            catch (System.Exception Exc)
            {
                _RTB.Text = Exc.Message;

                return(false);
            }
        }
        static IEnumerable <CodeInstruction> LoadGameDataTranspiler(IEnumerable <CodeInstruction> instructions,
                                                                    SRE.ILGenerator generator,
                                                                    MethodBase methodInfo)
        {
            var methodTry = methodInfo.GetMethodBody().ExceptionHandlingClauses;
            var locals    = generator.GetGenVariables();
            var tryBlocks = generator.GetCecilGen().IL.Body.ExceptionHandlers;

            if (Patch.Debug)
            {
                printCode(instructions, locals, "Before Transpiler:");
            }
            bool fail = false;
            IEnumerable <CodeInstruction> codes;

            try
            {
                codes = XPiler(instructions, generator);
            }
            catch (Exception ex)
            {
                fail = true;
                LogError($"Error in Xpiler:\n{ex}");
                codes = null;
            }
            if (!fail && Patch.Debug)
            {
                printCode(codes, locals, "After Transpiler");
            }
            return(fail ? instructions : codes);
        }
示例#17
0
        public override void generar(Emit.ILGenerator il)
        {
            Emit.LocalBuilder tmpVarLogico;

            Console.WriteLine("Generando Nodo Condicional (IF)");
            this.condicion.generar(il);

            il.Emit(Emit.OpCodes.Ldc_I4_0); //Ingreso constante 0
            il.Emit(Emit.OpCodes.Ceq);      //Comparo si es falso (es 0)
            //Almaceno este resultado en una variable temporal
            tmpVarLogico = il.DeclareLocal(typeof(bool));
            il.Emit(Emit.OpCodes.Stloc, tmpVarLogico);
            //cargo el resultado de la variable temporal
            il.Emit(Emit.OpCodes.Ldloc, tmpVarLogico);
            Emit.Label bloqueFalso = il.DefineLabel();
            //salto en caso que sea verdadero el resultado es decir es cero la evaluacion del (pila==0) hago el sino
            il.Emit(Emit.OpCodes.Brtrue, bloqueFalso);

            Entonces.generar(il);

            Emit.Label finSi = il.DefineLabel();
            il.Emit(Emit.OpCodes.Br, finSi);
            il.MarkLabel(bloqueFalso);

            if (Sino != null)
            {
                Sino.generar(il);
            }

            il.MarkLabel(finSi);
        }
示例#18
0
        public override void Generate(ILGenerator generator, Symbols symbols)
        {
            //Save the previous variables
            var currentVariables = new List<string>();
            foreach (var item in symbols.Variables)
            {
                currentVariables.Add(item.Key);
                generator.Emit(OpCodes.Ldsfld, symbols.Variables[item.Key]);
            }

            DeclarationBlock.Generate(generator, symbols);
            InstructionsBlock.Generate(generator, symbols);

            LocalBuilder returnValue = null;
            if (InstructionsBlock.ExpressionType.Type != TypesEnumeration.Void)
            {
                returnValue = generator.DeclareLocal(symbols.GetRealType(InstructionsBlock.ExpressionType.ILName));
                generator.Emit(OpCodes.Stloc, returnValue);
            }

            currentVariables.Reverse();
            //load in the variables it's previous values
            currentVariables.ForEach(x => generator.Emit(OpCodes.Stsfld, symbols.Variables[x]));
            if (InstructionsBlock.ExpressionType.Type != TypesEnumeration.Void)
                generator.Emit(OpCodes.Ldloc, returnValue);
        }
示例#19
0
 /// <summary>
 /// 二項演算のコンパイル
 /// </summary>
 /// <param name="ilgen">IL Generator</param>
 /// <param name="expr">二項演算</param>
 static void CompileBinOpExpr(ILGenerator ilgen, MBinOpExpr expr)
 {
     CompileExpr(ilgen, expr.Lhs);
     CompileExpr(ilgen, expr.Rhs);
     switch (expr.OpType)
     {
         case BinOpType.Add:
             ilgen.Emit(OpCodes.Add);
             break;
         case BinOpType.Sub:
             ilgen.Emit(OpCodes.Sub);
             break;
         case BinOpType.Mul:
             ilgen.Emit(OpCodes.Mul);
             break;
         case BinOpType.Div:
             ilgen.Emit(OpCodes.Div);
             break;
         case BinOpType.Gt:
             CompileGtExpr(ilgen);
             break;
         case BinOpType.Eq:
             CompileEqExpr(ilgen);
             break;
         default:
             throw new NotImplementedException();
     }
 }
		public override void Emit(IEasyMember member, ILGenerator gen)
		{
			LocalBuilder local = gen.DeclareLocal( typeof(object[]) );
			gen.Emit(OpCodes.Ldc_I4, _args.Length);
			gen.Emit(OpCodes.Newarr, typeof(object));
			gen.Emit(OpCodes.Stloc, local);
			
			for(int i=0; i < _args.Length; i++)
			{
				gen.Emit(OpCodes.Ldloc, local);
				gen.Emit(OpCodes.Ldc_I4, i);

				TypeReference reference = _args[i];

				ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);

				if (reference.Type.IsByRef)
				{
					throw new NotSupportedException();
				}

				if (reference.Type.IsValueType)
				{
					gen.Emit(OpCodes.Box, reference.Type.UnderlyingSystemType);
				}
				
				gen.Emit(OpCodes.Stelem_Ref);
			}

			gen.Emit(OpCodes.Ldloc, local);
		}
示例#21
0
        public override void Emit(ILGenerator gen, bool labelSetAlready)
        {
            if (!labelSetAlready) MarkLabel(gen);
            MarkSequencePoint(gen);
            numericExpression.Emit(gen);
            gen.Emit(OpCodes.Call, typeof(BuiltIns).GetMethod("Round"));

            // We need to subtract one from the expression. OnGoto starts
            // counting at 1 and switch starts counting at 0.
            gen.Emit(OpCodes.Ldc_I4_1);
            gen.Emit(OpCodes.Sub);

            List<Label> destinations = new List<Label>();
            foreach (string target in targets)
            {
               destinations.Add(labels[target]);
            }
            gen.Emit(OpCodes.Switch, destinations.ToArray());

            // if the integer was larger than number of labels, then
            // switch falls thru to next statement. An On-Goto should
            // output BAD VALUE IN xx  error.
            gen.Emit(OpCodes.Ldstr, line.Label);
            BuiltInsMethodCall.BadValueError().Emit(gen);
        }
示例#22
0
        private void op_log_shift(ILGenerator il)
        {
            if (operandTypes[1] == OperandType.Variable)
            {
                MethodInfo impl = typeof(ZMachine).GetMethod("LogShiftImpl", BindingFlags.NonPublic | BindingFlags.Static);

                LoadOperand(il, 0);
                LoadOperand(il, 1);
                il.Emit(OpCodes.Call, impl);
            }
            else if (operandValues[1] < 0)
            {
                // shift right
                int value = -operandValues[1];
                LoadOperand(il, 0);
                il.Emit(OpCodes.Conv_U2);
                il.Emit(OpCodes.Ldc_I4, value);
                il.Emit(OpCodes.Shr_Un);
            }
            else
            {
                // shift left
                LoadOperand(il, 0);
                il.Emit(OpCodes.Ldc_I4, (int)operandValues[1]);
                il.Emit(OpCodes.Shl);
            }
            StoreResult(il);
        }
示例#23
0
 void LoadArguments(ILGenerator generator, Type[] paramsType)
 {
     for (int i = 0; i < paramsType.Length; i++)
     {
         generator.Emit(OpCodes.Ldarg_1);
         switch (i)
         {
             case 0: generator.Emit(OpCodes.Ldc_I4_0); break;
             case 1: generator.Emit(OpCodes.Ldc_I4_1); break;
             case 2: generator.Emit(OpCodes.Ldc_I4_2); break;
             case 3: generator.Emit(OpCodes.Ldc_I4_3); break;
             case 4: generator.Emit(OpCodes.Ldc_I4_4); break;
             case 5: generator.Emit(OpCodes.Ldc_I4_5); break;
             case 6: generator.Emit(OpCodes.Ldc_I4_6); break;
             case 7: generator.Emit(OpCodes.Ldc_I4_7); break;
             case 8: generator.Emit(OpCodes.Ldc_I4_8); break;
             default: generator.Emit(OpCodes.Ldc_I4, i); break;
         }
         generator.Emit(OpCodes.Ldelem_Ref);
         if (paramsType[i].IsValueType())
         {
             generator.Emit(OpCodes.Unbox_Any, paramsType[i]);
         }
         else if (paramsType[i] != typeof(object))
         {
             generator.Emit(OpCodes.Castclass, paramsType[i]);
         }
     }
 }
示例#24
0
        public static void FillEntity(ILGenerator generator, Type entityType, LocalBuilder entity)
        {
            //Dictionary<string, int> fields = DataPortal.FindFields(data);
            LocalBuilder fields = generator.DeclareLocal(typeof(Dictionary<string, int>));
            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(OpCodes.Call, typeof(DataPortal).GetMethod("FindFields", new Type[]{typeof(IDataRecord)}));
            generator.Emit(OpCodes.Stloc, fields);

            foreach(PropertyInfo property in entityType.GetProperties())
            {
                DbFieldAttribute fieldInfo = ReflectionHelper.GetAttribute<DbFieldAttribute>(property);
                if(fieldInfo == null)
                {
                    continue;
                }

                //int fieldIndex = DataPortal.FindField(fields, propInfo.Name);
                LocalBuilder fieldIndex = generator.DeclareLocal(typeof(Int32));
                generator.Emit(OpCodes.Ldloc, fields);
                generator.Emit(OpCodes.Ldstr, fieldInfo.FieldName);
                generator.Emit(OpCodes.Call, typeof(DataPortal).GetMethod("FindField", new Type[] { typeof(Dictionary<string, int>), typeof(string) }));
                generator.Emit(OpCodes.Stloc, fieldIndex);
                //if(fieldIndex >= 0)
                Label notFieldExists = generator.DefineLabel();
                generator.Emit(OpCodes.Ldloc, fieldIndex);
                generator.Emit(OpCodes.Ldc_I4_0);
                generator.Emit(OpCodes.Clt);
                generator.Emit(OpCodes.Brtrue_S, notFieldExists);
                {
                    FillProperty(generator, entityType, entity, property, fieldIndex);
                    generator.Emit(OpCodes.Nop);
                }
                generator.MarkLabel(notFieldExists);
            }
        }
示例#25
0
        private void op_restore(ILGenerator il)
        {
            if (argc == 0)
            {
                MethodInfo impl = typeof(ZMachine).GetMethod("RestoreQuetzal", BindingFlags.NonPublic | BindingFlags.Instance);

                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldc_I4, resultStorage);
                il.Emit(OpCodes.Ldc_I4, PC + ZCodeLength);
                il.Emit(OpCodes.Call, impl);

                compiling = false;
            }
            else
            {
                MethodInfo impl = typeof(ZMachine).GetMethod("RestoreAuxiliary", BindingFlags.NonPublic | BindingFlags.Instance);

                il.Emit(OpCodes.Ldarg_0);
                LoadOperand(il, 0);
                LoadOperand(il, 1);
                LoadOperand(il, 2);
                il.Emit(OpCodes.Call, impl);
                StoreResult(il);
            }
        }
示例#26
0
		public override void Generate (ILGenerator gen)
		{
			if (!object.ReferenceEquals (retValue, null))
				retValue.Generate (gen);

			gen.Emit (OpCodes.Br, codeBuilder.ReturnLabel);
		}
示例#27
0
		public FleeILGenerator(ILGenerator ilg, int startLength = 0, bool isTemp = false)
		{
			MyILGenerator = ilg;
			MyTempLocals = new Dictionary<Type, LocalBuilder>();
			MyIsTemp = isTemp;
			MyLength = startLength;
		}
示例#28
0
 private static void EmitBoxIfNeeded(ILGenerator il, System.Type type)
 {
     if (type.IsValueType)
     {
         il.Emit(OpCodes.Box, type);
     }
 }
示例#29
0
        public ILEmitter(Type callerType, object buildingType, System.Reflection.Emit.ILGenerator il,
                         [System.Runtime.CompilerServices.CallerMemberName] string callerMethod = "")
        {
            if (callerType == null)
            {
                throw new ArgumentNullException(nameof(callerType));
            }
            if (buildingType == null)
            {
                throw new ArgumentNullException(nameof(buildingType));
            }
            if (il == null)
            {
                throw new ArgumentNullException(nameof(il));
            }
            if (string.IsNullOrWhiteSpace(callerMethod))
            {
                throw new ArgumentException("Value cannot be null or whitespace.", nameof(callerMethod));
            }
            _il          = il;
            Emitter      = il;
            CallerMethod = callerMethod;

            BuildingType = buildingType;
            CallerType   = callerType;
        }
示例#30
0
        static void Main()
        {
            // prepare
            TypeBuilder typeBuilder = AppDomain.CurrentDomain
                .DefineDynamicAssembly(new AssemblyName("TLE"), AssemblyBuilderAccess.Run)
                .DefineDynamicModule("TLE")
                .DefineType("TLE", TypeAttributes.Public);
            MethodBuilder methodBuilder = typeBuilder.DefineMethod("Run",
                MethodAttributes.Static | MethodAttributes.Public,
                null, new Type[] { typeof(int[]), typeof(bool[]) });
            ILGen = methodBuilder.GetILGenerator();

            // parse
            foreach (string s in Console.In.ReadToEnd().Split(new char[] { '\n', '\r' }).Select(s => s.Trim())) Parse(s);
            ILGen.Emit(OpCodes.Ret);
            values = new int[variables.Count];
            inits = new bool[variables.Count];

            // run
            try
            {
                typeBuilder.CreateType().InvokeMember("Run",
                    BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public,
                    null, null, new object[] { values, inits });
            }
            catch (Exception)
            {
                Console.WriteLine("Program terminated. Variables state:");
                foreach (var variable in variables.OrderBy(x => x.Key, StringComparer.Ordinal))
                    if (inits[variable.Value]) Console.WriteLine("{0}: {1}", variable.Key, values[variable.Value]);
            }
        }
示例#31
0
        public override void GenerateCode(ILGenerator codeGenerator, TypeBuilder typeBuilder, ModuleBuilder moduleBuilder)
        {
            LeftOperand.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
            RightOperand.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);

            Label endLabel = codeGenerator.DefineLabel();
            Label trueLabel = codeGenerator.DefineLabel();

            if (LeftOperand.ReturnType == StringType.StringInstance)
            {
                codeGenerator.Emit(OpCodes.Call, typeof(String).GetMethod("CompareTo", new Type[] { typeof(string) }));
                codeGenerator.Emit(OpCodes.Ldc_I4_0);
                codeGenerator.Emit(OpCodes.Bne_Un, trueLabel);
            }
            else
                codeGenerator.Emit(OpCodes.Bne_Un, trueLabel);

            codeGenerator.Emit(OpCodes.Ldc_I4_0);
            codeGenerator.Emit(OpCodes.Br, endLabel);

            codeGenerator.MarkLabel(trueLabel);
            codeGenerator.Emit(OpCodes.Ldc_I4_1);

            codeGenerator.MarkLabel(endLabel);
        }
        public override LocalBuilder BuildArguments(ILGenerator ilGenerator)
        {
            LocalBuilder propertyLocalBuilder = null;
            FieldBuilder contractFieldBuilder = null;
            LocalBuilder aspectArgLocalBuilder = null;
            ConstructorInfo ctorInterceptionArgs = null;
            AbstractAspectPropertyArgsWeaver methodWeaver = null;

            propertyLocalBuilder = LocalBuilderRepository.Declare(() => {
                return ilGenerator.DeclareLocal(typeof(PropertyInfo));
            });

            ctorInterceptionArgs = ArgumentType.GetConstructors()[0];
            aspectArgLocalBuilder = ilGenerator.DeclareLocal(ArgumentType);
            contractFieldBuilder = WeavingSettings.TypeDefinition.GetFieldBuilder(WeavingSettings.ContractType);
            methodWeaver = new AspectArgsGetPropertyWeaver(Member, propertyLocalBuilder, aspectWeavingSettings);
            methodWeaver.Weave(ilGenerator);
            ilGenerator.EmitLoadArg(0);
            ilGenerator.Emit(OpCodes.Ldfld, contractFieldBuilder);
            ilGenerator.EmitLoadLocal(propertyLocalBuilder);
            ilGenerator.Emit(OpCodes.Ldsfld, BindingsDependency);
            ilGenerator.Emit(OpCodes.Newobj, ctorInterceptionArgs);
            ilGenerator.EmitStoreLocal(aspectArgLocalBuilder);

            return aspectArgLocalBuilder;
        }
		protected AbstractCodeBuilder(ILGenerator generator)
		{
			this.generator = generator;
			stmts = new ArrayList();
			ilmarkers = new ArrayList();
			isEmpty = true;
		}
示例#34
0
        static void GenDeserializerBody(CodeGenContext ctx, Type type, ILGenerator il)
        {
            if (type.IsClass)
            {
                // instantiate empty class
                il.Emit(OpCodes.Ldarg_1);

                var gtfh = typeof(Type).GetMethod("GetTypeFromHandle", BindingFlags.Public | BindingFlags.Static);
                var guo = typeof(System.Runtime.Serialization.FormatterServices).GetMethod("GetUninitializedObject", BindingFlags.Public | BindingFlags.Static);
                il.Emit(OpCodes.Ldtoken, type);
                il.Emit(OpCodes.Call, gtfh);
                il.Emit(OpCodes.Call, guo);
                il.Emit(OpCodes.Castclass, type);

                il.Emit(OpCodes.Stind_Ref);
            }

            var fields = GetFieldInfos(type);

            foreach (var field in fields)
            {
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldarg_1);
                if (type.IsClass)
                    il.Emit(OpCodes.Ldind_Ref);
                il.Emit(OpCodes.Ldflda, field);

                GenDeserializerCall(ctx, il, field.FieldType);
            }

            il.Emit(OpCodes.Ret);
        }
示例#35
0
 public override void Generate(ILGenerator generator, Symbols symbols)
 {
     if (symbols.Records.ContainsKey(Alias.ILName))
         symbols.Records.Add(Identifier.ILName, symbols.Records[Alias.ILName]);
     else
         symbols.ArraysTypes.Add(Identifier.ILName, symbols.ArraysTypes[Alias.ILName]);
 }
示例#36
0
 public override void generar(Emit.ILGenerator il)
 {
     foreach (Sentencia sent in lista)
     {
         sent.generar(il);
     }
 }
示例#37
0
        public void EmitGetTypeArrayMethodIL(System.Reflection.Emit.ILGenerator emit, Type[] array)
        {
            var e = emit;

            e.DeclareLocal(typeof(Type[]));
            e.Emit(OpCodes.Ldc_I4, array.Length);
            e.Emit(OpCodes.Newarr, typeof(Type));

            var mGetTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle",
                                                            new[] { typeof(RuntimeTypeHandle) });

            var i = 0;

            foreach (var p in array)
            {
                e.Emit(OpCodes.Dup);
                e.Emit(OpCodes.Ldc_I4, i);
                e.Emit(OpCodes.Ldtoken, p);
                e.Emit(OpCodes.Call, mGetTypeFromHandle);
                e.Emit(OpCodes.Stelem_Ref);

                i += 1;
            }
            e.Emit(OpCodes.Ret);
        }
示例#38
0
        private Emit.MethodBuilder GenerateMethod(Emit.MethodBuilder methb, MethodDeclaration method)
        {
            this.il             = methb.GetILGenerator();
            this.symbolTable    = new Collections.Dictionary <string, Emit.LocalBuilder>();
            this.parameterTable = new System.Collections.Generic.Dictionary <string, Type>();

            //foreach (string arg in method.parameters)
            //{
            //    parameterTable[arg] = typeof(string);
            //}

            foreach (Collections.KeyValuePair <string, Type> para in method.parameters)
            {
                parameterTable[para.Key] = para.Value;
            }


            this.GenStmt(method.stmt);

            Collections.List <Type> args = new System.Collections.Generic.List <Type>();

            foreach (Collections.KeyValuePair <string, Type> para in parameterTable)
            {
                args.Add(para.Value);
            }


            //foreach(string arg in method.parameters)
            //{
            //    args.Add(typeof(string));
            //}

            methb.SetParameters(args.ToArray());
            return(methb);
        }
示例#39
0
		/// <summary>
		/// Emit a call to get the value.
		/// </summary>
		/// <param name="il">The IL generator to use.</param>
		public void EmitGetValue(ILGenerator il)
		{
			if (FieldInfo != null)
				il.Emit(OpCodes.Ldfld, FieldInfo);
			else
				il.Emit(OpCodes.Callvirt, MethodInfo);
		}
 /// <summary>
 /// Emits a conversion to type object for the value on the stack.
 /// </summary>
 /// <param name="generator">The code generator to use.</param>
 /// <param name="sourceType">The type of value on the stack.</param>
 public static void EmitToObjectConversion(ILGenerator generator, Type sourceType)
 {
     if (sourceType.IsValueType)
     {
         generator.Emit(OpCodes.Box, sourceType);
     }
 }
		protected AbstractCodeBuilder(ILGenerator generator)
		{
			this.generator = generator;
			stmts = new List<Statement>();
			ilmarkers = new List<Reference>();
			isEmpty = true;
		}
示例#42
0
 private Emit.MethodBuilder GenerateMethod(Emit.TypeBuilder typeBuilder, MethodDeclaration method)
 {
     Emit.MethodBuilder methb = typeBuilder.DefineMethod(method.MethodName, Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
     this.il          = methb.GetILGenerator();
     this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
     this.GenStmt(method.stmt);
     return(methb);
 }
示例#43
0
 public void FinishGen()
 {
     this.il.Emit(Emit.OpCodes.Ret);
     this.typeBuilder.CreateType();
     this.modb.CreateGlobalFunctions();
     this.asmb.SetEntryPoint(methb);
     this.asmb.Save(this.program_name);
     this.il = null;
 }
示例#44
0
 public override void generar(Emit.ILGenerator il)
 {
     if (!TinyCompiler.generador.GeneradorCodigo.TablaDireccionesSimbolos.ContainsKey(Nombre.Texto))
     {
         throw new System.Exception("ERROR-0007 fallo en analisis semantico Variable no declarada encontrada durante generacion '" + Nombre.Texto + "'");
     }
     else
     {
         il.Emit(Emit.OpCodes.Ldloc, TinyCompiler.generador.GeneradorCodigo.TablaDireccionesSimbolos[Nombre.Texto]);
     }
 }
示例#45
0
        internal MethodBuilder(MethodName name)
        {
            Name = name;


            var invokeInfo     = typeof(Invokable).GetMethod("Invoke");
            var parameterTypes = (from param in invokeInfo.GetParameters() select param.ParameterType).ToArray();

            _dynamicMethod = new DynamicMethod(name.Simple, invokeInfo.ReturnType, parameterTypes, this.GetType());
            _g             = _dynamicMethod.GetILGenerator();
        }
        /// <summary>
        /// Emit a reference to an arbitrary object. Note that the references "leak."
        /// </summary>
        public static int EmitGetReference <T>(this SRE.ILGenerator il, int id)
        {
            Type t = typeof(T);

            il.Emit(SRE.OpCodes.Ldc_I4, id);
            il.Emit(SRE.OpCodes.Call, _GetReference);
            if (t.IsValueType)
            {
                il.Emit(SRE.OpCodes.Unbox_Any, t);
            }
            return(id);
        }
示例#47
0
        private void CompileMethodDecl(Node ActiveNode)
        {
            OpenBlockVariables();
            OpenParametersBlock();
            // Разбираем список переменных
            CreateCode(ActiveNode.Nodes[4]);

            // Создаём объявление метода
            Emit.MethodBuilder Method;


            if (FormalIds.Count == 0)
            {
                Method = CurrentType.DefineMethod(ActiveNode.Nodes[2].Value, Reflect.MethodAttributes.Public,
                                                  TypeByTypeId(ActiveNode.Nodes[1]),
                                                  System.Type.EmptyTypes);


                System.Type Tst = System.Type.GetType(ActiveNode.Nodes[1].Nodes[0].Value);
            }
            else
            {
                Collections.List <System.Type> FormalParameters = new Collections.List <System.Type>();

                for (int i = 0; i < FormalIds.Count; i++)
                {
                    FormalParameters.Add(TypeByTypeId(FormalTypes[i]));
                }

                Method = CurrentType.DefineMethod(ActiveNode.Nodes[2].Value, Reflect.MethodAttributes.Public,
                                                  TypeByTypeId(ActiveNode.Nodes[1]),
                                                  FormalParameters.ToArray());
            }
            this.AssemblerGenerator = Method.GetILGenerator();

            // Обнуляем список формальных параметров
            FormalTypes = new Collections.List <Node>();
            FormalIds   = new Collections.List <Node>();

            // Вызываем разбор объявлений переменных
            CreateCode(ActiveNode.Nodes[7]);


            // Вызываем разбор тела метода
            CreateCode(ActiveNode.Nodes[8]);
            CreateCode(ActiveNode.Nodes[10]);

            // Завершаем метод
            AssemblerGenerator.Emit(Emit.OpCodes.Ret);

            CloseBlockVariables();
            CloseParametersBLock();
        }
示例#48
0
    public void genMain()
    {
        //Debemos poner el ret correcto
        if (this.il != null)
        {
            this.il.Emit(Emit.OpCodes.Ret);
        }

        this.methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void),
                                              System.Type.EmptyTypes);
        this.il = methb.GetILGenerator();
    }
示例#49
0
        public override void generar(Emit.ILGenerator il)
        {
            List <FuncionDef> funs = NucleoLenguaje.Instancia.getFuncBasicas();

            foreach (FuncionDef fun in funs)
            {
                if (Id.Texto.Equals(fun.Nombre.Texto))
                {
                    fun.ejecutarMetodo(il, this.Params);
                }
            }
        }
示例#50
0
        private List <CodeInstruction> ApplyTranspilers(SRE.ILGenerator il, MethodBase original = null)
        {
            var tempInstructions = MakeBranchesLong(codeInstructions);

            foreach (var transpiler in transpilers)
            {
                var args = GetTranpilerArguments(il, transpiler, tempInstructions, original);

                Logger.Log(Logger.LogChannel.Info, () => $"Running transpiler {transpiler.GetID()}");
                tempInstructions = MakeBranchesLong(transpiler.Invoke(null, args) as IEnumerable <CodeInstruction>);
            }

            return(tempInstructions.ToList());
        }
示例#51
0
        private void finalizar(string nombreEjecutable)
        {
            //Asigno una pausa para indicar que finalizo la ejecucion del codigo objetivo generado
            anadirPausa();
            //Creo el assembler .net y defino las ultimas opciones de configuracion
            il.Emit(Emit.OpCodes.Ret);
            Type pp = typeBuilder.CreateType();

            modb.CreateGlobalFunctions();
            asmb.SetEntryPoint(methb, Reflect.Emit.PEFileKinds.ConsoleApplication);
            asmb.Save(IO.Path.GetFileName(nombreEjecutable));
            //Ahora procedo a limpiar la tabla de direcciones para su proximo uso.
            TablaDireccionesSimbolos.Clear();
            this.il = null;
        }
示例#52
0
        public override void generar(Emit.ILGenerator il)
        {
            Emit.LocalBuilder tmpCondicion;
            tmpCondicion = il.DeclareLocal(typeof(bool));
            Emit.Label sentenciasRepita = il.DefineLabel();
            il.MarkLabel(sentenciasRepita);
            il.Emit(Emit.OpCodes.Nop);          //emito primera sentencia vacia

            Sentencias.generar(il);

            Condicion.generar(il);

            il.Emit(Emit.OpCodes.Stloc, tmpCondicion);  //almaceno resultado de condicion del mientras
            il.Emit(Emit.OpCodes.Ldloc, tmpCondicion);  //cargo resultado de condicion del mientras
            il.Emit(Emit.OpCodes.Brfalse, sentenciasRepita);
        }
示例#53
0
        private static Func <IServiceFactory, IQuery <TResult>, Task <TResult> > CreateDelegate <TResult>(Type queryType)
        {
            // Define the signature of the dynamic method.
            var dynamicMethod = new System.Reflection.Emit.DynamicMethod("Sql", typeof(Task <TResult>), new[] { typeof(IServiceFactory), typeof(IQuery <TResult>) });

            System.Reflection.Emit.ILGenerator generator = dynamicMethod.GetILGenerator();

            // Create the closed generic query handler type.
            Type queryHandlerType = typeof(IQueryHandler <,>).MakeGenericType(queryType, typeof(TResult));

            // Get the MethodInfo that represents the HandleAsync method.
            MethodInfo method = queryHandlerType.GetMethod("HandleAsync");

            // Push the service factory onto the evaluation stack.
            generator.Emit(OpCodes.Ldarg_0);

            // Push the query handler type onto the evaluation stack.
            generator.Emit(OpCodes.Ldtoken, queryHandlerType);
            generator.Emit(OpCodes.Call, GetTypeFromHandleMethod);

            // Call the GetInstance method and push the query handler
            // instance onto the evaluation stack.
            generator.Emit(OpCodes.Callvirt, GetInstanceMethod);

            // Since the GetInstance method returns an object,
            // we need to cast it to the actual query handler type.
            generator.Emit(OpCodes.Castclass, queryHandlerType);

            // Push the query onto the evaluation stack.
            generator.Emit(OpCodes.Ldarg_1);

            // The query is passed in as an IQuery<TResult> instance
            // and we need to cast it to the actual query type.
            generator.Emit(OpCodes.Castclass, queryType);

            // Call the Sql method and push the Task<TResult>
            // onto the evaluation stack.
            generator.Emit(OpCodes.Callvirt, method);

            // Mark the end of the dynamic method.
            generator.Emit(OpCodes.Ret);

            var getQueryHandlerDelegate =
                dynamicMethod.CreateDelegate(typeof(Func <IServiceFactory, IQuery <TResult>, Task <TResult> >));

            return((Func <IServiceFactory, IQuery <TResult>, Task <TResult> >)getQueryHandlerDelegate);
        }
示例#54
0
        private void inicializar(string nombreCodigoFuente, string nombrePrograma)
        {
            if (TablaDireccionesSimbolos.Count > 0)
            {
                throw new System.Exception("ERROR-0002: Tabla de direcciones de variables ha sido inicializada previamente");
            }

            String rutaEjecutable = IO.Path.GetDirectoryName(nombrePrograma);

            //Describo el identificador unico del ensamblado que se esta generando
            nombre = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(nombrePrograma));

            //Creo la representacion basica del ensamblado creado de forma dinamica (assembly)
            if (rutaEjecutable.Length > 0)
            {
                asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave, rutaEjecutable);
            }
            else
            {
                asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave);
            }



            Console.WriteLine("Common Runtime usado para generar el ejecutable del programa: " + asmb.ImageRuntimeVersion);
            Console.WriteLine("Se esta ejecutando el compilador bajo el CLR version {0}", Environment.Version);

            //Defino un nuevo modulo de .net de forma dinamica
            modb = asmb.DefineDynamicModule(IO.Path.GetFileName(nombrePrograma), false);

            //Creo una nueva clase en el Il Generator stream
            typeBuilder = modb.DefineType("pseudoGenerado");

            //Debido a que los programas en este tiny solo cuentan con un unico metodo principal (Main) de forma estructurada
            //como un truco defino el metodo Main en un objeto por defecto para ejecutar todas las acciones
            //expresadas por el lenguaje alli.
            //formato: NOMBRE -> Main   TIPO-> Static  RETORNA-> void  PARAMETROS-> vacios
            methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.HideBySig | Reflect.MethodAttributes.Static | Reflect.MethodAttributes.Public, typeof(void), System.Type.EmptyTypes);

            //Inicializo/Creo el generador/stream de codigo IL con el metodo donde generare el codigo actualmente
            this.il = methb.GetILGenerator();

            //Para iniciar el programa Emito una primera instruccion vacia (no hace nada)
            il.Emit(Emit.OpCodes.Nop);
        }
 /// <summary>
 /// Fill the DynamicMethod with a stub.
 /// </summary>
 public static SRE.DynamicMethod Stub(this SRE.DynamicMethod dm)
 {
     SRE.ILGenerator il = dm.GetILGenerator();
     for (int i = 0; i < 32; i++)
     {
         // Prevent mono from inlining the DynamicMethod.
         il.Emit(SRE.OpCodes.Nop);
     }
     if (dm.ReturnType != typeof(void))
     {
         il.DeclareLocal(dm.ReturnType);
         il.Emit(SRE.OpCodes.Ldloca_S, (sbyte)0);
         il.Emit(SRE.OpCodes.Initobj, dm.ReturnType);
         il.Emit(SRE.OpCodes.Ldloc_0);
     }
     il.Emit(SRE.OpCodes.Ret);
     return(dm);
 }
示例#56
0
        //Almacena el valor del tope de la pila en el nombre de variable proporcionado (no maneja ambito)
        public static void Almacenar(string nombre, Emit.ILGenerator _il)
        {
            if (!TablaDireccionesSimbolos.ContainsKey(nombre))
            {
                TablaDireccionesSimbolos[nombre] = _il.DeclareLocal(typeof(System.Int32));  //Solo variables enteras
            }

            Emit.LocalBuilder variableLocal = TablaDireccionesSimbolos[nombre];

            if (!variableLocal.LocalType.HasElementType) //(es una variable simple) verdadero solo en caso de vectores o matrices
            {
                _il.Emit(Emit.OpCodes.Stloc, TablaDireccionesSimbolos[nombre]);
            }
            else //es una matriz o vector y actuo acorde
            {
                throw new System.Exception("No se soportan arrays o matrices en las asignaciones");
            }
        }
示例#57
0
 public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
 {
     if (_reference != null)
     {
         ArgumentsUtil.EmitLoadOwnerAndReference(_reference, gen);
     }
     else if (_expression != null)
     {
         _expression.Emit(member, gen);
     }
     else
     {
         if (member.ReturnType != typeof(void))
         {
             OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, member.ReturnType);
         }
     }
     gen.Emit(OpCodes.Ret);
 }
示例#58
0
        public void Compile(Program Program, string moduleName)
        {
            if (System.IO.Path.GetFileName(moduleName) != moduleName)
            {
                throw new Exception("can only output into current directory!");
            }

            // Deal with arguments
            Type[] argTypes = new Type[Program.Variables.Length];
            for (int i = 0; i < Program.Variables.Length; i++)
            {
                argTypes[i] = typeof(int);
                m_ArgTable.Add(Program.Variables[i].Name, i);
            }

            AssemblyName    name        = new AssemblyName(System.IO.Path.GetFileNameWithoutExtension(moduleName));
            AssemblyBuilder asmb        = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Save);
            ModuleBuilder   modb        = asmb.DefineDynamicModule(moduleName);
            TypeBuilder     typeBuilder = modb.DefineType("Prog.Program", TypeAttributes.Public);
            MethodBuilder   methb       = typeBuilder.DefineMethod("Function", MethodAttributes.Static | MethodAttributes.Public, typeof(int), argTypes);

            for (int i = 0; i < Program.Variables.Length; i++)
            {
                methb.DefineParameter(i + 1, ParameterAttributes.HasDefault, Program.Variables[i].Name);
            }

            // CodeGenerator
            this.il          = methb.GetILGenerator();
            this.symbolTable = new Dictionary <string, LocalBuilder>();

            // Go Compile
            GenerateStatement(Program.TopNode);

            il.Emit(OpCodes.Ret);
            typeBuilder.CreateType();
            modb.CreateGlobalFunctions();
            asmb.SetEntryPoint(methb);
            asmb.Save(moduleName);

            this.symbolTable = null;
            this.il          = null;
        }
示例#59
0
        private int GetSize(string target)
        {
            Type targetType = Type.GetType(target, false);

            if (targetType == null)
            {
                return(-1);
            }

            SRE.DynamicMethod dm = new SRE.DynamicMethod("", typeof(int), null);

            SRE.ILGenerator gen = dm.GetILGenerator();

            gen.Emit(SRE.OpCodes.Sizeof, targetType);
            gen.Emit(SRE.OpCodes.Ret);

            SizeDM del = (SizeDM)dm.CreateDelegate(typeof(SizeDM));

            return(del());
        }
示例#60
0
        public void EmitGetStringArrayMethodIL(System.Reflection.Emit.ILGenerator emit, string[] array)
        {
            var e = emit;

            e.DeclareLocal(typeof(string[]));
            e.Emit(OpCodes.Ldc_I4, array.Length);
            e.Emit(OpCodes.Newarr, typeof(string));

            var i = 0;

            foreach (var p in array)
            {
                e.Emit(OpCodes.Dup);
                e.Emit(OpCodes.Ldc_I4, i);
                e.Emit(OpCodes.Ldstr, p);
                e.Emit(OpCodes.Stelem_Ref);
                i += 1;
            }
            e.Emit(OpCodes.Ret);
        }