// 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; }
/// <summary> /// Initializes a new instance of the <see cref="SetAccessorFactory"/> class. /// </summary> /// <param name="allowCodeGeneration">if set to <c>true</c> [allow code generation].</param> public SetAccessorFactory(bool allowCodeGeneration) { if (allowCodeGeneration) { // Detect runtime environment and create the appropriate factory if (Environment.Version.Major >= 2) { _createPropertySetAccessor = new CreatePropertySetAccessor(CreateDynamicPropertySetAccessor); _createFieldSetAccessor = new CreateFieldSetAccessor(CreateDynamicFieldSetAccessor); } else { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = "iBATIS.FastSetAccessor" + HashCodeProvider.GetIdentityHashCode(this); // Create a new assembly with one module _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); _moduleBuilder = _assemblyBuilder.DefineDynamicModule(assemblyName.Name + ".dll"); _createPropertySetAccessor = new CreatePropertySetAccessor(CreatePropertyAccessor); _createFieldSetAccessor = new CreateFieldSetAccessor(CreateFieldAccessor); } } else { _createPropertySetAccessor = new CreatePropertySetAccessor(CreateReflectionPropertySetAccessor); _createFieldSetAccessor = new CreateFieldSetAccessor(CreateReflectionFieldSetAccessor); } }
internal static TypeBuilder Build(ModuleBuilder proxyModule, Type proxyType, AssemblyDebugging debugAssembly) { TypeBuilder proxyTypeBuilder = null; string proxyName = proxyType.Namespace + "." + proxyType.Name + Proxy.ProxyExtension; var iProxyType = typeof(IProxy<>).MakeGenericType(proxyType); proxyTypeBuilder = proxyModule.DefineType(proxyName, TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public, proxyType, new Type[] { iProxyType }); using (TypeDebugging debugType = debugAssembly.GetTypeDebugging(proxyTypeBuilder)) { var fields = ProxyFieldBuilder.Build( proxyTypeBuilder, proxyType); ProxyConstructorBuilder.Build(proxyTypeBuilder, proxyType, fields[ProxyFieldBuilder.WrappedObjectField], fields[ProxyFieldBuilder.InvokeHandlerField], debugType); ProxyMethodBuilder.Build(proxyTypeBuilder, proxyType, iProxyType, fields[ProxyFieldBuilder.WrappedObjectField], fields[ProxyFieldBuilder.InvokeHandlerField], debugType); } return proxyTypeBuilder; }
internal SymbolMethod(ModuleBuilder mod, MethodToken token, Type arrayClass, String methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes) { // This is a kind of MethodInfo to represent methods for array type of unbaked type // Another way to look at this class is as a glorified MethodToken wrapper. At the time of this comment // this class is only constructed inside ModuleBuilder.GetArrayMethod and the only interesting thing // passed into it is this MethodToken. The MethodToken was forged using a TypeSpec for an Array type and // the name of the method on Array. // As none of the methods on Array have CustomModifiers their is no need to pass those around in here. m_mdMethod = token; // The ParameterTypes are also a bit interesting in that they may be unbaked TypeBuilders. m_returnType = returnType; if (parameterTypes != null) { m_parameterTypes = new Type[parameterTypes.Length]; Array.Copy(parameterTypes, 0, m_parameterTypes, 0, parameterTypes.Length); } else { m_parameterTypes = EmptyArray<Type>.Value; } m_module = mod; m_containingType = arrayClass; m_name = methodName; m_callingConvention = callingConvention; m_signature = SignatureHelper.GetMethodSigHelper( mod, callingConvention, returnType, null, null, parameterTypes, null, null); }
public Scope(ModuleBuilder moduleBuilder) { _vars = new Dictionary<string, ParameterExpression>(); _types = new Dictionary<string, Type>(); _func = new Dictionary<string, LambdaExpression>(); _moduleBuilder = moduleBuilder; }
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); }
private TypeBuilder GetTypeBuilder(Type sourceType, ModuleBuilder moduleBuilder) { return moduleBuilder.DefineType( SnapshotNameGenerator.Generate(sourceType), TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed, SnapshotBaseType); }
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 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)); } }
static PropertyAccessor() { AssemblyName asmName = new AssemblyName(); asmName.Name = "$Assembly.Hprose.IO.PropertyAccessor"; asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run); modBuilder = asmBuilder.DefineDynamicModule("$Module.PropertyAccessor"); }
static MethodInvoker(){ MethodInvoker.invokerFor = new SimpleHashtable(64); AssemblyName name = new AssemblyName(); name.Name = "JScript MethodInvoker Assembly"; MethodInvoker.assembly = Thread.GetDomain().DefineDynamicAssembly(name, AssemblyBuilderAccess.Run); MethodInvoker.module = MethodInvoker.assembly.DefineDynamicModule("JScript MethodInvoker Module"); }
public DataTypeBuilder(string name) { var assemblyName = new AssemblyName {Name = name}; _moduleBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run).DefineDynamicModule(name); }
internal ModuleBuilderData(ModuleBuilder module, string strModuleName, string strFileName, int tkFile) { this.m_globalTypeBuilder = new TypeBuilder(module); this.m_module = module; this.m_tkFile = tkFile; this.InitNames(strModuleName, strFileName); }
internal static Type makeRecord(String name,Type basetype) { if(assembly == null) { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = "RecordAssembly"; assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,AssemblyBuilderAccess.Run); module = assembly.DefineDynamicModule("RecordModule"); } TypeBuilder tb = module.DefineType(name,TypeAttributes.Class|TypeAttributes.Public,basetype); Type[] paramTypes = Type.EmptyTypes; ConstructorBuilder cb = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, paramTypes); ILGenerator constructorIL = cb.GetILGenerator(); constructorIL.Emit(OpCodes.Ldarg_0); ConstructorInfo superConstructor = basetype.GetConstructor(Type.EmptyTypes); constructorIL.Emit(OpCodes.Call, superConstructor); constructorIL.Emit(OpCodes.Ret); Type t = tb.CreateType(); //Import.AddType(t); //must do in lisp return t; }
// Главная функция кодогенератора. Получает на вход синтаксическое дерево, обходит его и в хое его обхода с // помощью библиотеки System.Reflection строит исполняемый файл на MSIL, который потом можно запускать вне компилятора (однако, на компьютере должна быть установлена .Net Framwork) // Путь к файлу задаётся в интерфейсе компилятора public bool Proceed(Node Tree, RichTextBox RTB, string FileName) { _Tree = Tree; _RTB = RTB; InitFileName(FileName); try { Reflect.AssemblyName Name = new Reflect.AssemblyName(FileName); AsmBuilder = System.AppDomain.CurrentDomain.DefineDynamicAssembly(Name, Emit.AssemblyBuilderAccess.Save); ModBuilder = AsmBuilder.DefineDynamicModule(FileName); TypeTable = new Collections.Dictionary <string, Emit.TypeBuilder>(); CreatedTypeTable = new Collections.Dictionary <string, System.Type>(); SymbolTable = new Collections.List <Collections.Dictionary <string, Emit.LocalBuilder> >(); BeforeCompile(Tree); CreateCode(Tree); AsmBuilder.Save(FileName); this.SymbolTable = null; this.AssemblerGenerator = null; this.TypeTable = null; File.Move(FileName, FileName + ".exe"); File.Delete(FileName); return(true); } catch (System.Exception Exc) { _RTB.Text = Exc.Message; return(false); } }
public AssemblyEmitter( string assemblyName, bool canSave ) { m_AssemblyName = assemblyName; m_AppDomain = AppDomain.CurrentDomain; m_AssemblyBuilder = m_AppDomain.DefineDynamicAssembly( new AssemblyName( assemblyName ), canSave ? AssemblyBuilderAccess.RunAndSave : AssemblyBuilderAccess.Run ); if ( canSave ) { m_ModuleBuilder = m_AssemblyBuilder.DefineDynamicModule( assemblyName, String.Format( "{0}.dll", assemblyName.ToLower() ), false ); } else { m_ModuleBuilder = m_AssemblyBuilder.DefineDynamicModule( assemblyName, false ); } }
public MethodInfo GetInvokeMethod(string methodName, Type returnType, Type[] types) { string entryName = methodName; if (assemblyBuilder == null) { AssemblyName assemblyName = new AssemblyName(AssemblyName); assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); moduleBuilder = assemblyBuilder.DefineDynamicModule(AssemblyName); } var defineType = moduleBuilder.DefineType(GetDefineTypeName(methodName)); var methodBuilder = defineType.DefinePInvokeMethod(methodName, dllName, entryName, MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.PinvokeImpl, CallingConventions.Standard, returnType, types, CallingConvention, CharSet); if ((returnType != null) && (returnType != typeof(void))) { methodBuilder.SetImplementationFlags(MethodImplAttributes.PreserveSig | methodBuilder.GetMethodImplementationFlags()); } var type = defineType.CreateType(); var method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.Static); return method; }
static XmlILModule() { AssemblyName asmName; AssemblyBuilder asmBldr; CreateModulePermissionSet = new PermissionSet(PermissionState.None); // CreateDelegate demands MemberAccess permission CreateModulePermissionSet.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)); // DynamicMethod constructor demands ControlEvidence permissions. // Emitting symbols in DefineDynamicModule (to allow to debug the stylesheet) requires UnmanagedCode permission. CreateModulePermissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.UnmanagedCode)); AssemblyId = 0; // 1. LRE assembly only needs to execute // 2. No temp files need be created // 3. Never allow assembly to Assert permissions asmName = CreateAssemblyName(); asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run); try { CreateModulePermissionSet.Assert(); // Add custom attribute to assembly marking it as security transparent so that Assert will not be allowed // and link demands will be converted to full demands. asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Transparent, new object[] {})); // Store LREModule once. If multiple threads are doing this, then some threads might get different // modules. This is OK, since it's not mandatory to share, just preferable. LREModule = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", false); } finally { CodeAccessPermission.RevertAssert(); } }
public GenContext(string assyName, string directory, CompilerMode mode) { AssemblyName aname = new AssemblyName(assyName); _assyBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(aname, AssemblyBuilderAccess.RunAndSave,directory); _moduleBldr = _assyBldr.DefineDynamicModule(aname.Name, aname.Name + ".dll", true); _mode = mode; }
static FieldAccessor(){ FieldAccessor.accessorFor = new SimpleHashtable(32); AssemblyName name = new AssemblyName(); name.Name = "JScript FieldAccessor Assembly"; FieldAccessor.assembly = Thread.GetDomain().DefineDynamicAssembly(name, AssemblyBuilderAccess.Run); FieldAccessor.module = FieldAccessor.assembly.DefineDynamicModule("JScript FieldAccessor Module"); }
private TypeBuilder EmitOwnerMappingType(IPropertyMappingProvider map, ModuleBuilder defineDynamicModule, string ownerTypeName) { var owner = defineDynamicModule.DefineType( ownerTypeName, TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract, null, new[] { typeof(IRdfListOwner) }).CreateType(); var ownerMapType = typeof(ListOwnerMap<>).MakeGenericType(new[] { owner }); var mapBuilderHelper = defineDynamicModule.DefineType(ownerTypeName + "Map", TypeAttributes.Public, ownerMapType); var propertyBuilder = mapBuilderHelper.DefineProperty("ListPredicate", PropertyAttributes.None, typeof(Uri), null); var getMethod = mapBuilderHelper.DefineMethod( "get_ListPredicate", MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName, typeof(Uri), Type.EmptyTypes); propertyBuilder.SetGetMethod(getMethod); var ilGenerator = getMethod.GetILGenerator(); ilGenerator.Emit(OpCodes.Nop); ilGenerator.Emit(OpCodes.Ldstr, map.GetTerm(_ontologyProvider).ToString()); ilGenerator.Emit(OpCodes.Newobj, typeof(Uri).GetConstructor(new[] { typeof(string) })); ilGenerator.Emit(OpCodes.Ret); return mapBuilderHelper; }
public NavigatorProxyBuilder(ModuleBuilder moduleBuilder, string className, Type interfaceType, Type innerType) : base(moduleBuilder, className, interfaceType, innerType) { _navigateValues = new List<string>(); _innerNavigateMethod = FindInnerNavigateMethod(innerType); if (_innerNavigateMethod == null) { AddErrorMessage("Cannot find method with signature 'void Navigate(string)' in type {0}", innerType); } _innerCanNavigateMethod = FindInnerCanNavigateMethod(innerType); if (_innerCanNavigateMethod == null) { AddErrorMessage("Cannot find method with signature 'bool CanNavigate(string)' in type {0}", innerType); } _outerNavigateEnumMethod = FindOuterNavigateEnumMethod(interfaceType); if (_outerNavigateEnumMethod != null) { _navigateValueEnumType = _outerNavigateEnumMethod.GetParameters()[0].ParameterType; _outerCanNavigateEnumMethod = FindOuterCanNavigateEnumMethod(interfaceType, _navigateValueEnumType); _navigateValues.AddRange(Enum.GetNames(_navigateValueEnumType)); } FindEvents(); _outerNavigateMethods = FindOuterNavigateMethods(); _outerCanNavigateProperties = FindOuterCanNavigateProperties(); }
public static void Clear() { _dynamicAssembly = null; _moduleBuilder = null; _typeBuilder = null; _accessorList.Clear(); }
static NativeCall() { // The static constructor is responsible for generating the // assembly and the methods that implement the IJW thunks. // // To do this, we actually use reflection on the INativeCall // interface (defined below) and generate the required thunk // code based on the method signatures. AssemblyName aname = new AssemblyName(); aname.Name = "e__NativeCall_Assembly"; AssemblyBuilderAccess aa = AssemblyBuilderAccess.Run; aBuilder = Thread.GetDomain().DefineDynamicAssembly(aname, aa); mBuilder = aBuilder.DefineDynamicModule("e__NativeCall_Module"); TypeAttributes ta = TypeAttributes.Public; TypeBuilder tBuilder = mBuilder.DefineType("e__NativeCall", ta); Type iType = typeof(INativeCall); tBuilder.AddInterfaceImplementation(iType); // Use reflection to loop over the INativeCall interface methods, // calling GenerateThunk to create a managed thunk for each one. foreach (MethodInfo method in iType.GetMethods()) { GenerateThunk(tBuilder, method); } Type theType = tBuilder.CreateType(); Impl = (INativeCall)Activator.CreateInstance(theType); }
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; }
static DynamicAssemblyManager() { #if !SILVERLIGHT assemblyName = new AssemblyName("NLiteDynamicAssembly"); assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.RunAndSave ); moduleBuilder = assemblyBuilder.DefineDynamicModule( assemblyName.Name, assemblyName.Name + ".dll", true); Module = assemblyBuilder.GetModules().FirstOrDefault(); #else assemblyName = new AssemblyName("EmitMapperAssembly.SL"); assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run ); moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, true); #endif }
static Type CreateTypeFromInterface(ModuleBuilder builder, Type typeToProxy) { string typeName = typeToProxy.Namespace + ProxyNamespaceSuffix + "." + typeToProxy.Name; TypeBuilder typeBuilder = builder.DefineType(typeName, TypeAttributes.Serializable | TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed, typeof(object), new[] {typeToProxy}); typeBuilder.DefineDefaultConstructor(MethodAttributes.Public); typeToProxy.GetAllProperties().Each(x => { FieldBuilder fieldBuilder = typeBuilder.DefineField("field_" + x.Name, x.PropertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(x.Name, x.Attributes | PropertyAttributes.HasDefault, x.PropertyType, null); MethodBuilder getMethod = GetGetMethodBuilder(x, typeBuilder, fieldBuilder); MethodBuilder setMethod = GetSetMethodBuilder(x, typeBuilder, fieldBuilder); propertyBuilder.SetGetMethod(getMethod); propertyBuilder.SetSetMethod(setMethod); }); return typeBuilder.CreateType(); }
/// <summary> /// Initializes a new instance of the <see cref="SerializerEmitter"/> class for enum. /// </summary> /// <param name="context">A <see cref="SerializationContext"/>.</param> /// <param name="host">The host <see cref="ModuleBuilder"/>.</param> /// <param name="specification">The specification of the serializer.</param> /// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param> public SerializerEmitter( SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable ) : this( host, specification, typeof( EnumMessagePackSerializer<> ).MakeGenericType( specification.TargetType ), isDebuggable ) { Tracer.Emit.TraceEvent( Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName ); this._defaultEnumSerializationMethod = context.EnumSerializationOptions.SerializationMethod; }
private void CreateCallee() { AssemblyName myAssemblyName = new AssemblyName(); myAssemblyName.Name = "EnumAssembly"; _myAssemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run); _myModuleBuilder = TestLibrary.Utilities.GetModuleBuilder(_myAssemblyBuilder, "EnumModule.mod"); }
public Type Compile(IMetadataSchema schema, ModuleBuilder module, string @namespace, string typeName) { if (schema == null) { throw new ArgumentNullException(nameof(schema)); } if (schema.Definitions == null) { throw new ArgumentException("There is no definition is schema.", nameof(schema)); } if (module == null) { throw new ArgumentNullException(nameof(module)); } if (@namespace == null) { throw new ArgumentNullException(nameof(@namespace)); } if (string.IsNullOrWhiteSpace(@namespace)) { throw new ArgumentException("namespace cannot be white space.", nameof(@namespace)); } if (typeName == null) { throw new ArgumentNullException(nameof(typeName)); } if (string.IsNullOrWhiteSpace(typeName)) { throw new ArgumentException("typeName cannot be white space.", nameof(typeName)); } ValidateProperties(); return CompileCore(schema, module, @namespace, typeName); }
static RuntimeTypeProvider() { ModuleBuilder = Thread .GetDomain() .DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run) .DefineDynamicModule(AssemblyName.Name); }
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; }
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 static RowViewModelBase Create(ModuleBuilder mb, SpreadsheetViewModel viewModel, int rowNumber, int columns) { if (RowType == null) RowType = CreateType(mb, columns); return (RowViewModelBase)Activator.CreateInstance(RowType, viewModel, rowNumber); }
private static System.Reflection.Emit.ModuleBuilder GetDynamicModule() { if (DynamicAssembly == null) { DynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("DynamicAssembly"), AssemblyBuilderAccess.Run); ModuleBuilder = DynamicAssembly.DefineDynamicModule("MainModule"); } return(ModuleBuilder); }
public WrappedPropertyProxyBuilder(ModuleDefinition module, TypeReference proxyBaseTypeDef, TypeReference propertyWrapperType, bool isPublic = true, string typeNameFormat = "Fast{0}Proxy", string proxyNamespace = null) : base(module, typeNameFormat, proxyBaseTypeDef, isPublic, proxyNamespace: proxyNamespace) { this.propertyWrapperType = propertyWrapperType; }
internal ReflectionEmitModuleInfo(ScriptEngine engine) { Engine = engine; // Create a dynamic assembly and module. AssemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly( new AssemblyName("Nitro Dynamic Assembly"), AssemblyBuilderAccess.Run); // Create a dynamic module. ModuleBuilder = AssemblyBuilder.DefineDynamicModule("Module", ScriptEngine.EnableDebugging); }
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(); }
public ProxyBuilder( ModuleDefinition module, string proxyNameFormat, TypeReference proxyBaseTypeDef, bool isPublic, Action <PropertyInfo, PropertyDefinition, TypeReference, TypeReference> onGeneratePropertyMethodsFunc = null, string proxyNamespace = null) { this.proxyNamespace = proxyNamespace ?? module.Assembly.GetName().Name; Module = module; this.proxyBaseTypeDef = proxyBaseTypeDef; this.onGeneratePropertyMethodsFunc = onGeneratePropertyMethodsFunc; this.proxyNameFormat = proxyNameFormat; this.isPublic = isPublic; }
private void inicializar(string nombreCodigoFuente, string nombrePrograma) { if (TablaDireccionesSimbolos.Count > 0) { throw new System.Exception("ERROR-0002: Tabla de direcciones de variables ha sido inicializada previamente"); } String rutaEjecutable = IO.Path.GetDirectoryName(nombrePrograma); //Describo el identificador unico del ensamblado que se esta generando nombre = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(nombrePrograma)); //Creo la representacion basica del ensamblado creado de forma dinamica (assembly) if (rutaEjecutable.Length > 0) { asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave, rutaEjecutable); } else { asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave); } Console.WriteLine("Common Runtime usado para generar el ejecutable del programa: " + asmb.ImageRuntimeVersion); Console.WriteLine("Se esta ejecutando el compilador bajo el CLR version {0}", Environment.Version); //Defino un nuevo modulo de .net de forma dinamica modb = asmb.DefineDynamicModule(IO.Path.GetFileName(nombrePrograma), false); //Creo una nueva clase en el Il Generator stream typeBuilder = modb.DefineType("pseudoGenerado"); //Debido a que los programas en este tiny solo cuentan con un unico metodo principal (Main) de forma estructurada //como un truco defino el metodo Main en un objeto por defecto para ejecutar todas las acciones //expresadas por el lenguaje alli. //formato: NOMBRE -> Main TIPO-> Static RETORNA-> void PARAMETROS-> vacios methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.HideBySig | Reflect.MethodAttributes.Static | Reflect.MethodAttributes.Public, typeof(void), System.Type.EmptyTypes); //Inicializo/Creo el generador/stream de codigo IL con el metodo donde generare el codigo actualmente this.il = methb.GetILGenerator(); //Para iniciar el programa Emito una primera instruccion vacia (no hace nada) il.Emit(Emit.OpCodes.Nop); }
/// <summary> /// Build a new provider /// </summary> /// <param name="assemblyName">Name of the assembly to build.</param> public SigilFunctionProvider(string assemblyName = null) { AlreadyBuildedMethods = new Dictionary <Type, IResponse>(); if (string.IsNullOrEmpty(assemblyName)) { return; } this.assemblyName = new AssemblyName(assemblyName); #if RUN_ONLY var attributes = System.Reflection.Emit.AssemblyBuilderAccess.Run; #else var attributes = System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave; #endif assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(this.assemblyName, attributes, Path.GetTempPath()); moduleBuilder = assemblyBuilder.DefineDynamicModule($"{assemblyName}.dll"); typeBuilder = moduleBuilder.DefineType($"{this.assemblyName.Name}.Handler", TypeAttributes.Public); }
public AssemblyGen(TypeDeclaration methodDec, string moduleName, string dllProbeDirectory) { if (IO.Path.GetFileName(moduleName) != moduleName) { throw new System.Exception("can only output into current directory!"); } this.dllProbeDirectory = dllProbeDirectory; typeList = new List <TypeGen>(); 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); GenerateType(methodDec, modb, dllProbeDirectory); modb.CreateGlobalFunctions(); asmb.SetEntryPoint(GetEntryPoint()); asmb.Save(moduleName); }
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); }
internal RefEmit.ModuleBuilder GetOrCreateDynamicModule() { if (dynamicModule == null) { DebuggerUtilities.CallBeforeAcquiringLock(); //see method comment lock (this) { if (dynamicModule == null) { dynamicModule = CreateDynamicModule( #if DEBUG EnableAssemblySave ? RefEmit.AssemblyBuilderAccess.RunAndSave : #endif RefEmit.AssemblyBuilderAccess.Run, dynamicAssemblyName, UncollectibleModuleFileName); } } } return(dynamicModule); }
private void GenerateType(TypeDeclaration typeDec, Emit.ModuleBuilder modb, string dllProbeDirectory) { TypeDeclaration temp = null; bool flag = true; while (flag) { if (typeDec is TypeSequence) { temp = (typeDec as TypeSequence).First; typeDec = (typeDec as TypeSequence).Second; } else { temp = typeDec; flag = false; } child = new TypeGen(temp, modb, dllProbeDirectory, this); child.GenerateCode(); typeList.Add(child); } }
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); }
internal MethodToken GetToken(ModuleBuilder mod) { return(mod.GetArrayMethodToken(this.m_containingType, this.m_name, this.m_callingConvention, this.m_returnType, this.m_parameterTypes)); }
internal ModuleBuilderData(ModuleBuilder module, String strModuleName, String strFileName) { Init(module, strModuleName, strFileName); }
internal void CreateMethodBodyHelper(ILGenerator il) { // Sets the IL of the method. An ILGenerator is passed as an argument and the method // queries this instance to get all of the information which it needs. if (il == null) { throw new ArgumentNullException(nameof(il)); } __ExceptionInfo[] excp; int counter = 0; int[] filterAddrs; int[] catchAddrs; int[] catchEndAddrs; Type[] catchClass; int[] type; int numCatch; int start, end; ModuleBuilder dynMod = (ModuleBuilder)m_module; m_containingType.ThrowIfCreated(); if (m_bIsBaked) { throw new InvalidOperationException(SR.InvalidOperation_MethodHasBody); } if (il.m_methodBuilder != this && il.m_methodBuilder != null) { // you don't need to call DefineBody when you get your ILGenerator // through MethodBuilder::GetILGenerator. // throw new InvalidOperationException(SR.InvalidOperation_BadILGeneratorUsage); } ThrowIfShouldNotHaveBody(); if (il.m_ScopeTree.m_iOpenScopeCount != 0) { // There are still unclosed local scope throw new InvalidOperationException(SR.InvalidOperation_OpenLocalVariableScope); } m_ubBody = il.BakeByteArray(); m_mdMethodFixups = il.GetTokenFixups(); //Okay, now the fun part. Calculate all of the exceptions. excp = il.GetExceptions(); int numExceptions = CalculateNumberOfExceptions(excp); if (numExceptions > 0) { m_exceptions = new ExceptionHandler[numExceptions]; for (int i = 0; i < excp.Length; i++) { filterAddrs = excp[i].GetFilterAddresses(); catchAddrs = excp[i].GetCatchAddresses(); catchEndAddrs = excp[i].GetCatchEndAddresses(); catchClass = excp[i].GetCatchClass(); numCatch = excp[i].GetNumberOfCatches(); start = excp[i].GetStartAddress(); end = excp[i].GetEndAddress(); type = excp[i].GetExceptionTypes(); for (int j = 0; j < numCatch; j++) { int tkExceptionClass = 0; if (catchClass[j] != null) { tkExceptionClass = dynMod.GetTypeTokenInternal(catchClass[j]).Token; } switch (type[j]) { case __ExceptionInfo.None: case __ExceptionInfo.Fault: case __ExceptionInfo.Filter: m_exceptions[counter++] = new ExceptionHandler(start, end, filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; case __ExceptionInfo.Finally: m_exceptions[counter++] = new ExceptionHandler(start, excp[i].GetFinallyEndAddress(), filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass); break; } } } } m_bIsBaked = true; if (dynMod.GetSymWriter() != null) { // set the debugging information such as scope and line number // if it is in a debug module // SymbolToken tk = new SymbolToken(MetadataTokenInternal); ISymbolWriter symWriter = dynMod.GetSymWriter(); // call OpenMethod to make this method the current method symWriter.OpenMethod(tk); // call OpenScope because OpenMethod no longer implicitly creating // the top-levelsmethod scope // symWriter.OpenScope(0); if (m_symCustomAttrs != null) { foreach (SymCustomAttr symCustomAttr in m_symCustomAttrs) { dynMod.GetSymWriter().SetSymAttribute( new SymbolToken(MetadataTokenInternal), symCustomAttr.m_name, symCustomAttr.m_data); } } if (m_localSymInfo != null) { m_localSymInfo.EmitLocalSymInfo(symWriter); } il.m_ScopeTree.EmitScopeTree(symWriter); il.m_LineNumberInfo.EmitLineNumberInfo(symWriter); symWriter.CloseScope(il.ILOffset); symWriter.CloseMethod(); } }
private void Init(String name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, ModuleBuilder mod, TypeBuilder type, bool bIsGlobalMethod) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (name.Length == 0) { throw new ArgumentException(SR.Argument_EmptyName, nameof(name)); } if (name[0] == '\0') { throw new ArgumentException(SR.Argument_IllegalName, nameof(name)); } if (mod == null) { throw new ArgumentNullException(nameof(mod)); } if (parameterTypes != null) { foreach (Type t in parameterTypes) { if (t == null) { throw new ArgumentNullException(nameof(parameterTypes)); } } } m_strName = name; m_module = mod; m_containingType = type; // //if (returnType == null) //{ // m_returnType = typeof(void); //} //else { m_returnType = returnType; } if ((attributes & MethodAttributes.Static) == 0) { // turn on the has this calling convention callingConvention = callingConvention | CallingConventions.HasThis; } else if ((attributes & MethodAttributes.Virtual) != 0) { // A method can't be both static and virtual throw new ArgumentException(SR.Arg_NoStaticVirtual); } if ((attributes & MethodAttributes.SpecialName) != MethodAttributes.SpecialName) { if ((type.Attributes & TypeAttributes.Interface) == TypeAttributes.Interface) { // methods on interface have to be abstract + virtual except special name methods such as type initializer if ((attributes & (MethodAttributes.Abstract | MethodAttributes.Virtual)) != (MethodAttributes.Abstract | MethodAttributes.Virtual) && (attributes & MethodAttributes.Static) == 0) { throw new ArgumentException(SR.Argument_BadAttributeOnInterfaceMethod); } } } m_callingConvention = callingConvention; if (parameterTypes != null) { m_parameterTypes = new Type[parameterTypes.Length]; Array.Copy(parameterTypes, 0, m_parameterTypes, 0, parameterTypes.Length); } else { m_parameterTypes = null; } m_returnTypeRequiredCustomModifiers = returnTypeRequiredCustomModifiers; m_returnTypeOptionalCustomModifiers = returnTypeOptionalCustomModifiers; m_parameterTypeRequiredCustomModifiers = parameterTypeRequiredCustomModifiers; m_parameterTypeOptionalCustomModifiers = parameterTypeOptionalCustomModifiers; // m_signature = SignatureHelper.GetMethodSigHelper(mod, callingConvention, // returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, // parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers); m_iAttributes = attributes; m_bIsGlobalMethod = bIsGlobalMethod; m_bIsBaked = false; m_fInitLocals = true; m_localSymInfo = new LocalSymInfo(); m_ubBody = null; m_ilGenerator = null; // Default is managed IL. Manged IL has bit flag 0x0020 set off m_dwMethodImplFlags = MethodImplAttributes.IL; }
public ModuleBuilderTokenGenerator(ModuleBuilder mb) { this.mb = mb; }
private static extern int getUSIndex(ModuleBuilder mb, string str);
private static extern int getToken(ModuleBuilder mb, object obj, bool create_open_instance);
private static extern int getMethodToken(ModuleBuilder mb, MethodBase method, Type[] opt_param_types);
private static extern void basic_init(ModuleBuilder ab);
private static extern void set_wrappers_type(ModuleBuilder mb, Type?ab);
public void CreateAssembly() { // we need to process global assembly attributes before creating assembly name _assembly_name = CreateAssemblyName(); _assembly_name.Name = Path.GetFileNameWithoutExtension(_OutputFileName); var assembly_requirements = (Manager.Options.CompileToMemory) ? Emit.AssemblyBuilderAccess.Run : Emit.AssemblyBuilderAccess.Save; var dir = Path.GetDirectoryName(Path.GetFullPath(_OutputFileName)); if (!Directory.Exists(dir)) Message.FatalError($"specified output directory `$dir' does not exist"); PermissionSet required; PermissionSet optional; PermissionSet refused; foreach ((action, perm_set) in Manager.AttributeCompiler.GetPermissionSets(assembly_attributes)) { switch (action) { case Permissions.SecurityAction.RequestMinimum: required = perm_set; break; case Permissions.SecurityAction.RequestOptional: optional = perm_set; break; case Permissions.SecurityAction.RequestRefuse: refused = perm_set; break; default: Message.FatalError($"$action is not valid here"); break; } } /* define a dynamic assembly */ this._assembly_builder = System.AppDomain.CurrentDomain.DefineDynamicAssembly (this._assembly_name, assembly_requirements, dir, required, optional, refused); GetInformationalAssemblyAttributes().Iter(this._assembly_builder.SetCustomAttribute); if (_assembly_name.Name == "") Message.FatalError("name of output assembly cannot be empty"); /* create a dynamic module */ this._module_builder = (Manager.Options.CompileToMemory) // we cannot give output filename if we are compiling only to Run ? this._assembly_builder.DefineDynamicModule(_assembly_name.Name, Manager.Options.EmitDebug) : this._assembly_builder.DefineDynamicModule(_assembly_name.Name, Path.GetFileName(_OutputFileName), Manager.Options.EmitDebug); if (Manager.Options.EmitDebug) _debug_emit = _module_builder.GetSymWriter(); }
internal ConstructorBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention, Type[]?parameterTypes, ModuleBuilder mod, TypeBuilder type) : this(name, attributes, callingConvention, parameterTypes, null, null, mod, type) { }
private static void CreateDynamicDatabaseModelModule() { // Get tables and their columns var databaseTableInfo = GetDatabaseTableInfo(); AppDomain domain = AppDomain.CurrentDomain; AssemblyName aName = new AssemblyName("Example.DynamicMapping.DynamicDatabaseMapping"); AssemblyBuilder ab = domain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Save); System.Reflection.Emit.ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll"); // Define mapping static class of the database TypeBuilder typeDatabaseModel = mb.DefineType("Example.DynamicMapping.DynamicDatabaseMapping.DatabaseModels.DatabaseMapping", TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed); // Get base table class Type tableBase = typeof(SqlTableModelBase); ConstructorInfo tableBaseCtor = tableBase.GetConstructor(Type.EmptyTypes); // no parameters // Get base column class Type columnBase = typeof(SqlColumnModelBase); ConstructorInfo fieldBaseCtor = columnBase.GetConstructor(new[] { typeof(string) }); // Needed for creating the class constructors in a loop var tableFields = new List <ReflectionDefineField>(); foreach (var table in databaseTableInfo) { var columnFields = new List <ReflectionDefineField>(); TypeBuilder typeTable = mb.DefineType($"Example.DynamicMapping.DynamicDatabaseMapping.DatabaseModels.{table.Name}", TypeAttributes.Public, typeof(SqlTableModelBase)); // Create the column classes for the table foreach (var column in table.Columns) { TypeBuilder typeColumn = mb.DefineType($"Example.DynamicMapping.DynamicDatabaseMapping.DatabaseModels.{table.Name}.{column.Name}", TypeAttributes.Public, typeof(SqlColumnModelBase)); ConstructorBuilder staticColumnConstructorBuilder = typeColumn.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.HasThis, new[] { typeof(string) }); ILGenerator staticColumnConstructorILGenerator = staticColumnConstructorBuilder.GetILGenerator(); staticColumnConstructorILGenerator.Emit(OpCodes.Ldarg_0); staticColumnConstructorILGenerator.Emit(OpCodes.Ldarg_1); staticColumnConstructorILGenerator.Emit(OpCodes.Call, fieldBaseCtor); staticColumnConstructorILGenerator.Emit(OpCodes.Nop); staticColumnConstructorILGenerator.Emit(OpCodes.Nop); staticColumnConstructorILGenerator.Emit(OpCodes.Ret); var createdColumn = typeColumn.CreateType(); ConstructorInfo columnConstructor = createdColumn.GetConstructor(new[] { typeof(string) }); columnFields.Add(new ReflectionDefineField() { ConstructorInfo = columnConstructor, Type = createdColumn }); } ConstructorBuilder staticTableConstructorBuilder = typeTable.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.HasThis, Type.EmptyTypes); ILGenerator staticTableConstructorILGenerator = staticTableConstructorBuilder.GetILGenerator(); staticTableConstructorILGenerator.Emit(OpCodes.Ldarg_0); staticTableConstructorILGenerator.Emit(OpCodes.Call, tableBaseCtor); // Initialise constructor of column classes and assign to property on table class foreach (var field in columnFields) { FieldBuilder fieldColumn = typeTable.DefineField(field.ConstructorInfo.DeclaringType.Name, field.Type, FieldAttributes.InitOnly | FieldAttributes.Public); staticTableConstructorILGenerator.Emit(OpCodes.Ldarg_0); staticTableConstructorILGenerator.Emit(OpCodes.Ldstr, table.Name); staticTableConstructorILGenerator.Emit(OpCodes.Newobj, field.ConstructorInfo); staticTableConstructorILGenerator.Emit(OpCodes.Stfld, fieldColumn); // Stfld => non-static field! } staticTableConstructorILGenerator.Emit(OpCodes.Ret); // Create the table class var createdTable = typeTable.CreateType(); ConstructorInfo tableConstructor = createdTable.GetConstructor(Type.EmptyTypes); tableFields.Add(new ReflectionDefineField() { ConstructorInfo = tableConstructor, Type = createdTable }); } ConstructorBuilder staticDatabaseConstructorBuilder = typeDatabaseModel.DefineConstructor(MethodAttributes.Private | MethodAttributes.PrivateScope | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Static, CallingConventions.Standard, Type.EmptyTypes); ILGenerator staticDatabaseConstructorILGenerator = staticDatabaseConstructorBuilder.GetILGenerator(); // Initialise constructor of table classes and assign to property on mapping class foreach (var field in tableFields) { FieldBuilder fieldDatabase = typeDatabaseModel.DefineField(field.ConstructorInfo.DeclaringType.Name, field.Type, FieldAttributes.InitOnly | FieldAttributes.Public | FieldAttributes.Static); staticDatabaseConstructorILGenerator.Emit(OpCodes.Nop); staticDatabaseConstructorILGenerator.Emit(OpCodes.Newobj, field.ConstructorInfo); staticDatabaseConstructorILGenerator.Emit(OpCodes.Stsfld, fieldDatabase); // Stsfld => static field! } staticDatabaseConstructorILGenerator.Emit(OpCodes.Ret); // Create the mapping class var createdDatabaseModel = typeDatabaseModel.CreateType(); ab.Save(aName.Name + ".dll"); // Save .dll module }
internal QCallModule(ref System.Reflection.Emit.ModuleBuilder module) { _ptr = Unsafe.AsPointer(ref module); _module = module.GetNativeHandle().GetUnderlyingNativeHandle(); }