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); }
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(); }
public TypeLocalPool(ILGenerator gen, Type t) { this.Type = t; this.stack = new Stack<LocalBuilder>(); this.queue = new Queue<LocalBuilder>(); this.ilgen = gen; }
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); }
private static void EmitCallMethod(ILGenerator il, MethodInfo methodInfo) { if (methodInfo.IsStatic) il.EmitCall(OpCodes.Call, methodInfo, null); else il.EmitCall(OpCodes.Callvirt, methodInfo, null); }
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); }
void CopyLabels(ILGenerator Gen, int i, Dictionary<int, Label> LateLabels) { if(!LateLabels.ContainsKey(i)) return; Gen.MarkLabel(LateLabels[i]); LateLabels.Remove(i); }
/// <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); } }
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); }
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; }
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; } }
// Главная функция кодогенератора. Получает на вход синтаксическое дерево, обходит его и в хое его обхода с // помощью библиотеки 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); }
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); }
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); }
/// <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); }
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); }
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); }
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]); } } }
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); } }
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); } }
public override void Generate (ILGenerator gen) { if (!object.ReferenceEquals (retValue, null)) retValue.Generate (gen); gen.Emit (OpCodes.Br, codeBuilder.ReturnLabel); }
public FleeILGenerator(ILGenerator ilg, int startLength = 0, bool isTemp = false) { MyILGenerator = ilg; MyTempLocals = new Dictionary<Type, LocalBuilder>(); MyIsTemp = isTemp; MyLength = startLength; }
private static void EmitBoxIfNeeded(ILGenerator il, System.Type type) { if (type.IsValueType) { il.Emit(OpCodes.Box, type); } }
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; }
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]); } }
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; }
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); }
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]); }
public override void generar(Emit.ILGenerator il) { foreach (Sentencia sent in lista) { sent.generar(il); } }
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); }
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); }
/// <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; }
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); }
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; }
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]); } }
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); }
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(); }
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(); }
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); } } }
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()); }
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; }
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); }
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); }
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); }
//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"); } }
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); }
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; }
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()); }
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); }