We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Reflection.Emit \ AssemblyBuilder

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. namespace System.Reflection.Emit
  16. {
  17.     using System;
  18.     using System.IO;
  19.     using System.Diagnostics.SymbolStore;
  20.     using System.Reflection;
  21.     using System.Diagnostics;
  22.     using System.Resources;
  23.     using System.Security.Permissions;
  24.     using System.Runtime.Remoting.Activation;
  25.     using CultureInfo = System.Globalization.CultureInfo;
  26.     using System.Runtime.Serialization;
  27.     using System.Security;
  28.     using System.Threading;
  29.     using System.Runtime.CompilerServices;
  30.     using System.Runtime.InteropServices;
  31.     using System.Runtime.Versioning;
  32.    
  33.     // AssemblyBuilder class.
  34.     // deliberately not [serializable]
  35.     [HostProtection(MayLeakOnAbort = true)]
  36.     [ClassInterface(ClassInterfaceType.None)]
  37.     [ComDefaultInterface(typeof(_AssemblyBuilder))]
  38.     [ComVisible(true)]
  39.     public sealed class AssemblyBuilder : Assembly, _AssemblyBuilder
  40.     {
  41.        
  42. /**********************************************
  43.         *
  44.         * Defines a named dynamic module. It is an error to define multiple
  45.         * modules within an Assembly with the same name. This dynamic module is
  46.         * a transient module.
  47.         *
  48.         **********************************************/       
  49.         public ModuleBuilder DefineDynamicModule(string name)
  50.         {
  51.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  52.            
  53.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  54.             return DefineDynamicModuleInternal(name, false, ref stackMark);
  55.         }
  56.        
  57.         // specify if emit symbol info or not
  58.         public ModuleBuilder DefineDynamicModule(string name, bool emitSymbolInfo)
  59.         {
  60.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  61.            
  62.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  63.             return DefineDynamicModuleInternal(name, emitSymbolInfo, ref stackMark);
  64.         }
  65.        
  66.             // specify if emit symbol info or not
  67.         internal ModuleBuilder DefineDynamicModuleInternal(string name, bool emitSymbolInfo, ref StackCrawlMark stackMark)
  68.         {
  69.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.DefineDynamicModule( " + name + " )");
  70.            
  71.             BCLDebug.Assert(m_assemblyData != null, "m_assemblyData is null in DefineDynamicModuleInternal");
  72.            
  73.             if (name == null)
  74.                 throw new ArgumentNullException("name");
  75.             if (name.Length == 0)
  76.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  77.             if (name[0] == '\0')
  78.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidName"), "name");
  79.            
  80.             m_assemblyData.CheckNameConflict(name);
  81.            
  82.             // create the dynamic module
  83.             ModuleBuilder dynModule = nDefineDynamicModule(this, emitSymbolInfo, name, ref stackMark);
  84.             ISymbolWriter writer = null;
  85.            
  86.             if (emitSymbolInfo) {
  87.                 // create the default SymWriter
  88.                 Assembly assem = LoadISymWrapper();
  89.                 Type symWriter = assem.GetType("System.Diagnostics.SymbolStore.SymWriter", true, false);
  90.                 if (symWriter != null && !symWriter.IsVisible)
  91.                     symWriter = null;
  92.                
  93.                 if (symWriter == null) {
  94.                     // cannot find SymWriter
  95.                     throw new ExecutionEngineException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString(ResId.MissingType), "SymWriter"));
  96.                 }
  97.                 try {
  98.                     (new PermissionSet(PermissionState.Unrestricted)).Assert();
  99.                     writer = (ISymbolWriter)Activator.CreateInstance(symWriter);
  100.                 }
  101.                 finally {
  102.                     CodeAccessPermission.RevertAssert();
  103.                 }
  104.             }
  105.            
  106.             dynModule.Init(name, null, writer);
  107.             m_assemblyData.AddModule(dynModule);
  108.             return dynModule;
  109.         }
  110.        
  111.         private Assembly LoadISymWrapper()
  112.         {
  113.             if (m_assemblyData.m_ISymWrapperAssembly != null)
  114.                 return m_assemblyData.m_ISymWrapperAssembly;
  115.            
  116.             Assembly assem = Assembly.Load("ISymWrapper, Version=" + ThisAssembly.Version + ", Culture=neutral, PublicKeyToken=" + AssemblyRef.MicrosoftPublicKeyToken);
  117.            
  118.             m_assemblyData.m_ISymWrapperAssembly = assem;
  119.             return assem;
  120.         }
  121.        
  122. /**********************************************
  123.         *
  124.         * Defines a named dynamic module. It is an error to define multiple
  125.         * modules within an Assembly with the same name. No symbol information
  126.         * will be emitted.
  127.         *
  128.         **********************************************/       
  129.         public ModuleBuilder DefineDynamicModule(string name, string fileName)
  130.         {
  131.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  132.            
  133.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  134.            
  135.             // delegate to the next DefineDynamicModule
  136.             return DefineDynamicModuleInternal(name, fileName, false, ref stackMark);
  137.         }
  138.        
  139. /**********************************************
  140.         *
  141.         * Emit symbol information if emitSymbolInfo is true using the
  142.         * default symbol writer interface.
  143.         * An exception will be thrown if the assembly is transient.
  144.         *
  145.         **********************************************/       
  146.             // module name
  147.             // module file name
  148.         // specify if emit symbol info or not
  149.         public ModuleBuilder DefineDynamicModule(string name, string fileName, bool emitSymbolInfo)
  150.         {
  151.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  152.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  153.             return DefineDynamicModuleInternal(name, fileName, emitSymbolInfo, ref stackMark);
  154.         }
  155.        
  156.             // module name
  157.             // module file name
  158.             // specify if emit symbol info or not
  159.         // stack crawl mark used to find caller
  160.         private ModuleBuilder DefineDynamicModuleInternal(string name, string fileName, bool emitSymbolInfo, ref StackCrawlMark stackMark)
  161.         {
  162.             if (m_assemblyData.m_isSynchronized) {
  163.                 lock (m_assemblyData) {
  164.                     return DefineDynamicModuleInternalNoLock(name, fileName, emitSymbolInfo, ref stackMark);
  165.                 }
  166.             }
  167.             else {
  168.                 return DefineDynamicModuleInternalNoLock(name, fileName, emitSymbolInfo, ref stackMark);
  169.             }
  170.         }
  171.        
  172.         public override bool ReflectionOnly {
  173.             get { return base.ReflectionOnly; }
  174.         }
  175.        
  176.         internal void CheckContext(params Type[][] typess)
  177.         {
  178.             if (typess == null)
  179.                 return;
  180.            
  181.             foreach (Type[] types in typess)
  182.                 if (types != null)
  183.                     CheckContext(types);
  185.         }
  186.        
  187.         internal void CheckContext(params Type[] types)
  188.         {
  189.             if (types == null)
  190.                 return;
  191.            
  192.             foreach (Type type in types) {
  193.                 if (type == null || type.Module.Assembly == typeof(object).Module.Assembly)
  194.                     return;
  195.                 if (type.Module.Assembly.ReflectionOnly && !ReflectionOnly)
  196.                     throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arugment_EmitMixedContext1"), type.AssemblyQualifiedName));
  197.                
  198.                 if (!type.Module.Assembly.ReflectionOnly && ReflectionOnly)
  199.                     throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arugment_EmitMixedContext2"), type.AssemblyQualifiedName));
  200.             }
  201.         }
  202.        
  203.             // module name
  204.             // module file name
  205.             // specify if emit symbol info or not
  206.         // stack crawl mark used to find caller
  207.         private ModuleBuilder DefineDynamicModuleInternalNoLock(string name, string fileName, bool emitSymbolInfo, ref StackCrawlMark stackMark)
  208.         {
  209.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.DefineDynamicModule( " + name + ", " + fileName + ", " + emitSymbolInfo + " )");
  210.             if (m_assemblyData.m_access == AssemblyBuilderAccess.Run) {
  211.                 // Error! You cannot define a persistable module within a transient data.
  212.                 throw new NotSupportedException(Environment.GetResourceString("Argument_BadPersistableModuleInTransientAssembly"));
  213.             }
  214.            
  215.             if (m_assemblyData.m_isSaved == true) {
  216.                 // assembly has been saved before!
  217.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotAlterAssembly"));
  218.             }
  219.            
  220.             if (name == null)
  221.                 throw new ArgumentNullException("name");
  222.             if (name.Length == 0)
  223.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  224.             if (name[0] == '\0')
  225.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidName"), "name");
  226.            
  227.             if (fileName == null)
  228.                 throw new ArgumentNullException("fileName");
  229.             if (fileName.Length == 0)
  230.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyFileName"), "fileName");
  231.             if (!String.Equals(fileName, Path.GetFileName(fileName)))
  232.                 throw new ArgumentException(Environment.GetResourceString("Argument_NotSimpleFileName"), "fileName");
  233.            
  234.             m_assemblyData.CheckNameConflict(name);
  235.             m_assemblyData.CheckFileNameConflict(fileName);
  236.            
  237.             // ecall to create the dynamic module
  238.             ModuleBuilder dynModule = nDefineDynamicModule(this, emitSymbolInfo, fileName, ref stackMark);
  239.             ISymbolWriter writer = null;
  240.            
  241.             if (emitSymbolInfo) {
  242.                 // create the default SymWriter
  243.                 Assembly assem = LoadISymWrapper();
  244.                 Type symWriter = assem.GetType("System.Diagnostics.SymbolStore.SymWriter", true, false);
  245.                 if (symWriter != null && !symWriter.IsVisible)
  246.                     symWriter = null;
  247.                
  248.                 if (symWriter == null) {
  249.                     // cannot find SymWriter
  250.                     throw new ExecutionEngineException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("MissingType"), "SymWriter"));
  251.                 }
  252.                 try {
  253.                     (new PermissionSet(PermissionState.Unrestricted)).Assert();
  254.                     writer = (ISymbolWriter)Activator.CreateInstance(symWriter);
  255.                 }
  256.                 finally {
  257.                     CodeAccessPermission.RevertAssert();
  258.                 }
  259.                
  260.             }
  261.            
  262.             // initialize the dynamic module's managed side information
  263.             dynModule.Init(name, fileName, writer);
  264.             m_assemblyData.AddModule(dynModule);
  265.             return dynModule;
  266.         }
  267.        
  268.        
  269. /**********************************************
  270.         *
  271.         * Define stand alone managed resource for Assembly
  272.         *
  273.         **********************************************/       
  274.         [ResourceExposure(ResourceScope.Machine)]
  275.         [ResourceConsumption(ResourceScope.Machine)]
  276.         public IResourceWriter DefineResource(string name, string description, string fileName)
  277.         {
  278.             return DefineResource(name, description, fileName, ResourceAttributes.Public);
  279.         }
  280.        
  281. /**********************************************
  282.         *
  283.         * Define stand alone managed resource for Assembly
  284.         *
  285.         **********************************************/       
  286.         [ResourceExposure(ResourceScope.Machine)]
  287.         [ResourceConsumption(ResourceScope.Machine)]
  288.         public IResourceWriter DefineResource(string name, string description, string fileName, ResourceAttributes attribute)
  289.         {
  290.             if (m_assemblyData.m_isSynchronized) {
  291.                 lock (m_assemblyData) {
  292.                     return DefineResourceNoLock(name, description, fileName, attribute);
  293.                 }
  294.             }
  295.             else {
  296.                 return DefineResourceNoLock(name, description, fileName, attribute);
  297.             }
  298.         }
  299.        
  300.         [ResourceExposure(ResourceScope.Machine)]
  301.         [ResourceConsumption(ResourceScope.Machine)]
  302.         private IResourceWriter DefineResourceNoLock(string name, string description, string fileName, ResourceAttributes attribute)
  303.         {
  304.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  305.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.DefineResource( " + name + ", " + fileName + ")");
  306.            
  307.             if (name == null)
  308.                 throw new ArgumentNullException("name");
  309.             if (name.Length == 0)
  310.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), name);
  311.             if (fileName == null)
  312.                 throw new ArgumentNullException("fileName");
  313.             if (fileName.Length == 0)
  314.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyFileName"), "fileName");
  315.             if (!String.Equals(fileName, Path.GetFileName(fileName)))
  316.                 throw new ArgumentException(Environment.GetResourceString("Argument_NotSimpleFileName"), "fileName");
  317.            
  318.             m_assemblyData.CheckResNameConflict(name);
  319.             m_assemblyData.CheckFileNameConflict(fileName);
  320.            
  321.             ResourceWriter resWriter;
  322.             string fullFileName;
  323.            
  324.             if (m_assemblyData.m_strDir == null) {
  325.                 // If assembly directory is null, use current directory
  326.                 fullFileName = Path.Combine(Environment.CurrentDirectory, fileName);
  327.                 resWriter = new ResourceWriter(fullFileName);
  328.             }
  329.             else {
  330.                 // Form the full path given the directory provided by user
  331.                 fullFileName = Path.Combine(m_assemblyData.m_strDir, fileName);
  332.                 resWriter = new ResourceWriter(fullFileName);
  333.             }
  334.             // get the full path
  335.             fullFileName = Path.GetFullPath(fullFileName);
  336.            
  337.             // retrieve just the file name
  338.             fileName = Path.GetFileName(fullFileName);
  339.            
  340.             m_assemblyData.AddResWriter(new ResWriterData(resWriter, null, name, fileName, fullFileName, attribute));
  341.             return resWriter;
  342.         }
  343.        
  344.        
  345. /**********************************************
  346.         *
  347.         * Add an existing resource file to the Assembly
  348.         *
  349.         **********************************************/       
  350.         [ResourceExposure(ResourceScope.Machine)]
  351.         [ResourceConsumption(ResourceScope.Machine)]
  352.         public void AddResourceFile(string name, string fileName)
  353.         {
  354.             AddResourceFile(name, fileName, ResourceAttributes.Public);
  355.         }
  356.        
  357. /**********************************************
  358.         *
  359.         * Add an existing resource file to the Assembly
  360.         *
  361.         **********************************************/       
  362.         [ResourceExposure(ResourceScope.Machine)]
  363.         [ResourceConsumption(ResourceScope.Machine)]
  364.         public void AddResourceFile(string name, string fileName, ResourceAttributes attribute)
  365.         {
  366.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  367.             if (m_assemblyData.m_isSynchronized) {
  368.                 lock (m_assemblyData) {
  369.                     AddResourceFileNoLock(name, fileName, attribute);
  370.                 }
  371.             }
  372.             else {
  373.                 AddResourceFileNoLock(name, fileName, attribute);
  374.             }
  375.         }
  376.        
  377.         [ResourceExposure(ResourceScope.Machine)]
  378.         [ResourceConsumption(ResourceScope.Machine)]
  379.         private void AddResourceFileNoLock(string name, string fileName, ResourceAttributes attribute)
  380.         {
  381.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.AddResourceFile( " + name + ", " + fileName + ")");
  382.            
  383.             if (name == null)
  384.                 throw new ArgumentNullException("name");
  385.             if (name.Length == 0)
  386.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), name);
  387.             if (fileName == null)
  388.                 throw new ArgumentNullException("fileName");
  389.             if (fileName.Length == 0)
  390.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyFileName"), fileName);
  391.             if (!String.Equals(fileName, Path.GetFileName(fileName)))
  392.                 throw new ArgumentException(Environment.GetResourceString("Argument_NotSimpleFileName"), "fileName");
  393.            
  394.             m_assemblyData.CheckResNameConflict(name);
  395.             m_assemblyData.CheckFileNameConflict(fileName);
  396.            
  397.             string fullFileName;
  398.            
  399.             if (m_assemblyData.m_strDir == null) {
  400.                 // If assembly directory is null, use current directory
  401.                 fullFileName = Path.Combine(Environment.CurrentDirectory, fileName);
  402.             }
  403.             else {
  404.                 // Form the full path given the directory provided by user
  405.                 fullFileName = Path.Combine(m_assemblyData.m_strDir, fileName);
  406.             }
  407.            
  408.             // get the full path
  409.             fullFileName = Path.GetFullPath(fullFileName);
  410.            
  411.             // retrieve just the file name
  412.             fileName = Path.GetFileName(fullFileName);
  413.            
  414.             if (File.Exists(fullFileName) == false)
  415.                 throw new FileNotFoundException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("IO.FileNotFound_FileName"), fileName), fileName);
  416.             m_assemblyData.AddResWriter(new ResWriterData(null, null, name, fileName, fullFileName, attribute));
  417.         }
  418.        
  419.         // Returns the names of all the resources
  420.         public override string[] GetManifestResourceNames()
  421.         {
  422.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  423.         }
  424.        
  425.         public override FileStream GetFile(string name)
  426.         {
  427.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  428.         }
  429.        
  430.         public override FileStream[] GetFiles(bool getResourceModules)
  431.         {
  432.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  433.         }
  434.        
  435.         public override Stream GetManifestResourceStream(Type type, string name)
  436.         {
  437.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  438.         }
  439.        
  440.         public override Stream GetManifestResourceStream(string name)
  441.         {
  442.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  443.         }
  444.        
  445.         public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
  446.         {
  447.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  448.         }
  449.        
  450.         public override string Location {
  451.             get {
  452.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  453.             }
  454.         }
  455.        
  456.         public override string ImageRuntimeVersion {
  457.             get { return RuntimeEnvironment.GetSystemVersion(); }
  458.         }
  459.        
  460.         public override string CodeBase {
  461.             get {
  462.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  463.             }
  464.         }
  465.        
  466.        
  467.        
  468.        
  469.        
  470. /**********************************************
  471.         *
  472.         * return a dynamic module with the specified name.
  473.         *
  474.         **********************************************/       
  475.         // the name of module for the look up
  476.         public ModuleBuilder GetDynamicModule(string name)
  477.         {
  478.             if (m_assemblyData.m_isSynchronized) {
  479.                 lock (m_assemblyData) {
  480.                     return GetDynamicModuleNoLock(name);
  481.                 }
  482.             }
  483.             else {
  484.                 return GetDynamicModuleNoLock(name);
  485.             }
  486.         }
  487.        
  488.         // the name of module for the look up
  489.         private ModuleBuilder GetDynamicModuleNoLock(string name)
  490.         {
  491.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.GetDynamicModule( " + name + " )");
  492.             if (name == null)
  493.                 throw new ArgumentNullException("name");
  494.             if (name.Length == 0)
  495.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  496.            
  497.             int size = m_assemblyData.m_moduleBuilderList.Count;
  498.             for (int i = 0; i < size; i++) {
  499.                 ModuleBuilder moduleBuilder = (ModuleBuilder)m_assemblyData.m_moduleBuilderList[i];
  500.                 if (moduleBuilder.m_moduleData.m_strModuleName.Equals(name)) {
  501.                     return moduleBuilder;
  502.                 }
  503.             }
  504.             return null;
  505.         }
  506.        
  507. /**********************************************
  508.         *
  509.         * Setting the entry point if the assembly builder is building
  510.         * an exe.
  511.         *
  512.         **********************************************/       
  513.         public void SetEntryPoint(MethodInfo entryMethod)
  514.         {
  515.             SetEntryPoint(entryMethod, PEFileKinds.ConsoleApplication);
  516.         }
  517.             // entry method for the assembly. We use this to determine the entry module
  518.         // file kind for the assembly.
  519.         public void SetEntryPoint(MethodInfo entryMethod, PEFileKinds fileKind)
  520.         {
  521.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  522.             if (m_assemblyData.m_isSynchronized) {
  523.                 lock (m_assemblyData) {
  524.                     SetEntryPointNoLock(entryMethod, fileKind);
  525.                 }
  526.             }
  527.             else {
  528.                 SetEntryPointNoLock(entryMethod, fileKind);
  529.             }
  530.         }
  531.        
  532.             // entry method for the assembly. We use this to determine the entry module
  533.         // file kind for the assembly.
  534.         private void SetEntryPointNoLock(MethodInfo entryMethod, PEFileKinds fileKind)
  535.         {
  536.            
  537.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.SetEntryPoint");
  538.             if (entryMethod == null)
  539.                 throw new ArgumentNullException("entryMethod");
  540.            
  541.             //
  542.             //
  543.             Module tmpModule = entryMethod.Module;
  544.             if (!(tmpModule is ModuleBuilder && this.Equals(tmpModule.Assembly)))
  545.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EntryMethodNotDefinedInAssembly"));
  546.             m_assemblyData.m_entryPointModule = (ModuleBuilder)tmpModule;
  547.             m_assemblyData.m_entryPointMethod = entryMethod;
  548.             m_assemblyData.m_peFileKind = fileKind;
  549.             m_assemblyData.m_entryPointModule.SetEntryPoint(entryMethod);
  550.         }
  551.        
  552.        
  553.         // Override the EntryPoint method on Assembly.
  554.         public override MethodInfo EntryPoint {
  555.             get { return m_assemblyData.m_entryPointMethod; }
  556.         }
  557.        
  558. /**********************************************
  559.         * Use this function if client decides to form the custom attribute blob themselves
  560.         **********************************************/       
  561.         [System.Runtime.InteropServices.ComVisible(true)]
  562.         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
  563.         {
  564.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  565.             if (con == null)
  566.                 throw new ArgumentNullException("con");
  567.             if (binaryAttribute == null)
  568.                 throw new ArgumentNullException("binaryAttribute");
  569.            
  570.             ModuleBuilder inMemoryAssemblyModule;
  571.             inMemoryAssemblyModule = m_assemblyData.GetInMemoryAssemblyModule();
  572.                 // This is the AssemblyDef token
  573.                 // pass in the in-memory assembly module
  574.             TypeBuilder.InternalCreateCustomAttribute(AssemblyBuilderData.m_tkAssembly, inMemoryAssemblyModule.GetConstructorToken(con).Token, binaryAttribute, inMemoryAssemblyModule, false, typeof(System.Diagnostics.DebuggableAttribute) == con.DeclaringType);
  575.            
  576.             // Track the CA for persistence
  577.             if (m_assemblyData.m_access == AssemblyBuilderAccess.Run) {
  578.                 return;
  579.             }
  580.            
  581.             // tracking the CAs for persistence
  582.             m_assemblyData.AddCustomAttribute(con, binaryAttribute);
  583.         }
  584.        
  585. /**********************************************
  586.         * Use this function if client wishes to build CustomAttribute using CustomAttributeBuilder
  587.         **********************************************/       
  588.         public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
  589.         {
  590.             CodeAccessPermission.DemandInternal(PermissionType.ReflectionEmit);
  591.             if (customBuilder == null) {
  592.                 throw new ArgumentNullException("customBuilder");
  593.             }
  594.            
  595.             ModuleBuilder inMemoryAssemblyModule;
  596.             inMemoryAssemblyModule = m_assemblyData.GetInMemoryAssemblyModule();
  597.             customBuilder.CreateCustomAttribute(inMemoryAssemblyModule, AssemblyBuilderData.m_tkAssembly);
  598.             // This is the AssemblyDef token
  599.             // Track the CA for persistence
  600.             if (m_assemblyData.m_access == AssemblyBuilderAccess.Run) {
  601.                 return;
  602.             }
  603.             m_assemblyData.AddCustomAttribute(customBuilder);
  604.         }
  605.        
  606.        
  607. /**********************************************
  608.         *
  609.         * Saves the assembly to disk. Also saves all dynamic modules defined
  610.         * in this dynamic assembly. Assembly file name can be the same as one of
  611.         * the module's name. If so, assembly info is stored within that module.
  612.         * Assembly file name can be different from all of the modules underneath. In
  613.         * this case, assembly is stored stand alone.
  614.         *
  615.         **********************************************/       
  616.        
  617.         [ResourceExposure(ResourceScope.Machine)]
  618.         [ResourceConsumption(ResourceScope.Machine)]
  619.         // assembly file name
  620.         public void Save(string assemblyFileName)
  621.         {
  622.             Save(assemblyFileName, System.Reflection.PortableExecutableKinds.ILOnly, System.Reflection.ImageFileMachine.I386);
  623.         }
  624.        
  625.         [ResourceExposure(ResourceScope.Machine)]
  626.         [ResourceConsumption(ResourceScope.Machine)]
  627.         public void Save(string assemblyFileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  628.         {
  629.             if (m_assemblyData.m_isSynchronized) {
  630.                 lock (m_assemblyData) {
  631.                     SaveNoLock(assemblyFileName, portableExecutableKind, imageFileMachine);
  632.                 }
  633.             }
  634.             else {
  635.                 SaveNoLock(assemblyFileName, portableExecutableKind, imageFileMachine);
  636.             }
  637.         }
  638.        
  639.         [ResourceExposure(ResourceScope.Machine)]
  640.         [ResourceConsumption(ResourceScope.Machine)]
  641.         private void SaveNoLock(string assemblyFileName, PortableExecutableKinds portableExecutableKind, ImageFileMachine imageFileMachine)
  642.         {
  643.             int i;
  644.             int size;
  645.             Type type;
  646.             TypeBuilder typeBuilder;
  647.             ModuleBuilder modBuilder;
  648.             string strModFileName;
  649.             ModuleBuilder assemblyModule;
  650.             ResWriterData tempRes;
  651.             int[] tkAttrs = null;
  652.             int[] tkAttrs2 = null;
  653.             ModuleBuilder onDiskAssemblyModule;
  654.            
  655.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.Save( " + assemblyFileName + " )");
  656.            
  657.             string tmpVersionFile = null;
  658.            
  659.             try {
  660.                 if (m_assemblyData.m_iCABuilder != 0)
  661.                     tkAttrs = new int[m_assemblyData.m_iCABuilder];
  662.                 if (m_assemblyData.m_iCAs != 0)
  663.                     tkAttrs2 = new int[m_assemblyData.m_iCAs];
  664.                
  665.                 if (m_assemblyData.m_isSaved == true) {
  666.                     // assembly has been saved before!
  667.                     throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString(ResId.InvalidOperation_AssemblyHasBeenSaved), nGetSimpleName()));
  668.                 }
  669.                
  670.                 if ((m_assemblyData.m_access & AssemblyBuilderAccess.Save) != AssemblyBuilderAccess.Save) {
  671.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CantSaveTransientAssembly"));
  672.                 }
  673.                
  674.                 if (assemblyFileName == null)
  675.                     throw new ArgumentNullException("assemblyFileName");
  676.                 if (assemblyFileName.Length == 0)
  677.                     throw new ArgumentException(Environment.GetResourceString("Argument_EmptyFileName"), "assemblyFileName");
  678.                 if (!String.Equals(assemblyFileName, Path.GetFileName(assemblyFileName)))
  679.                     throw new ArgumentException(Environment.GetResourceString("Argument_NotSimpleFileName"), "assemblyFileName");
  680.                
  681.                 // Check if assembly info is supposed to be stored with one of the module files.
  682.                 assemblyModule = m_assemblyData.FindModuleWithFileName(assemblyFileName);
  683.                
  684.                 if (assemblyModule != null) {
  685.