public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg) { Type type = Type.EmptyTypes.GetType(); for (int i = 0; i < Compiler.Types.Count; i++) if (Compiler.Types[i].name == Expr.ReturnType.Name) type = Compiler.SearchType(Compiler.Types[i].typeArray); if (assign) { assign = false; LocalBuilder local = cg.DeclareLocal(type); cg.Emit(OpCodes.Stloc, local); Expr.GenCode(tb, mb, cg);//pone el array, luego el index y luego el valor para hacer stelem Index.GenCode(tb, mb, cg); cg.Emit(OpCodes.Ldloc, local); cg.Emit(OpCodes.Stelem, type); } else { Expr.GenCode(tb, mb, cg); Index.GenCode(tb, mb, cg); cg.Emit(OpCodes.Ldelem, type); } }
protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination) { var genericArgs = source.GetGenericArguments(); if (genericArgs.Length == 0) { return new GenericTypeParameterBuilder[0]; } var names = new string[genericArgs.Length]; for (var i = 0; i < genericArgs.Length; i++) { names[i] = genericArgs[i].Name; } var genericTypeParameterBuilders = destination.DefineGenericParameters(names); for (var i = 0; i < genericTypeParameterBuilders.Length; i++) { var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints(); for (var j = 0; j < genericArgConstraints.Length; j++) { genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]); } } return genericTypeParameterBuilders; }
private void GenerateFunction(TypeBuilder typeBuilder, out MethodBuilder methodBuilder) { methodBuilder = null; ProgramDeclBlock pdb = this.expr as ProgramDeclBlock; if (pdb != null) { foreach (var function in pdb.Statements) { var functionDecl = function as BlockDeclExpr; if (functionDecl != null) { bool isMain = functionDecl.IsMain; var parameters = functionDecl.Parameters; Expr mainFunctionParameters = null; if (isMain) { mainFunctionParameters = GenerateMainMethod( typeBuilder, functionDecl, parameters, mainFunctionParameters, out methodBuilder); } } } } }
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); }
public void IncLevel(int i, string procId) { Debug.WriteLine(String.Format("Generator: IncLevel({0},{1})", i, procId)); if(i > 0) currentMethodBuilder = currentType.DefineMethod(procId, MethodAttributes.Static, typeof(void), System.Type.EmptyTypes); }
public ILDynamicMethodDebugImpl(string name, Type delegateType, Type thisType) { _delegateType = delegateType; _expectedLength = 64; var mi = delegateType.GetMethod("Invoke"); var uniqueName = ILDynamicTypeDebugImpl.UniqueName(name); _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(uniqueName), AssemblyBuilderAccess.RunAndSave, DynamicILDirectoryPath.DynamicIL); _moduleBuilder = _assemblyBuilder.DefineDynamicModule(uniqueName + ".dll", true); var sourceCodeFileName = Path.Combine(DynamicILDirectoryPath.DynamicIL, uniqueName + ".il"); _symbolDocumentWriter = _moduleBuilder.DefineDocument(sourceCodeFileName, SymDocumentType.Text, SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft); _sourceCodeWriter = new SourceCodeWriter(sourceCodeFileName, _symbolDocumentWriter); Type[] parameterTypes; if (thisType != null) { parameterTypes = new[] { thisType }.Concat(mi.GetParameters().Select(pi => pi.ParameterType)).ToArray(); } else { parameterTypes = mi.GetParameters().Select(pi => pi.ParameterType).ToArray(); } _sourceCodeWriter.StartMethod(name, mi.ReturnType, parameterTypes, MethodAttributes.Static); _typeBuilder = _moduleBuilder.DefineType(name, TypeAttributes.Public, typeof(object), Type.EmptyTypes); _forbidenInstructions = new ILGenForbidenInstructionsCheating(_typeBuilder); _dynamicMethod = _typeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Static, mi.ReturnType, parameterTypes); for (int i = 0; i < parameterTypes.Length; i++) { _dynamicMethod.DefineParameter(i + 1, ParameterAttributes.In, string.Format("arg{0}", i)); } }
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 InjectableConstructorArg(Type propertyType, string name, MethodBuilder getter, MethodBuilder setter) { PropertyType = propertyType; Name = name; Getter = getter; Setter = setter; }
private static void EmitMethodBody (MethodBuilder methodBuilder, MethodInfo methodInfo, String message) { Type returnType = methodInfo.ReturnType; ILGenerator generator = methodBuilder.GetILGenerator (); ParameterInfo[] parameterInfos = methodInfo.GetParameters (); if (returnType == typeof(void)) { MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_VOID_ARGS; // Makes the actual call generator.Emit (OpCodes.Ldarg_0); generator.Emit (OpCodes.Ldstr, message); EmitParametersAsArrayOnStack (generator, parameterInfos); generator.Emit (OpCodes.Call, sendMessageInvoker); generator.Emit (OpCodes.Ret); } else { MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_ARGS_GENERIC.MakeGenericMethod (returnType); // Makes the actual call generator.Emit (OpCodes.Ldarg_0); generator.Emit (OpCodes.Ldstr, message); EmitParametersAsArrayOnStack (generator, parameterInfos); generator.Emit (OpCodes.Call, sendMessageInvoker); generator.Emit (OpCodes.Ret); } }
public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg) { List<Type> parametersConstructor = new List<Type>(); List<FieldBuilder> campos = new List<FieldBuilder>(); foreach (var item in Parameters) { parametersConstructor.Add(Compiler.SearchType(item.Type)); campos.Add(tb.DefineField(item.Id, Compiler.SearchType(item.Type), FieldAttributes.Public)); } ConstructorBuilder constructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, parametersConstructor.ToArray()); Compiler.RecordConstructors.Add(new RecordsConstructors(tb.Name, constructor)); ILGenerator ilgen = constructor.GetILGenerator(); Type objType = Type.GetType("System.Object"); ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);//creando el contructor vacio para generar el otro ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Call, objCtor); int i = 1; foreach (var item in campos)//poniendole los valores de los campos a lsa propiedades { ilgen.Emit(OpCodes.Ldarg_0);//este objeto ilgen=contructor.getIlgenerator() ilgen.Emit(OpCodes.Ldarg, i);//tiene un field item ilgen.Emit(OpCodes.Stfld, item);//y en el se pone el valor del argumento i del contructor i++; } ilgen.Emit(OpCodes.Ret); record = tb.CreateType(); }
internal TypeBuilder(string szName, int genParamPos, MethodBuilder declMeth) { this.m_declMeth = declMeth; this.m_DeclaringType = this.m_declMeth.GetTypeBuilder(); this.m_module = declMeth.GetModuleBuilder(); this.InitAsGenericParam(szName, genParamPos); }
private void CreateContinueMethod(MethodInfo method, MethodBuilder continueMethod, int position, Type[] parameters, int count) { var generator = continueMethod.GetILGenerator(); // Store array in temp0 generator.DeclareLocal(typeof (object[])); generator.LoadArgument(1); generator.StashTemporaryVariable(0); // Push backing object onto the stack generator.LoadField(backingObject); // Push each of the arguments passed in onto the stack for (int i = 0; i < count; i++) { generator.LoadTemporaryVariable(0); generator.LoadInteger(i); generator.Emit(OpCodes.Ldelem_Ref); generator.MaybeUnBox(parameters[i]); } // Delegate to backing object generator.Execute(method); // Convert the returned value to an object if (method.ReturnType == typeof(void)) generator.LoadNull(); else generator.MaybeBox(method.ReturnType); // Return generator.Emit(OpCodes.Ret); }
public static IILRewriterContext RewriteInto(this MethodBase src, MethodBuilder dest, Func<IILOp, IILRewriteControl, IILRewriteControl> logic) { var rewriter = new ILRewriter(src, dest, logic); rewriter.DoRewrite(); return rewriter; }
private static MethodInfo GetDecompressLZF(ModuleBuilder modBldr, GeneratorOptions config) { CreateTb(modBldr, config); if (decompress_LZF == null) decompress_LZF = EmitDecompressLZF(mTb); return decompress_LZF; }
protected void SetUp () { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = GetType().FullName; AssemblyBuilder assembly = Thread.GetDomain().DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run); module = assembly.DefineDynamicModule("module1"); tb = module.DefineType("class1", TypeAttributes.Public); eb = tb.DefineEvent ("event1", EventAttributes.None, typeof (AnEvent)); mb = tb.DefineMethod ("OnAnEvent", MethodAttributes.Public, typeof (void), new Type [] { typeof (AnEvent) }); ILGenerator ilgen = mb.GetILGenerator(); ilgen.Emit (OpCodes.Ret); // These two are required eb.SetAddOnMethod (mb); eb.SetRemoveOnMethod (mb); }
public void Emit(CompilerErrorCollection errors, MethodBuilder m) { //Set the parameters //ParameterBuilder[] parms = new ParameterInfo[args.Length]; for(int i = 0; i < args.Length; i++) m.DefineParameter(i + 1, ParameterAttributes.None, args[i].Name); ILGenerator gen = m.GetILGenerator(); //Define the IT variable LocalRef it = locals["IT"] as LocalRef; DefineLocal(gen, it); statements.Process(this, errors, gen); statements.Emit(this, gen); //Cast the IT variable to our return type and return it if (m.ReturnType != typeof(void)) { gen.Emit(OpCodes.Ldloc, it.Local); Expression.EmitCast(gen, it.Type, m.ReturnType); } gen.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); }
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 static void Generate( TypeBuilder typeBuilder, EventMetadata eventMetadata, MethodBuilder addMethod, MethodBuilder removeMethod, MethodBuilder raiseMethod) { var @event = typeBuilder.DefineEvent( eventMetadata.Name, eventMetadata.EventAttributes, eventMetadata.EventHandlerType); if (addMethod != null) { @event.SetAddOnMethod(addMethod); } if (removeMethod != null) { @event.SetRemoveOnMethod(removeMethod); } if (raiseMethod != null) { @event.SetRaiseMethod(raiseMethod); } }
private static void EmitEmptyImplementation( MethodBuilder vM, Type returnType, ParameterInfo[] parameters ) { ILGenerator gVM = vM.GetILGenerator(); for( int i = 0; i < parameters.Length; ++i ) { // DefineParameter use 0 for the return parameter. ParameterInfo param = parameters[i]; vM.DefineParameter( i + 1, param.Attributes, param.Name ); if( param.IsOut ) { Debug.Assert( param.ParameterType.IsByRef, "'Out' is just an attribute on 'by ref' parameters (unfortunate for covariance support)." ); gVM.StoreDefaultValueForOutParameter( param ); } } if( returnType != typeof( void ) ) { if( returnType.GetTypeInfo().IsValueType ) { LocalBuilder retValue = gVM.DeclareLocal( returnType ); gVM.Emit( OpCodes.Ldloca_S, retValue.LocalIndex ); gVM.Emit( OpCodes.Initobj, returnType ); gVM.LdLoc( retValue ); } else { gVM.Emit( OpCodes.Ldnull ); } } gVM.Emit( OpCodes.Ret ); }
public PropertyEmitter(TypeBuilder owner, string name, Type propertyType, FieldBuilder propertyChangedField) { this.owner = owner; this.propertyChangedField = propertyChangedField; fieldBuilder = owner.DefineField(String.Format("<{0}>", name), propertyType, FieldAttributes.Private); getterBuilder = owner.DefineMethod(String.Format("get_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, propertyType, Type.EmptyTypes); ILGenerator getterIl = getterBuilder.GetILGenerator(); getterIl.Emit(OpCodes.Ldarg_0); getterIl.Emit(OpCodes.Ldfld, fieldBuilder); getterIl.Emit(OpCodes.Ret); setterBuilder = owner.DefineMethod(String.Format("set_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, typeof(void), new[] {propertyType}); ILGenerator setterIl = setterBuilder.GetILGenerator(); setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Ldarg_1); setterIl.Emit(OpCodes.Stfld, fieldBuilder); if (propertyChangedField != null) { setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Dup); setterIl.Emit(OpCodes.Ldfld, propertyChangedField); setterIl.Emit(OpCodes.Ldstr, name); setterIl.Emit(OpCodes.Call, proxyBase_NotifyPropertyChanged); } setterIl.Emit(OpCodes.Ret); propertyBuilder = owner.DefineProperty(name, PropertyAttributes.None, propertyType, null); propertyBuilder.SetGetMethod(getterBuilder); propertyBuilder.SetSetMethod(setterBuilder); }
private void CreateMethodBuilder() { methodBuilder = typeBuilder.DefineMethod( "DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object), typeof(object[]) }); methodBuilder.InitLocals = true; ilGenerator = methodBuilder.GetILGenerator(); }
public void CreateDynamicMethod() { #if SAVE_ASSEMBLY if (_assemblyBuilder == null) { AssemblyName assemblyName = new AssemblyName("ExpressionAssembly"); _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, "I:\\Trash"); _moduleBuilder = _assemblyBuilder.DefineDynamicModule("ExpressionModule", "ExpressionModule.module"); } string typeName = String.Format("Expression{0}", _typeCount); _typeCount++; _typeBuilder = _moduleBuilder.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public); FieldBuilder filedBuilder = _typeBuilder.DefineField("Source", typeof(string), FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal); filedBuilder.SetConstant(_source); _methodBuilder = _typeBuilder.DefineMethod("Evaluate", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object[]) }); _ilGenerator = _methodBuilder.GetILGenerator(); #else _dynamicMethod = new DynamicMethod("Expression", typeof(object), new Type[] { typeof(object[]) }, GetType().Module); _ilGenerator = _dynamicMethod.GetILGenerator(); #endif }
private void CreateMethodBuilder(Type returnType, Type[] parameterTypes) { methodBuilder = typeBuilder.DefineMethod( "DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, returnType, parameterTypes); methodBuilder.InitLocals = true; emitter = new Emitter(methodBuilder.GetILGenerator(), parameterTypes); }
private static void EmitBody(MethodBuilder mb, Body body) { foreach (var st in body.Statements) { EmitStatement(mb, st); } }
public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg) { LeftOperand.GenCode(tb, mb, cg); RigthOperand.GenCode(tb, mb, cg); cg.Emit(OpCodes.And); }
public void SetupParameters(MethodBuilder methodBuilder) { if (methodToOverride.IsGenericMethod) { Type[] genericArguments = methodToOverride.GetGenericArguments(); string[] names = genericArguments .Select(t => t.Name) .ToArray(); GenericTypeParameterBuilder[] builders = methodBuilder.DefineGenericParameters(names); for (int i = 0; i < genericArguments.Length; ++i) { builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes); var constraintTypes = genericArguments[i].GetGenericParameterConstraints(); builders[i].SetInterfaceConstraints(constraintTypes.Where(t => t.IsInterface).ToArray()); foreach (Type type in constraintTypes.Where(t => !t.IsInterface)) { builders[i].SetBaseTypeConstraint(type); } } for(int i = 0; i < genericArguments.Length; ++i) { genericMethodParameters.Add(new KeyValuePair<Type, Type>(genericArguments[i], builders[i].UnderlyingSystemType)); } } }
public static GenericTypeParameterBuilder[] CopyGenericArguments( IMethodInfo methodToCopyGenericsFrom, MethodBuilder builder, Dictionary<String, GenericTypeParameterBuilder> name2GenericType) { return CopyGenericArguments(methodToCopyGenericsFrom, name2GenericType, builder.DefineGenericParameters); }
/// <summary> /// Calls a method on this variable /// </summary> /// <param name="method">Method</param> /// <param name="parameters">Parameters sent in</param> /// <returns>Variable returned by the function (if one exists, null otherwise)</returns> public virtual VariableBase Call(System.Reflection.Emit.MethodBuilder method, object[] parameters = null) { if (method == null) { throw new ArgumentNullException("method"); } return(MethodBase.CurrentMethod.Call(this, method, parameters)); }
public CodeGen(Emit.MethodBuilder methb, MethodDeclaration methodDec, Collections.Dictionary <string, Emit.FieldBuilder> typefieldList, string _dllProbeDirectory, MethodGen _parent) { this.dllProbeDirectory = _dllProbeDirectory; this.typefieldList = typefieldList; this.parent = _parent; this.methb = methb; this.methodDec = methodDec; }
internal void Compile(MethodBuilder m) { if (Builder == null) { int ofs = (m.IsStatic ? 0 : 1); Builder = m.DefineParameter(this.Index + ofs, this.Attributes, this.Name); } }
internal MethodOnTypeBuilderInst (MethodOnTypeBuilderInst gmd, Type[] typeArguments) { this.instantiation = gmd.instantiation; this.mb = gmd.mb; this.method_arguments = new Type [typeArguments.Length]; typeArguments.CopyTo (this.method_arguments, 0); this.generic_method_definition = gmd; }
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 override void Gen(TypeBuilder program, MethodBuilder method) { AstNode left = this.child; AstNode right = left.sibling; left.Gen(program, method); right.Gen(program, method); method.GetILGenerator().EmitCall(OpCodes.Callvirt, typeof(TypeBase).GetMethod("Equal"), new Type[] { typeof(TypeBase) }); }
// .NET 4.5 and later have the documented SetMethodBody() method. static Type GetTypeNET45(TypeBuilder tb, MethodBuilder mb, IntPtr address) { byte[] code = new byte[1] { 0x2A }; int maxStack = 8; byte[] locals = GetLocalSignature(address); setMethodBodyMethodInfo.Invoke(mb, new object[5] { code, maxStack, locals, null, null }); var createdMethod = tb.CreateType().GetMethod(METHOD_NAME, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); return createdMethod.GetMethodBody().LocalVariables[0].LocalType; }
internal void BeginMethod(Type returnType, MethodBuilderInfo methodBuilderInfo, Type[] argTypes, string[] argNames, MethodAttributes methodAttributes) { #if DEBUG methodBuilderInfo.Validate(returnType, argTypes, methodAttributes); #endif _methodBuilder = methodBuilderInfo.MethodBuilder; _ilGen = _methodBuilder.GetILGenerator(); InitILGeneration(argTypes, argNames, (_methodBuilder.Attributes & MethodAttributes.Static) == MethodAttributes.Static); }
internal void DefineBuilders() { declareHelperBuilder = PureAssemblyBuilder.GlobalTypeEmitter.TypeBuilder.DefineMethod( Name.DeclareHelperName.Value, MethodAttributes.Assembly | MethodAttributes.Static, Types.Void, new Type[] { typeof(ApplicationContext) }); // sets the type builder to null, which makes functions and global constants defined globally on the module: this.globalType.TypeDesc.DefineBuilder((TypeBuilder)null); }
internal EasyMethod(AbstractEasyType maintype, string name, MethodAttributes attrs, ReturnReferenceExpression returnRef, params ArgumentReference[] arguments) { this._maintype = maintype; this._arguments = arguments; Type returnType = returnRef.Type; Type[] parameterTypes = ArgumentsUtil.InitializeAndConvert(arguments); this._builder = maintype.TypeBuilder.DefineMethod(name, attrs, returnType, parameterTypes); }
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(); }
private Emit.MethodBuilder GetEntryPoint() { Emit.MethodBuilder methodB = null; foreach (TypeGen typeGen in typeList) { methodB = typeGen.GetEntryPoint(); if (methodB == null) { continue; } return(methodB); } return(methodB); }
private static void CopyGenericMethodParameters(MethodInfo targetMethod, MethodDefinition method, Dictionary <Type, Type> genArgMapping, Func <Type, Type> typeReplacer) { if (targetMethod.IsGenericMethodDefinition) { var targetGenArgs = targetMethod.GetGenericArguments(); var items = method.DefineGenericParameters(targetGenArgs.Select(x => x.Name).ToArray()).Zip(targetGenArgs, (paramBuilder, target) => new { paramBuilder, target }) .ToList(); foreach (var arg in items) { arg.paramBuilder.SetGenericParameterAttributes(arg.target.GenericParameterAttributes); genArgMapping[arg.target] = arg.paramBuilder; } foreach (var arg in items) { IEnumerable <Type> interfaceConstraints = arg.target.GetGenericParameterConstraints().Select(typeReplacer).ToList(); if (arg.target.BaseType != null) { var baseTypeFixed = typeReplacer(arg.target.BaseType); if (!baseTypeFixed.IsInterface) { arg.paramBuilder.SetBaseTypeConstraint(baseTypeFixed); } else { //arg.paramBuilder.SetBaseTypeConstraint(typeof(object)); interfaceConstraints = interfaceConstraints.Append(baseTypeFixed); } //if (arg.target.BaseType.IsGenericParameter) //{ // interfaceConstraints = interfaceConstraints.Except(arg.target.BaseType.GetInterfaces()); //} } arg.paramBuilder.SetInterfaceConstraints(interfaceConstraints.ToArray()); } } }
public void Intercept(DynamicMember parent, System.Reflection.Emit.MethodBuilder builder, System.Reflection.Emit.ILGenerator generator, ref Label returnLabel) { var prop = parent as DynamicProperty; var hasMultipleValuesProperty = prop.DynamicTypeBuilder.DynamicMembers.OfType <DynamicProperty>().FirstOrDefault(p => p.MemberName == $"{prop.MemberName}_HasMultipleValues"); if (hasMultipleValuesProperty == null) { return; } generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldc_I4_0); generator.Emit(OpCodes.Call, hasMultipleValuesProperty.PropertySetMethod); generator.Emit(OpCodes.Nop); }
private static void GenerateInvokeMethodIl(MethodDefinition method, Type[] paramTypes, ParameterInfo[] parameters, MethodInfo proxyOnGetMethod) { var il = method.GetILGenerator(); var argsLocal = il.DeclareLocal(typeof(object[])); il.Emit(OpCodes.Ldc_I4, paramTypes.Length); il.Emit(OpCodes.Newarr, typeof(object)); il.Emit(OpCodes.Stloc, argsLocal); foreach (var param in parameters) { il.Emit(OpCodes.Ldloc, argsLocal); il.Emit(OpCodes.Ldc_I4, param.Position); il.Emit(OpCodes.Ldarg, param.Position + 1); // +1 since Ldarg0 means this if (param.ParameterType.IsValueType) { il.Emit(OpCodes.Box, param.ParameterType); } il.Emit(OpCodes.Stelem_Ref); } il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetCurrentMethod")); il.Emit(OpCodes.Castclass, typeof(MethodInfo)); //il.Emit(OpCodes.Ldstr, targetMethod.Name); il.Emit(OpCodes.Ldloc_0); il.Emit(OpCodes.Callvirt, proxyOnGetMethod); if (method.ReturnType == typeof(void)) { il.Emit(OpCodes.Pop); } else if (method.ReturnType.IsValueType) { il.Emit(OpCodes.Unbox_Any, method.ReturnType); } else if (method.ReturnType != typeof(object)) { il.Emit(OpCodes.Castclass, method.ReturnType); } il.Emit(OpCodes.Ret); }
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); }
public Emit.MethodBuilder GenerateCode(MethodDeclaration methodDec) { MethodAttributes methodAttributes = MethodAttributes.Public; if (methodDec.IsStatic) { methodAttributes = methodAttributes | MethodAttributes.Static; } //Type[] types = { typeof(string) }; //Emit.MethodBuilder methb = typeBuilder.DefineMethod(methodDec.MethodName, methodAttributes, typeof(void), types); Emit.MethodBuilder methb = typeBuilder.DefineMethod(methodDec.MethodName, methodAttributes, typeof(void), System.Type.EmptyTypes); child = new CodeGen(methb, methodDec, typefieldList, dllProbeDirectory, this); child.GenerateCode(); return(methb); }
private static void AdjustParameterTypes(ParameterInfo[] parameters, Func <Type, Type> typeReplacer, MethodDefinition method) { var fixedParams = new Type[parameters.Length]; foreach (var parameter in parameters) { var paramType = typeReplacer(parameter.ParameterType); fixedParams[parameter.Position] = paramType; method.DefineParameter(parameter.Position, parameter.Attributes, parameter.Name); } // Set fixed parameters having correct generic parameters. method.SetParameters(fixedParams); // Set fixed return type with correct generic parameter. method.SetReturnType(typeReplacer(method.ReturnType)); }
static void Main(string[] args) { string name = "hello.exe"; var asm_name = new Refl.AssemblyName(IO.Path.GetFileNameWithoutExtension(name)); //no extension for assembly name var asml = System.AppDomain.CurrentDomain.DefineDynamicAssembly(asm_name, Emit.AssemblyBuilderAccess.Save); var modl = asml.DefineDynamicModule(name); //extension is needed for module name var prog = modl.DefineType("Program"); Emit.MethodBuilder main = prog.DefineMethod("Main", Refl.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes); var generator = main.GetILGenerator(); generator.Emit(Emit.OpCodes.Ldstr, "hello~ I'm Yue"); generator.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) }));//? generator.Emit(Emit.OpCodes.Ret); prog.CreateType(); modl.CreateGlobalFunctions(); asml.SetEntryPoint(main); asml.Save(name); }
public static Type BuildPropertyObject(System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <string, Type> > obj) { string nameOfDLL = "magic.dll"; string nameOfAssembly = "magic_Assembly"; string nameOfModule = "magic_Module"; string nameOfType = "magic_Type"; System.Reflection.AssemblyName assemblyName = new System.Reflection.AssemblyName { Name = nameOfAssembly }; System.Reflection.Emit.AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave); System.Reflection.Emit.ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(nameOfModule, nameOfDLL); System.Reflection.Emit.TypeBuilder typeBuilder = moduleBuilder.DefineType(nameOfType, System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Class); foreach (var prop in obj) { string Name = prop.Key; Type DataType = prop.Value; System.Reflection.Emit.FieldBuilder field = typeBuilder.DefineField("_" + Name, DataType, System.Reflection.FieldAttributes.Private); System.Reflection.Emit.PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(Name, System.Reflection.PropertyAttributes.SpecialName, DataType, null); System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.SpecialName; System.Reflection.Emit.MethodBuilder methodBuilderGetter = typeBuilder.DefineMethod("get_" + Name, methodAttributes, DataType, new Type[] { }); System.Reflection.Emit.MethodBuilder methodBuilderSetter = typeBuilder.DefineMethod("set_" + Name, methodAttributes, typeof(void), new Type[] { DataType }); System.Reflection.Emit.ILGenerator ilGeneratorGetter = methodBuilderGetter.GetILGenerator(); ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldfld, field); ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ret); System.Reflection.Emit.ILGenerator ilGeneratorSetter = methodBuilderSetter.GetILGenerator(); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Stfld, field); ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ret); propertyBuilder.SetGetMethod(methodBuilderGetter); propertyBuilder.SetSetMethod(methodBuilderSetter); } // Yes! you must do this, it should not be needed but it is! Type dynamicType = typeBuilder.CreateType(); // Save to file assemblyBuilder.Save(nameOfDLL); return(dynamicType); }
public CodeGen(stmt stmt, string moduleName, int count) { if (IO.Path.GetFileName(moduleName) != moduleName) { throw new System.Exception("can only output into current directory!"); } stmts = stmt; Reflect.AssemblyName name = new Reflect.AssemblyName("FAJF"); //name of the assembly Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save); Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName); Emit.TypeBuilder typeBuilder = modb.DefineType("resister"); //name of the class 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>(); counting = 0; counter = count; counters = 0; // Go Compile! this.GenStmt(stmt); il.Emit(Emit.OpCodes.Ret); typeBuilder.CreateType(); modb.CreateGlobalFunctions(); asmb.SetEntryPoint(methb); asmb.Save(moduleName); // this.il.EmitWriteLine("press any key to continue"); this.symbolTable = null; this.il = null; System.Diagnostics.Process.Start(moduleName); }
public void SetRaiseMethod(MethodBuilder mdBuilder) { ArgumentNullException.ThrowIfNull(mdBuilder); RejectIfCreated(); raise_method = mdBuilder; }
public void SetSetMethod(MethodBuilder mdBuilder) { set_method = mdBuilder; }
public void SetGetMethod(MethodBuilder mdBuilder) { get_method = mdBuilder; }
public void AddOtherMethod(MethodBuilder mdBuilder) { }
public void AddOtherMethod(MethodBuilder mdBuilder) { SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Other); }
public void SetRaiseMethod(MethodBuilder mdBuilder) { SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Fire); }
public void SetRemoveOnMethod(MethodBuilder mdBuilder) { SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.RemoveOn); }
public void SetAddOnMethod(MethodBuilder mdBuilder) { ArgumentNullException.ThrowIfNull(mdBuilder); RejectIfCreated(); add_method = mdBuilder; }
public void SetAddOnMethod(MethodBuilder mdBuilder) { SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.AddOn); }
public void Intercept(DynamicMember parent, System.Reflection.Emit.MethodBuilder builder, System.Reflection.Emit.ILGenerator generator, ref Label returnLabel) { var prop = parent as DynamicProperty; var originalReturn = returnLabel; bool valueType = false; var compareMethod = prop.MemberType.GetMethod("op_Equality", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public); if (compareMethod == null) { compareMethod = typeof(object).GetMethod("Equals", BindingFlags.Static | BindingFlags.Public); valueType = true; } generator.Emit(OpCodes.Nop); generator.Emit(OpCodes.Ldarg_1); if (valueType) { generator.Emit(OpCodes.Box, prop.MemberType); } if (!prop.IsOverride) { generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldfld, prop.BackingField); } else { generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Call, prop.PropertyGetMethod); } if (valueType) { generator.Emit(OpCodes.Box, prop.MemberType); } var endlabel = generator.DefineLabel(); generator.Emit(OpCodes.Call, compareMethod); generator.Emit(OpCodes.Ldc_I4_0); generator.Emit(OpCodes.Ceq); generator.Emit(OpCodes.Brfalse_S, returnLabel); generator.Emit(OpCodes.Br_S, endlabel); returnLabel = generator.DefineLabel(); generator.MarkLabel(returnLabel); var raiseMethod = prop.DynamicTypeBuilder.DynamicMembers .OfType <RaisePropertyChangedMethod>() .Select(p => p.Method) .OfType <MethodInfo>() .FirstOrDefault(); if (raiseMethod == null) { raiseMethod = prop.DynamicTypeBuilder.BaseType.GetMethod("OnPropertyChanged", BindingFlags.NonPublic | BindingFlags.Instance); } if (raiseMethod == null) { #if (SILVERLIGHT) throw new MissingMemberException(string.Format("Missing Member {1} on type {0}", builder.DeclaringType.Name, "PropertyChanged")); #else throw new MissingMemberException(builder.DeclaringType.Name, "PropertyChanged"); #endif } generator.Emit(OpCodes.Nop); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldstr, prop.MemberName); generator.Emit(OpCodes.Callvirt, raiseMethod); generator.Emit(OpCodes.Br_S, originalReturn); generator.MarkLabel(endlabel); }
private int GetMemberRefToken(MethodBase methodInfo, Type[] optionalParameterTypes) { if (optionalParameterTypes != null && (methodInfo.CallingConvention & CallingConventions.VarArgs) == (CallingConventions)0) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAVarArgCallingConvention")); } RuntimeMethodInfo runtimeMethodInfo = methodInfo as RuntimeMethodInfo; DynamicMethod dynamicMethod = methodInfo as DynamicMethod; if (runtimeMethodInfo == null && dynamicMethod == null) { throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "methodInfo"); } ParameterInfo[] parametersNoCopy = methodInfo.GetParametersNoCopy(); Type[] array; if (parametersNoCopy != null && parametersNoCopy.Length != 0) { array = new Type[parametersNoCopy.Length]; for (int i = 0; i < parametersNoCopy.Length; i++) { array[i] = parametersNoCopy[i].ParameterType; } } else { array = null; } SignatureHelper memberRefSignature = this.GetMemberRefSignature(methodInfo.CallingConvention, MethodBuilder.GetMethodBaseReturnType(methodInfo), array, optionalParameterTypes); if (runtimeMethodInfo != null) { return(this.GetTokenForVarArgMethod(runtimeMethodInfo, memberRefSignature)); } return(this.GetTokenForVarArgMethod(dynamicMethod, memberRefSignature)); }