public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder) { const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; ParameterInfo[] parameters = method.GetParameters(); MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes, CallingConventions.HasThis, method.ReturnType, parameters.Select(param => param.ParameterType).ToArray()); System.Type[] typeArgs = method.GetGenericArguments(); if (typeArgs.Length > 0) { var typeNames = new List<string>(); for (int index = 0; index < typeArgs.Length; index++) { typeNames.Add(string.Format("T{0}", index)); } methodBuilder.DefineGenericParameters(typeNames.ToArray()); } ILGenerator IL = methodBuilder.GetILGenerator(); Debug.Assert(MethodBodyEmitter != null); MethodBodyEmitter.EmitMethodBody(IL, method, field); }
public static void Clear() { _dynamicAssembly = null; _moduleBuilder = null; _typeBuilder = null; _accessorList.Clear(); }
// Constructs a PropertyBuilder. // internal PropertyBuilder( ModuleBuilder mod, // the module containing this PropertyBuilder String name, // property name SignatureHelper sig, // property signature descriptor info PropertyAttributes attr, // property attribute such as DefaultProperty, Bindable, DisplayBind, etc Type returnType, // return type of the property. PropertyToken prToken, // the metadata token for this property TypeBuilder containingType) // the containing type { if (name == null) throw new ArgumentNullException("name"); if (name.Length == 0) throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); if (name[0] == '\0') throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "name"); Contract.EndContractBlock(); m_name = name; m_moduleBuilder = mod; m_signature = sig; m_attributes = attr; m_returnType = returnType; m_prToken = prToken; m_tkProperty = prToken.Token; m_containingType = containingType; }
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 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 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); }
#pragma warning restore 169, 414 internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnModReq, Type[] returnModOpt, Type[] parameterTypes, Type[][] paramModReq, Type[][] paramModOpt) { this.name = name; this.attrs = attributes; this.call_conv = callingConvention; this.rtype = returnType; this.returnModReq = returnModReq; this.returnModOpt = returnModOpt; this.paramModReq = paramModReq; this.paramModOpt = paramModOpt; // The MSDN docs does not specify this, but the MS MethodBuilder // appends a HasThis flag if the method is not static if ((attributes & MethodAttributes.Static) == 0) this.call_conv |= CallingConventions.HasThis; if (parameterTypes != null) { for (int i = 0; i < parameterTypes.Length; ++i) if (parameterTypes [i] == null) throw new ArgumentException ("Elements of the parameterTypes array cannot be null", "parameterTypes"); this.parameters = new Type [parameterTypes.Length]; System.Array.Copy (parameterTypes, this.parameters, parameterTypes.Length); } type = tb; table_idx = get_next_table_index (this, 0x06, true); ((ModuleBuilder)tb.Module).RegisterToken (this, GetToken ().Token); }
private void ImplementInterfaceProperties(Type interfaceOfTypeToCreate, System.Reflection.Emit.TypeBuilder typeBuilder) { typeBuilder.AddInterfaceImplementation(interfaceOfTypeToCreate); foreach (var implementedInterfaceType in interfaceOfTypeToCreate.GetInterfaces()) { ImplementInterfaceProperties(implementedInterfaceType, typeBuilder); } foreach (var pi in interfaceOfTypeToCreate.GetProperties()) { var backingFieldBuilder = typeBuilder.DefineField($"{interfaceOfTypeToCreate.Name}._{ToCamelCase(pi.Name)}", pi.PropertyType, FieldAttributes.Private); var accessorAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Virtual | MethodAttributes.HideBySig; var mbGetAccessor = typeBuilder.DefineMethod($"get_{pi.Name}", accessorAttributes, pi.PropertyType, Type.EmptyTypes); var mbGetIL = mbGetAccessor.GetILGenerator(); mbGetIL.Emit(OpCodes.Ldarg_0); mbGetIL.Emit(OpCodes.Ldfld, backingFieldBuilder); mbGetIL.Emit(OpCodes.Ret); var mbSetAccessor = typeBuilder.DefineMethod($"set_{pi.Name}", accessorAttributes, null, new[] { pi.PropertyType }); var mbSetIL = mbSetAccessor.GetILGenerator(); mbSetIL.Emit(OpCodes.Ldarg_0); mbSetIL.Emit(OpCodes.Ldarg_1); mbSetIL.Emit(OpCodes.Stfld, backingFieldBuilder); mbSetIL.Emit(OpCodes.Ret); var propertyBuilder = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, pi.PropertyType, null); propertyBuilder.SetGetMethod(mbGetAccessor); propertyBuilder.SetSetMethod(mbSetAccessor); } }
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)); } }
#pragma warning restore 169, 414 internal EventBuilder (TypeBuilder tb, string eventName, EventAttributes eventAttrs, Type eventType) { name = eventName; attrs = eventAttrs; type = eventType; typeb = tb; table_idx = get_next_table_index (this, 0x14, true); }
public MethodGen(Emit.TypeBuilder typeBuilder, Collections.Dictionary <string, Emit.FieldBuilder> typefieldList, string dllProbeDirectory, TypeGen parent) { this.typeBuilder = typeBuilder; this.dllProbeDirectory = dllProbeDirectory; this.typefieldList = typefieldList; this.parent = parent; }
/// <summary> /// Initializes a new instance of the <see cref="TypeBuilderHelper"/> class /// with the specified parameters. /// </summary> /// <param name="assemblyBuilder">Associated <see cref="AssemblyBuilderHelper"/>.</param> /// <param name="typeBuilder">A <see cref="TypeBuilder"/></param> public TypeBuilderHelper(AssemblyBuilderHelper assemblyBuilder, System.Reflection.Emit.TypeBuilder typeBuilder) { Assembly = assemblyBuilder ?? throw new ArgumentNullException(nameof(assemblyBuilder)); TypeBuilder = typeBuilder ?? throw new ArgumentNullException(nameof(typeBuilder)); TypeBuilder.SetCustomAttribute(Assembly.ReflectionExtensionsAttribute); }
private FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties) { FieldInfo[] array = new FieldBuilder[properties.Length]; for (int i = 0; i < properties.Length; i++) { DynamicProperty dynamicProperty = properties[i]; FieldBuilder fieldBuilder = tb.DefineField("_" + dynamicProperty.Name, dynamicProperty.Type, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty(dynamicProperty.Name, PropertyAttributes.HasDefault, dynamicProperty.Type, null); MethodBuilder methodBuilder = tb.DefineMethod("get_" + dynamicProperty.Name, MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName, dynamicProperty.Type, Type.EmptyTypes); ILGenerator iLGenerator = methodBuilder.GetILGenerator(); iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Ldfld, fieldBuilder); iLGenerator.Emit(OpCodes.Ret); MethodBuilder methodBuilder2 = tb.DefineMethod("set_" + dynamicProperty.Name, MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName, null, new Type[] { dynamicProperty.Type }); ILGenerator iLGenerator2 = methodBuilder2.GetILGenerator(); iLGenerator2.Emit(OpCodes.Ldarg_0); iLGenerator2.Emit(OpCodes.Ldarg_1); iLGenerator2.Emit(OpCodes.Stfld, fieldBuilder); iLGenerator2.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(methodBuilder); propertyBuilder.SetSetMethod(methodBuilder2); array[i] = fieldBuilder; } return array; }
private static void ImplementInterfaceMethod(TypeBuilder newType, MethodInfo interfaceMethod) { ParameterInfo[] parameters = interfaceMethod.GetParameters(); Type[] parameterTypes = new Type[parameters.Length]; for (int idx = 0; idx < parameters.Length; idx++) parameterTypes[idx] = parameters[idx].ParameterType; MethodBuilder newMethod = newType.DefineMethod( interfaceMethod.DeclaringType.Name + "." + interfaceMethod.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, interfaceMethod.ReturnType, parameterTypes ); MethodInfo baseMethod = newType.BaseType.GetMethod(interfaceMethod.Name, parameterTypes); for (int i = 0; i < parameters.Length; i++) newMethod.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name); ILGenerator ilGen = newMethod.GetILGenerator(); for (int i = 0; i <= parameterTypes.Length; i++) ilGen.Emit(OpCodes.Ldarg_S, (byte)i); ilGen.Emit(OpCodes.Call, baseMethod); ilGen.Emit(OpCodes.Ret); newType.DefineMethodOverride(newMethod, interfaceMethod); }
private static FieldInfo[] GenerateProperties(TypeBuilder tb, IDictionary<string, Type> properties) { const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; FieldInfo[] fields = new FieldBuilder[properties.Count]; int i = 0; foreach (string key in properties.Keys) { string name = key; Type type = properties[key]; FieldBuilder fb = tb.DefineField("_" + key, type, FieldAttributes.Public); PropertyBuilder pb = tb.DefineProperty(key, PropertyAttributes.HasDefault, type, null); MethodBuilder mbGet = tb.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes); ILGenerator genGet = mbGet.GetILGenerator(8); genGet.Emit(OpCodes.Ldarg_0); genGet.Emit(OpCodes.Ldfld, fb); genGet.Emit(OpCodes.Ret); pb.SetGetMethod(mbGet); MethodBuilder mbSet = tb.DefineMethod("set_" + name, getSetAttr, null, new Type[] { type }); ILGenerator genSet = mbSet.GetILGenerator(8); genSet.Emit(OpCodes.Ldarg_0); genSet.Emit(OpCodes.Ldarg_1); genSet.Emit(OpCodes.Stfld, fb); genSet.Emit(OpCodes.Ret); pb.SetSetMethod(mbSet); fields[i] = fb; } return fields; }
public AbstractProxyBuilder(ModuleBuilder moduleBuilder, string className, Type interfaceType, Type innerType) { Verify.ArgumentNotNull(moduleBuilder, "moduleBuilder"); Verify.ArgumentNotNull(className, "className"); Verify.ArgumentNotNull(interfaceType, "interfaceType"); Verify.ArgumentNotNull(innerType, "innerType"); if (!interfaceType.IsInterface) { throw new ArgumentException("must be an interface type", "interfaceType"); } _errorMessages = new List<string>(); _moduleBuilder = moduleBuilder; _className = className; _interfaceType = interfaceType; _innerType = innerType; _typeBuilder = _moduleBuilder.DefineType( _className, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, typeof(object), new Type[] {_interfaceType}); _innerFieldBuilder = _typeBuilder.DefineField("inner", _innerType, FieldAttributes.Private); }
public InterfaceImplementation( TypeBuilder typeBuilder, Type @interface, FieldBuilder proxyInterceptionPipelineField, bool explicitImplementation) : this(typeBuilder, @interface, proxyInterceptionPipelineField, explicitImplementation, null) { }
public void ImplementProxy(TypeBuilder typeBuilder) { typeBuilder.AddInterfaceImplementation(typeof (IProxy)); InterceptorField = typeBuilder .DefineField("__interceptor", typeof (Proxy.DynamicProxy.IInterceptor), FieldAttributes.Private); var getterMethod = typeBuilder .DefineMethod("get_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (Proxy.DynamicProxy.IInterceptor), new System.Type[0]); getterMethod.SetImplementationFlags(MethodImplAttributes.IL); var il = getterMethod.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, InterceptorField); il.Emit(OpCodes.Ret); var setterMethod = typeBuilder .DefineMethod("set_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (void), new[] {typeof (Proxy.DynamicProxy.IInterceptor)}); setterMethod.SetImplementationFlags(MethodImplAttributes.IL); il = setterMethod.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Stfld, InterceptorField); il.Emit(OpCodes.Ret); var originalSetter = typeof (IProxy).GetMethod("set_Interceptor"); var originalGetter = typeof (IProxy).GetMethod("get_Interceptor"); typeBuilder.DefineMethodOverride(setterMethod, originalSetter); typeBuilder.DefineMethodOverride(getterMethod, originalGetter); }
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); }
/// <summary> /// Creates a <see cref="MethodBuilder"/> and implements a default wrapper. /// </summary> /// <param name="owner">The type that will own this method.</param> /// <param name="interfaceType">Type of interface implemented by the <paramref name="owner"/>.</param> /// <param name="overrideMethod">Method to override.</param> /// <param name="fieldBuilders">Fields specified by the <see paramref="owner"/>.</param> /// <returns>MethodBuilder with an already implemented wrapper.</returns> public MethodBuilder GenerateInvocation(TypeBuilder owner, Type interfaceType, MethodInfo overrideMethod, IEnumerable<FieldBuilder> fieldBuilders) { var result = owner.DefineMethod ( overrideMethod.Name, MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot, overrideMethod.ReturnType, overrideMethod.GetParameters().OrderBy(p => p.Position).Select(t => t.ParameterType).ToArray() ); result.SetImplementationFlags(MethodImplAttributes.AggressiveInlining); var generator = result.GetILGenerator(); var fieldName = LibraryInterfaceMapper.GetFieldNameForMethodInfo(overrideMethod); var field = fieldBuilders.First(f => f.Name == fieldName); var parameters = overrideMethod.GetParameters(); OnInvokeBegin(owner, interfaceType, generator, overrideMethod); generator.Emit(OpCodes.Ldarg_0); // this generator.Emit(OpCodes.Ldfld, field); // MethodNameProc _glMethodName. Initialized by constructor. foreach (var item in parameters.Where(p => !p.IsRetval).Select((p, i) => new { Type = p, Index = i })) { generator.Emit(OpCodes.Ldarg, item.Index + 1); } generator.EmitCall(OpCodes.Callvirt, field.FieldType.GetMethod("Invoke"), null); OnInvokeEnd(owner, interfaceType, generator, overrideMethod); generator.Emit(OpCodes.Ret); owner.DefineMethodOverride(result, overrideMethod); return result; }
private static void BuildStringProperty(TypeBuilder typeBuilder, string property) { //implement properties from interface FieldBuilder fieldBuilder = typeBuilder.DefineField(property.ToLower(), typeof(string), FieldAttributes.Private); PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(property, PropertyAttributes.HasDefault, typeof(string), null); const MethodAttributes getSetAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual; //define 'get' accessor MethodBuilder getPropertyBuilder = typeBuilder.DefineMethod("get_" + property, getSetAttributes, typeof(string), Type.EmptyTypes); //create IL code for get ILGenerator genusGetIL = getPropertyBuilder.GetILGenerator(); genusGetIL.Emit(OpCodes.Ldarg_0); genusGetIL.Emit(OpCodes.Ldfld, fieldBuilder); genusGetIL.Emit(OpCodes.Ret); //define 'set' accessor MethodBuilder setPropertyBuilder = typeBuilder.DefineMethod("set_" + property, getSetAttributes, null, new[] { typeof(String) }); //create IL code for set ILGenerator genusSetIL = setPropertyBuilder.GetILGenerator(); genusSetIL.Emit(OpCodes.Ldarg_0); genusSetIL.Emit(OpCodes.Ldarg_1); genusSetIL.Emit(OpCodes.Stfld, fieldBuilder); genusSetIL.Emit(OpCodes.Ret); //map get and set to property 'methods' propertyBuilder.SetGetMethod(getPropertyBuilder); propertyBuilder.SetSetMethod(setPropertyBuilder); }
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; }
private static FieldBuilder CréeAttributs(TypeBuilder constructeurDeType, DataColumn colonne) { FieldBuilder champBldr = null; PropertyBuilder constructeurPropriété; #region Création de l'attribut champBldr = constructeurDeType.DefineField(colonne.ColumnName.ToLower(), colonne.DataType, FieldAttributes.Private); #endregion #region Création de la Propriété associée constructeurPropriété = constructeurDeType.DefineProperty(colonne.ColumnName, System.Reflection.PropertyAttributes.HasDefault, colonne.DataType, null); // Choix des attributs MethodAttributes attrGetSet = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; #region Définition du "getter". MethodBuilder constructeurGet = constructeurDeType.DefineMethod("get_" + colonne.ColumnName, attrGetSet, colonne.DataType, Type.EmptyTypes); ILGenerator champGetIL = constructeurGet.GetILGenerator(); champGetIL.Emit(OpCodes.Ldarg_0); champGetIL.Emit(OpCodes.Ldfld, champBldr); champGetIL.Emit(OpCodes.Ret); #endregion #region Définition du "setter". MethodBuilder constructeurSet = constructeurDeType.DefineMethod("set_" + colonne.ColumnName, attrGetSet, null, new Type[] { colonne.DataType }); ILGenerator champSetIL = constructeurSet.GetILGenerator(); champSetIL.Emit(OpCodes.Ldarg_0); champSetIL.Emit(OpCodes.Ldarg_1); champSetIL.Emit(OpCodes.Stfld, champBldr); champSetIL.Emit(OpCodes.Ret); #endregion #region Association des accesseurs à la propriété constructeurPropriété.SetGetMethod(constructeurGet); constructeurPropriété.SetSetMethod(constructeurSet); #endregion #endregion return champBldr; }
public void ImplementProxy(TypeBuilder typeBuilder) { // Implement the IProxy interface typeBuilder.AddInterfaceImplementation(typeof (IProxy)); field = typeBuilder.DefineField("__interceptor", typeof (IInterceptor), FieldAttributes.Private); // Implement the getter MethodBuilder getterMethod = typeBuilder.DefineMethod("get_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof(IInterceptor), new System.Type[0]); getterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL); ILGenerator IL = getterMethod.GetILGenerator(); // This is equivalent to: // get { return __interceptor; IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ldfld, field); IL.Emit(OpCodes.Ret); // Implement the setter MethodBuilder setterMethod = typeBuilder.DefineMethod("set_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (void), new[] {typeof (IInterceptor)}); setterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL); IL = setterMethod.GetILGenerator(); IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ldarg_1); IL.Emit(OpCodes.Stfld, field); IL.Emit(OpCodes.Ret); MethodInfo originalSetter = typeof (IProxy).GetMethod("set_Interceptor"); MethodInfo originalGetter = typeof (IProxy).GetMethod("get_Interceptor"); typeBuilder.DefineMethodOverride(setterMethod, originalSetter); typeBuilder.DefineMethodOverride(getterMethod, originalGetter); }
public static MethodBuilder GenerateStaticSerializerStub(TypeBuilder tb, Type type) { var mb = tb.DefineMethod("Serialize", MethodAttributes.Public | MethodAttributes.Static, null, new Type[] { typeof(Stream), type }); mb.DefineParameter(1, ParameterAttributes.None, "stream"); mb.DefineParameter(2, ParameterAttributes.None, "value"); return mb; }
private void DefineClassVaribale(Emit.TypeBuilder typeBuilder, TypeDeclaration _type) { fieldList = new Dictionary <string, Emit.FieldBuilder>(); Emit.FieldBuilder classVariable; foreach (KeyValuePair <string, Type> para in _type.instanceVariable) { classVariable = typeBuilder.DefineField(para.Key, para.Value, FieldAttributes.Private); fieldList.Add(para.Key, classVariable); } foreach (KeyValuePair <string, Type> para in _type.classVariable) { classVariable = typeBuilder.DefineField(para.Key, para.Value, FieldAttributes.Private | FieldAttributes.Static); fieldList.Add(para.Key, classVariable); } //mthdIL.Emit(OpCodes.Ldarg_0); //mthdIL.Emit(OpCodes.Ldarg_0); //mthdIL.Emit(OpCodes.Ldfld, balanceAmtBldr); //mthdIL.Emit(OpCodes.Ldarg_2); //mthdIL.Emit(OpCodes.Add); }
public TypeGen(TypeDeclaration typeDec, Emit.ModuleBuilder modb, string dllProbeDirectory, AssemblyGen parent) { methodList = new List <System.Reflection.Emit.MethodBuilder>(); typeBuilder = modb.DefineType(typeDec.TypeName, TypeAttributes.Public); this.parent = parent; this.typeDec = typeDec; }
/// <summary> /// Creates a new instance of the method builder. /// </summary> /// <param name="typeBuilder">The type builder to use.</param> /// <param name="aopProxyGenerator"> /// The <see cref="IAopProxyTypeGenerator"/> implementation to use. /// </param> /// <param name="targetMethods"> /// /// </param> /// <param name="index">index of the introduction to delegate call to</param> public IntroductionProxyMethodBuilder( TypeBuilder typeBuilder, IAopProxyTypeGenerator aopProxyGenerator, IDictionary targetMethods, int index) : base(typeBuilder, aopProxyGenerator, true, targetMethods) { this.index = index; }
public static void DefineInterface(TypeBuilder typeBuilder, Type interfaceType, Type implementType, Action<ILGenerator, MethodInfo, MethodInfo> ilGenerator) { var proxyMethodBuilder = new ProxyMethodBuilder(typeBuilder); InterfaceMapping mapping = implementType.GetInterfaceMap(interfaceType); for (int i = 0; i < mapping.InterfaceMethods.Length; i++) mapping.TargetMethods[i] = proxyMethodBuilder.DefineMethod(mapping.InterfaceMethods[i], il => ilGenerator(il, mapping.InterfaceMethods[i], mapping.TargetMethods[i])); foreach (PropertyInfo propertyInfo in interfaceType.GetProperties()) { MethodBuilder getMethodBuilder = null; MethodInfo getMethodInfo = propertyInfo.GetGetMethod(); if (getMethodInfo != null) getMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, getMethodInfo); MethodBuilder setMethodBuilder = null; MethodInfo setMethodInfo = propertyInfo.GetSetMethod(); if (setMethodInfo != null) setMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, setMethodInfo); ProxyBuilderHelper.DefineProperty(typeBuilder, propertyInfo, getMethodBuilder, setMethodBuilder); } foreach (EventInfo eventInfo in interfaceType.GetEvents()) { var addMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, eventInfo.GetAddMethod()); var removeMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, eventInfo.GetRemoveMethod()); ProxyBuilderHelper.DefineEvent(typeBuilder, eventInfo, addMethodBuilder, removeMethodBuilder); } }
public Type CreateType(TypeBuilder typeBuilder) { Type proxyType = typeBuilder.CreateType(); ((AssemblyBuilder)typeBuilder.Assembly).Save("ProxyAssembly.dll"); AssemblyAssert.IsValidAssembly("ProxyAssembly.dll"); return proxyType; }
/// <summary> /// 动态创建类的属性 /// </summary> /// <param name="tb">承载该属性的类型</param> /// <param name="properityName">属性名,首字母应大写</param> /// <param name="properityType">属性数据类型</param> public static FieldBuilder createProperty(TypeBuilder tb, string propertyName, Type propertyType) { //定义属性对应的私有字段 FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); //定义属性 PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); //定义与属性相关的get方法 MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); ILGenerator getIL = getPropMthdBldr.GetILGenerator();//获取il 生成器 getIL.Emit(OpCodes.Ldarg_0); getIL.Emit(OpCodes.Ldfld, fieldBuilder); getIL.Emit(OpCodes.Ret); //定义与属性相关的set方法 MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { propertyType }); ILGenerator setIL = setPropMthdBldr.GetILGenerator(); /* * OpCodes.Ldarg_0:Ldarg是加载方法参数的意思。这里Ldarg_0事实上是对当前对象的引用即this。 * 因为类的实例方法(非静态方法)在调用时,this 是会作为第一个参数传入的。 */ setIL.Emit(OpCodes.Ldarg_0); setIL.Emit(OpCodes.Ldarg_1);//OpCodes.Ldarg_1:加载参数列表的第一个参数了。 setIL.Emit(OpCodes.Stfld, fieldBuilder);//OpCodes.Stfld:用新值替换在对象引用或指针的字段中存储的值。 setIL.Emit(OpCodes.Ret); //把get/set方法和属性联系起来 propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); return fieldBuilder; }
private static void CreateProperty(string name, TypeBuilder tb, MethodInfo bgcmi, MethodInfo bscmi) { // define getter var gmb = tb.DefineMethod("get_" + name, MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public, typeof(string), null); var g = gmb.GetILGenerator(); g.Emit(OpCodes.Ldarg_0); g.Emit(OpCodes.Ldstr, name); g.Emit(OpCodes.Call, bgcmi); g.Emit(OpCodes.Ret); // define setter var smb = tb.DefineMethod("set_" + name, MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public, null, new Type[] { typeof(string) }); g = smb.GetILGenerator(); g.Emit(OpCodes.Ldarg_0); g.Emit(OpCodes.Ldstr, name); g.Emit(OpCodes.Ldarg_1); g.Emit(OpCodes.Call, bscmi); g.Emit(OpCodes.Ret); // define properties var pb = tb.DefineProperty(name, PropertyAttributes.None, typeof(string), null); pb.SetGetMethod(gmb); pb.SetSetMethod(smb); }
public static EventBrokerResolvedType ResolveType(IMemberMap<EventInfo> memberMap, TypeBuilder typeBuilder) { Type[] @params = null; Type delegateType = null; Type[] delegateParameters = null; var @event = memberMap.ContractMember; var declaringType = memberMap.ContractType; var invokeMethod = @event.GetInvokeMethod(); var invokeReturnType = invokeMethod.ReturnType; var eventBrokerResolvedType = new EventBrokerResolvedType(@event) { DecalringType = declaringType }; if (invokeMethod.GetDelegateParams(out @params, out delegateParameters)) { delegateType = @params.GetDelegateType(true); eventBrokerResolvedType.EventInterceptionContractArgs = @event.ToEventArgumentContract(@params); eventBrokerResolvedType.EventInterceptionArgs = declaringType.MakeGenericFunctionAspectArgsEvent(@params); eventBrokerResolvedType.EventBrokerBaseClassType = declaringType.MakeGenericEventBrokerBaseClassFunctionBinding(@params); eventBrokerResolvedType.EventBrokerInvokeDelegateType = typeof(Func<,>).MakeGenericType(new[] { eventBrokerResolvedType.EventInterceptionContractArgs, invokeReturnType }); } else { delegateType = delegateParameters.GetDelegateType(false); eventBrokerResolvedType.EventInterceptionContractArgs = @event.ToEventArgumentContract(delegateParameters); eventBrokerResolvedType.EventInterceptionArgs = declaringType.MakeGenericActionAspectArgsEvent(delegateParameters); eventBrokerResolvedType.EventBrokerBaseClassType = declaringType.MakeGenericEventBrokerBaseClassActionType(delegateParameters); eventBrokerResolvedType.EventBrokerInvokeDelegateType = typeof(Action<>).MakeGenericType(new[] { eventBrokerResolvedType.EventInterceptionContractArgs }); } eventBrokerResolvedType.Arguments = delegateParameters; eventBrokerResolvedType.EventBrokerFieldType = typeof(IEventBroker<>).MakeGenericType(delegateType); return eventBrokerResolvedType; }
private static void CreateProperty(System.Reflection.Emit.TypeBuilder tb, string propertyName, Type propertyType) { FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); ILGenerator getIl = getPropMthdBldr.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Ldfld, fieldBuilder); getIl.Emit(OpCodes.Ret); MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] { propertyType }); ILGenerator setIl = setPropMthdBldr.GetILGenerator(); Label modifyProperty = setIl.DefineLabel(); Label exitSet = setIl.DefineLabel(); setIl.MarkLabel(modifyProperty); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Stfld, fieldBuilder); setIl.Emit(OpCodes.Nop); setIl.MarkLabel(exitSet); setIl.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); }
private FieldInfo[] GenerateProperties( TypeBuilder tb , DynamicProperty[] properties ) { FieldInfo[] fields = new FieldBuilder[properties.Length]; for ( int i = 0 ; i < properties.Length ; i++ ) { DynamicProperty dp = properties[i]; FieldBuilder fb = tb.DefineField( "_" + dp.Name , dp.Type , FieldAttributes.Private ); PropertyBuilder pb = tb.DefineProperty( dp.Name , PropertyAttributes.HasDefault , dp.Type , null ); MethodBuilder mbGet = tb.DefineMethod( "get_" + dp.Name , MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig , dp.Type , Type.EmptyTypes ); ILGenerator genGet = mbGet.GetILGenerator(); genGet.Emit( OpCodes.Ldarg_0 ); genGet.Emit( OpCodes.Ldfld , fb ); genGet.Emit( OpCodes.Ret ); MethodBuilder mbSet = tb.DefineMethod( "set_" + dp.Name , MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig , null , new[] { dp.Type } ); ILGenerator genSet = mbSet.GetILGenerator(); genSet.Emit( OpCodes.Ldarg_0 ); genSet.Emit( OpCodes.Ldarg_1 ); genSet.Emit( OpCodes.Stfld , fb ); genSet.Emit( OpCodes.Ret ); pb.SetGetMethod( mbGet ); pb.SetSetMethod( mbSet ); fields[i] = fb; } return fields; }
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 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); }
static void DefineDelegateFieldAndOverride(TypeBuilder tb, int numArgs) { Type fieldType = FuncTypeHelpers.GetFFuncType(numArgs); string fieldName = "_fn" + numArgs; FieldBuilder fb = tb.DefineField(fieldName, fieldType, FieldAttributes.Public); MethodBuilder mb = tb.DefineMethod("invoke", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual, typeof(object), CreateObjectTypeArray(numArgs)); ILGenerator gen = mb.GetILGenerator(); Label eqLabel = gen.DefineLabel(); // this._fni == null ? gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, fb); gen.Emit(OpCodes.Ldnull); gen.Emit(OpCodes.Beq, eqLabel); //Not equal to Null, invoke it. gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, fb); for (int i = 0; i < numArgs; i++) gen.Emit(OpCodes.Ldarg, i+1); gen.Emit(OpCodes.Call,fb.FieldType.GetMethod("Invoke")); gen.Emit(OpCodes.Ret); gen.MarkLabel(eqLabel); // Equal to Null: throw WrongArityException gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, Method_AFn_WrongArityException); gen.Emit(OpCodes.Throw); }
public ProxyClassBuildingContext(Type interfaceType, string path, TypeBuilder builder, ProxyClassFieldCache fields) { Fields = fields; Builder = builder; Path = path; InterfaceType = interfaceType; }
protected override void Implement(DynamicTypeBuilder config, System.Reflection.Emit.TypeBuilder typeBuilder, ILGenerator il) { var evt = config.DynamicMembers.OfType <DynamicEvent>().Where(p => p.MemberName == "PropertyChanged").FirstOrDefault(); if (evt == null) { #if NETSTANDARD1_6 throw new MissingMemberException($"Missiong member PropertyChanged on type {typeBuilder.Name}."); #else throw new MissingMemberException(typeBuilder.Name, "PropertyChanged"); #endif } var endLabel = il.DefineLabel(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, evt.BackingField); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Ceq); il.Emit(OpCodes.Brtrue_S, endLabel); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, evt.BackingField); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Newobj, typeof(PropertyChangedEventArgs).GetConstructor(new[] { typeof(string) })); il.Emit(OpCodes.Callvirt, typeof(PropertyChangedEventHandler).GetMethod("Invoke")); il.MarkLabel(endLabel); il.Emit(OpCodes.Ret); }
protected override void Implement(DynamicTypeBuilder config, System.Reflection.Emit.TypeBuilder typeBuilder, System.Reflection.Emit.ILGenerator il) { var convention = config.Conventions.OfType <TransactionProxyConvention>().First(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, convention.TargetsField.Field); il.Emit(OpCodes.Ret); }
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 TypeBuilder( string TypeName, TypeAttributes TypeAttribute) { myAsmBuilder = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run); myModBuilder = myAsmBuilder.DefineDynamicModule(myAsmName.Name); myTypeBuilder = myModBuilder.DefineType(TypeName, TypeAttribute); }
protected override void Implement(DynamicTypeBuilder config, System.Reflection.Emit.TypeBuilder typeBuilder, System.Reflection.Emit.ILGenerator il) { var convention = config.Conventions.OfType <TransactionProxyConvention>().First(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.EmitCall(OpCodes.Callvirt, convention.GetValueEntiresTypedMethod.Method, null); il.Emit(OpCodes.Ret); }
public TypeBuilder Inicialize(string typeName, TypeAttributes typeAttributes, Type[] implementedInterfaces) { if (string.IsNullOrWhiteSpace(typeName)) { throw new ArgumentException("Parameter cannot be empty!", nameof(typeName)); } _typeBuilder = _moduleBuilder.DefineType(typeName, typeAttributes, null, implementedInterfaces); return(this); }
private void CompileClassDecl(Node ActiveNode) { Emit.TypeBuilder _TypeBuilder = TypeTable[ActiveNode.Nodes[1].Value]; CurrentType = _TypeBuilder; OpenBlockVariables(); CreateCode(ActiveNode.Nodes[3]); CloseBlockVariables(); CreateCode(ActiveNode.Nodes[4]); CreatedTypeTable[ActiveNode.Nodes[1].Value] = _TypeBuilder.CreateType(); }
///// <summary> ///// Creates a delegate that does type conversion and calls the method represented by this ///// object. ///// </summary> ///// <param name="argumentTypes"> The types of the arguments that will be passed to the delegate. </param> ///// <returns> A delegate that does type conversion and calls the method represented by this ///// object. </returns> //internal BinderDelegate CreateBinder<T>() //{ // // Delegate types have an Invoke method containing the relevant parameters. // MethodInfo adapterInvokeMethod = typeof(T).GetMethod("Invoke", BindingFlags.Public | BindingFlags.Instance); // if (adapterInvokeMethod == null) // throw new ArgumentException("The type parameter T must be delegate type.", "T"); // // Get the argument types. // Type[] argumentTypes = adapterInvokeMethod.GetParameters().Select(p => p.ParameterType).ToArray(); // // Create the binder. // return this.callBinder.CreateBinder(argumentTypes); //} #if !XBOX /// <summary> /// Compile the ClrFunction's Binder methods to IL /// </summary> /// <param name="typeBuilder">The TypeBuilder to attach the compiled Binder methods to</param> public void CompileBinder(System.Reflection.Emit.TypeBuilder typeBuilder) { if (this.callBinder != null) { this.callBinder.Compile(this.Engine, typeBuilder); } if (this.constructBinder != null) { this.constructBinder.Compile(this.Engine, typeBuilder); } }
public override void GenerateCode(ModuleBuilder moduleBuilder, System.Reflection.Emit.TypeBuilder program, ILGenerator generator) { var END = generator.DefineLabel(); var T = generator.DefineLabel(); /* true */ var F = generator.DefineLabel(); /* false */ //-------------------------------------------------- // [Stack Status] // 1. l_operand // (...) //-------------------------------------------------- this.LeftOperandNode.GenerateCode(moduleBuilder, program, generator); //-------------------------------------------------- // [Stack Status] // (...) //-------------------------------------------------- generator.Emit(OpCodes.Brfalse, F); //-------------------------------------------------- // [Stack Status] // 1. r_operand // (...) //-------------------------------------------------- this.RightOperandNode.GenerateCode(moduleBuilder, program, generator); //-------------------------------------------------- // [Stack Status] // (...) //-------------------------------------------------- generator.Emit(OpCodes.Brfalse, F); generator.MarkLabel(T); //-------------------------------------------------- // [Stack Status] // 1. 1 { true } // (...) //-------------------------------------------------- generator.Emit(OpCodes.Ldc_I4, 1); generator.Emit(OpCodes.Br, END); generator.MarkLabel(F); //-------------------------------------------------- // [Stack Status] // 1. 0 { false } // (...) //-------------------------------------------------- generator.Emit(OpCodes.Ldc_I4, 0); generator.MarkLabel(END); }
public ILCodeGen(string name) { this.symtab = Symboltable.Instance; this.program_name = name; this.asname = new Reflect.AssemblyName(name); this.asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(asname, Emit.AssemblyBuilderAccess.Save); this.modb = asmb.DefineDynamicModule(name); this.typeBuilder = modb.DefineType("fpc2IL"); this.mbuilderTable = new Hashtable(); this.fbuilderTable = new Hashtable(); this.lbuilderTable = new Hashtable(); }
protected override void Implement(DynamicTypeBuilder config, System.Reflection.Emit.TypeBuilder typeBuilder, System.Reflection.Emit.ILGenerator il) { var convention = config.Conventions.OfType <TransactionProxyConvention>().First(); var method = typeof(ITransactionProxy <>).MakeGenericType(convention.ItemType).GetMethod("SetTargets"); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Castclass, typeof(IEnumerable <>).MakeGenericType(convention.ItemType)); il.EmitCall(OpCodes.Callvirt, method, null); il.Emit(OpCodes.Ret); }
public override void CreateDeclarations(System.Reflection.Emit.TypeBuilder typeBuilder) { this.BaseMethod = typeBuilder.BaseType.GetMethods().OfType <MethodInfo>() .Where(p => p.Name == this.MemberName) .FirstOrDefault(p => p.ReturnType == this.MemberType && p.GetParameters().Length == this.ArgumentTypes.Count && p.GetParameters().Select((x, i) => new { Index = i, Type = x.ParameterType }).All(x => this.ArgumentTypes[x.Index] == x.Type)); if (BaseMethod != null && !BaseMethod.IsVirtual) { throw new MemberCreationException(this.MemberName, "The method has to be declared virtual on the base class."); } else if (BaseMethod != null) { IsOverride = true; } MethodAttributes methodAttributes = MethodAttributes.Public; if (IsProtected) { methodAttributes = MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.SpecialName | MethodAttributes.HideBySig; } else { methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.SpecialName | MethodAttributes.HideBySig; } var implementationAttributes = MethodAttributes.Private | MethodAttributes.SpecialName | MethodAttributes.HideBySig; Method = typeBuilder.DefineMethod(this.MemberName, methodAttributes); ImplementationMethod = typeBuilder.DefineMethod(string.Format("{0}_Implementation", this.MemberName), implementationAttributes); var genericParameters = GetGenericArguments().ToList(); if (genericParameters.Any()) { this._genericParameters.AddRange(Method.DefineGenericParameters(genericParameters.ToArray())); this._genericImplementationParameters.AddRange(ImplementationMethod.DefineGenericParameters(genericParameters.ToArray())); } this.Method.SetReturnType(TypeLookup(this.MemberType)); this.Method.SetParameters(TypeLookup(this.ArgumentTypes).ToArray()); this.ImplementationMethod.SetReturnType(ImplementationTypeLookup(this.MemberType)); this.ImplementationMethod.SetParameters(ImplementationTypeLookup(this.ArgumentTypes).ToArray()); if (IsOverride) { typeBuilder.DefineMethodOverride(this.Method, this.BaseMethod); } }
private static void CreateProperty(System.Reflection.Emit.TypeBuilder tb, string propertyName, Type propertyType, bool required) { if (propertyType.IsByRef) { //avoids an exception in code below when by ref parameters are used propertyType = propertyType.GetElementType(); } FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes); ILGenerator getIl = getPropMthdBldr.GetILGenerator(); getIl.Emit(OpCodes.Ldarg_0); getIl.Emit(OpCodes.Ldfld, fieldBuilder); getIl.Emit(OpCodes.Ret); MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] { propertyType }); ILGenerator setIl = setPropMthdBldr.GetILGenerator(); Label modifyProperty = setIl.DefineLabel(); Label exitSet = setIl.DefineLabel(); setIl.MarkLabel(modifyProperty); setIl.Emit(OpCodes.Ldarg_0); setIl.Emit(OpCodes.Ldarg_1); setIl.Emit(OpCodes.Stfld, fieldBuilder); setIl.Emit(OpCodes.Nop); setIl.MarkLabel(exitSet); setIl.Emit(OpCodes.Ret); Type[] ctorParams = { }; ConstructorInfo contructorInfo = typeof(DataMemberAttribute).GetConstructor(ctorParams); CustomAttributeBuilder customAttrBuilder = new CustomAttributeBuilder(contructorInfo, new object[] { }); //TODO: set IsRequired here ?? propertyBuilder.SetCustomAttribute(customAttrBuilder); propertyBuilder.SetGetMethod(getPropMthdBldr); propertyBuilder.SetSetMethod(setPropMthdBldr); }
/// <summary> /// AddConstructor /// </summary> /// <param name="typeBuilder"></param> /// <param name="backingFields"></param> private static void CreateConstructor(System.Reflection.Emit.TypeBuilder typeBuilder, IReadOnlyList <dynamic> backingFields) { #region Constructor //-------------------------------------------------------------------- // Constructor: (Default) // <code> // .custom instance void [Newtonsoft.Json]Newtonsoft.Json.JsonConverterAttribute::.ctor(class [mscorlib]System.Type) = { type(<NameSpace>.PayloadComplexTypeConverter) } // .method public hidebysig specialname rtspecialname instance void .ctor() cil managed // { // } // </code> // Attribute: // [JsonConverter(typeof(PayloadComplexTypeConverter))] // Ctor attributes /* Uncomment if needing similar functionality for nested duck types */ // Attribute: // [JsonConverterAttribute()] //var jsonConverterAttr = typeof(JsonConverterAttribute).GetConstructor(new [] { typeof(Type) }); //if (jsonConverterAttr != null) { // // ReSharper disable once InconsistentNaming // var jsonConverterCABuilder = new CustomAttributeBuilder( // jsonConverterAttr, // new object[] { typeof(PayloadComplexTypeConverter) } // ); // typeBuilder.SetCustomAttribute(jsonConverterCABuilder); //} var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new[] { typeof(string), typeof(string), typeof(Dictionary <string, Type>) }); var ctorIl = constructorBuilder.GetILGenerator(); // Now, we'll load the current instance ref in arg 0, along // with the value of parameter "x" stored in arg X, into stfld. for (var x = 0; x < backingFields.Count; x++) { ctorIl.Emit(OpCodes.Ldarg_0); ctorIl.Emit(OpCodes.Ldarg_S, x + 1); ctorIl.Emit(OpCodes.Stfld, backingFields[x]); } // Our work complete, we return. ctorIl.Emit(OpCodes.Ret); //-------------------------------------------------------------------- #endregion Constructor }
private void AddGetter(System.Reflection.Emit.TypeBuilder typeBuilder, FieldBuilder fieldBuilder, PropertyBuilder propertyBuilder) { MethodBuilder propertyGetter = typeBuilder.DefineMethod("get_" + _propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, _propertyType, Type.EmptyTypes); var ilGenerator = propertyGetter.GetILGenerator(); ilGenerator.Emit(OpCodes.Ldarg_0); ilGenerator.Emit(OpCodes.Ldfld, fieldBuilder); ilGenerator.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(propertyGetter); }
protected override void Implement(DynamicTypeBuilder config, System.Reflection.Emit.TypeBuilder typeBuilder, System.Reflection.Emit.ILGenerator il) { var convention = config.Conventions.OfType <TransactionProxyConvention>().First(); var listCtor = convention.TargetsField.MemberType.GetConstructor(new[] { typeof(IEnumerable <>).MakeGenericType(convention.ItemType) }); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Newobj, listCtor); il.Emit(OpCodes.Stfld, convention.TargetsField.Field); il.Emit(OpCodes.Ldarg_0); il.EmitCall(OpCodes.Callvirt, typeof(ICommitable).GetMethod("Rollback"), null); il.Emit(OpCodes.Ret); }
/// <summary>把lcpi参数里的属性加入到myTypeBuilder中。注意:该操作会将其它成员清除掉,其功能有待完善。</summary> /// <param name="typeBuilder">类型构造器的实例。</param> /// <param name="cpis">里面包含属性列表的信息。</param> private static void AddPropertyToTypeBuilder(System.Reflection.Emit.TypeBuilder typeBuilder, List <CustPropertyInfo> cpis) { PropertyBuilder custNamePropBldr; MethodBuilder custNameGetPropMthdBldr; MethodBuilder custNameSetPropMthdBldr; MethodAttributes getSetAttr; ILGenerator custNameGetIL; ILGenerator custNameSetIL; // 属性Set和Get方法要一个专门的属性。这里设置为Public。 getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; // 添加属性到myTypeBuilder。 foreach (CustPropertyInfo cpi in cpis) { // 定义字段。 FieldBuilder customerNameBldr = typeBuilder.DefineField(cpi.FieldName, Type.GetType(cpi.Type), FieldAttributes.Private); customerNameBldr.SetConstant("11111111"); // 定义属性。 最后一个参数为null,因为属性没有参数。 custNamePropBldr = typeBuilder.DefineProperty(cpi.PropertyName, PropertyAttributes.HasDefault, Type.GetType(cpi.Type), null); custNamePropBldr.SetConstant("111111111"); // 定义Get方法。 custNameGetPropMthdBldr = typeBuilder.DefineMethod(cpi.GetPropertyMethodName, getSetAttr, Type.GetType(cpi.Type), Type.EmptyTypes); custNameGetIL = custNameGetPropMthdBldr.GetILGenerator(); try { custNameGetIL.Emit(OpCodes.Ldarg_0); //custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr); custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr); custNameGetIL.Emit(OpCodes.Ret); } catch { } //定义Set方法。 custNameSetPropMthdBldr = typeBuilder.DefineMethod(cpi.SetPropertyMethodName, getSetAttr, null, new Type[] { Type.GetType(cpi.Type) }); custNameSetIL = custNameSetPropMthdBldr.GetILGenerator(); custNameSetIL.Emit(OpCodes.Ldarg_0); custNameSetIL.Emit(OpCodes.Ldarg_1); custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr); custNameSetIL.Emit(OpCodes.Ret); //custNamePropBldr.SetConstant("ceshi"); //把创建的两个方法(Get,Set)加入到PropertyBuilder中。 custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr); custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr); } }
private void AddSetter(System.Reflection.Emit.TypeBuilder typeBuilder, FieldBuilder fieldBuilder, PropertyBuilder propertyBuilder) { MethodBuilder propertySetter = typeBuilder.DefineMethod("set_" + _propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { _propertyType }); var propertySetterIl = propertySetter.GetILGenerator(); propertySetterIl.Emit(OpCodes.Ldarg_0); propertySetterIl.Emit(OpCodes.Ldarg_1); propertySetterIl.Emit(OpCodes.Stfld, fieldBuilder); propertySetterIl.Emit(OpCodes.Ret); propertyBuilder.SetSetMethod(propertySetter); }
public static Type CompileResultType(List <FieldInfo> listOfFields, string typeName) { System.Reflection.Emit.TypeBuilder tb = GetTypeBuilder(typeName); ConstructorBuilder constructor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); // NOTE: assuming your list contains Field objects with fields FieldName(string) and FieldType(Type) foreach (var field in listOfFields) { CreateProperty(tb, field.Name, field.Type); } Type objectType = tb.CreateType(); return(objectType); }
/// <summary> /// Create property with explicit implementation of getter and setter, with no method defined. /// </summary> private PropertyDefinition AddProperty(TypeDefinition declaringType, string name, TypeReference propertyType, string explicitPrefix, PropertyInfo overridedProp) { var proxyPropDef = declaringType.DefineProperty(explicitPrefix + name, PropertyAttributes.None | PropertyAttributes.SpecialName, propertyType, null); const MethodAttributes methodAttributes = MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.SpecialName; var overridedGetMethod = overridedProp.GetGetMethod(); if (overridedGetMethod != null) { var proxyPropGetter = declaringType.DefineMethod( $"{explicitPrefix}get_{name}", methodAttributes, propertyType, Type.EmptyTypes); declaringType.DefineMethodOverride(proxyPropGetter, overridedGetMethod); proxyPropDef.SetGetMethod(proxyPropGetter); } var overridedSetMethod = overridedProp.GetSetMethod(); if (overridedSetMethod != null) { var proxyPropSetter = declaringType.DefineMethod( $"{explicitPrefix}set_{name}", methodAttributes, null, new[] { propertyType }); proxyPropSetter.DefineParameter(0, ParameterAttributes.None, "value"); declaringType.DefineMethodOverride(proxyPropSetter, overridedSetMethod); proxyPropDef.SetSetMethod(proxyPropSetter); } return(proxyPropDef); }
/// <summary> /// Initializes a new instance of the <see cref="TypeBuilderHelper"/> class /// with the specified parameters. /// </summary> /// <param name="assemblyBuilder">Associated <see cref="AssemblyBuilderHelper"/>.</param> /// <param name="typeBuilder">A <see cref="TypeBuilder"/></param> public TypeBuilderHelper(AssemblyBuilderHelper assemblyBuilder, System.Reflection.Emit.TypeBuilder typeBuilder) { if (assemblyBuilder == null) { throw new ArgumentNullException("assemblyBuilder"); } if (typeBuilder == null) { throw new ArgumentNullException("typeBuilder"); } _assembly = assemblyBuilder; _typeBuilder = typeBuilder; _typeBuilder.SetCustomAttribute(_assembly.BLToolkitAttribute); }