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 \ AssemblyBuilderData

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. ////////////////////////////////////////////////////////////////////////////////
  16. ////////////////////////////////////////////////////////////////////////////////
  18. namespace System.Reflection.Emit
  19. {
  20.     using System;
  21.     using IList = System.Collections.IList;
  22.     using ArrayList = System.Collections.ArrayList;
  23.     using System.Reflection;
  24.     using System.Security;
  25.     using System.Diagnostics;
  26.     using CultureInfo = System.Globalization.CultureInfo;
  27.     using ResourceWriter = System.Resources.ResourceWriter;
  28.     using System.IO;
  29.     using System.Runtime.Versioning;
  30.    
  31.     // This is a package private class. This class hold all of the managed
  32.     // data member for AssemblyBuilder. Note that what ever data members added to
  33.     // this class cannot be accessed from the EE.
  34.     internal class AssemblyBuilderData
  35.     {
  36.         [ResourceExposure(ResourceScope.Machine)]
  37.         [ResourceConsumption(ResourceScope.Machine)]
  38.         internal AssemblyBuilderData(Assembly assembly, string strAssemblyName, AssemblyBuilderAccess access, string dir)
  39.         {
  40.             m_assembly = assembly;
  41.             m_strAssemblyName = strAssemblyName;
  42.             m_access = access;
  43.             m_moduleBuilderList = new ArrayList();
  44.             m_resWriterList = new ArrayList();
  45.             m_publicComTypeList = null;
  46.             m_CABuilders = null;
  47.             m_CABytes = null;
  48.             m_CACons = null;
  49.             m_iPublicComTypeCount = 0;
  50.             m_iCABuilder = 0;
  51.             m_iCAs = 0;
  52.             m_entryPointModule = null;
  53.             m_isSaved = false;
  54.             if (dir == null && access != AssemblyBuilderAccess.Run)
  55.                 m_strDir = Environment.CurrentDirectory;
  56.             else
  57.                 m_strDir = dir;
  58.             m_RequiredPset = null;
  59.             m_OptionalPset = null;
  60.             m_RefusedPset = null;
  61.             m_isSynchronized = false;
  62.            
  63.             m_InMemoryAssemblyModule = null;
  64.             m_OnDiskAssemblyModule = null;
  65.             m_peFileKind = PEFileKinds.Dll;
  66.            
  67.             m_entryPointMethod = null;
  68.             m_ISymWrapperAssembly = null;
  69.         }
  70.        
  71.         // Helper to add a dynamic module into the tracking list
  72.         internal void AddModule(ModuleBuilder dynModule)
  73.         {
  74.             m_moduleBuilderList.Add(dynModule);
  75.            
  76.             if (m_assembly != null)
  77.                 // also add the Module into the file list in the Assembly.
  78.                 m_assembly.nAddFileToInMemoryFileList(dynModule.m_moduleData.m_strFileName, dynModule);
  79.         }
  80.        
  81.         // Helper to add a resource information into the tracking list
  82.         internal void AddResWriter(ResWriterData resData)
  83.         {
  84.             m_resWriterList.Add(resData);
  85.         }
  86.        
  87.        
  88.         // Helper to track CAs to persist onto disk
  89.         internal void AddCustomAttribute(CustomAttributeBuilder customBuilder)
  90.         {
  91.            
  92.             // make sure we have room for this CA
  93.             if (m_CABuilders == null) {
  94.                 m_CABuilders = new CustomAttributeBuilder[m_iInitialSize];
  95.             }
  96.             if (m_iCABuilder == m_CABuilders.Length) {
  97.                 CustomAttributeBuilder[] tempCABuilders = new CustomAttributeBuilder[m_iCABuilder * 2];
  98.                 Array.Copy(m_CABuilders, tempCABuilders, m_iCABuilder);
  99.                 m_CABuilders = tempCABuilders;
  100.             }
  101.             m_CABuilders[m_iCABuilder] = customBuilder;
  102.            
  103.             m_iCABuilder++;
  104.         }
  105.        
  106.         // Helper to track CAs to persist onto disk
  107.         internal void AddCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
  108.         {
  109.            
  110.             // make sure we have room for this CA
  111.             if (m_CABytes == null) {
  112.                 m_CABytes = new byte[m_iInitialSize][];
  113.                 m_CACons = new ConstructorInfo[m_iInitialSize];
  114.             }
  115.             if (m_iCAs == m_CABytes.Length) {
  116.                 // enlarge the arrays
  117.                 byte[][] temp = new byte[m_iCAs * 2][];
  118.                 ConstructorInfo[] tempCon = new ConstructorInfo[m_iCAs * 2];
  119.                 for (int i = 0; i < m_iCAs; i++) {
  120.                     temp[i] = m_CABytes[i];
  121.                     tempCon[i] = m_CACons[i];
  122.                 }
  123.                 m_CABytes = temp;
  124.                 m_CACons = tempCon;
  125.             }
  126.            
  127.             byte[] attrs = new byte[binaryAttribute.Length];
  128.             Array.Copy(binaryAttribute, attrs, binaryAttribute.Length);
  129.             m_CABytes[m_iCAs] = attrs;
  130.             m_CACons[m_iCAs] = con;
  131.             m_iCAs++;
  132.         }
  133.        
  134.        
  135.         // Helper to ensure the resource name is unique underneath assemblyBuilder
  136.         internal void CheckResNameConflict(string strNewResName)
  137.         {
  138.             int size = m_resWriterList.Count;
  139.             int i;
  140.             for (i = 0; i < size; i++) {
  141.                 ResWriterData resWriter = (ResWriterData)m_resWriterList[i];
  142.                 if (resWriter.m_strName.Equals(strNewResName)) {
  143.                     // Cannot have two resources with the same name
  144.                     throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateResourceName"));
  145.                 }
  146.             }
  147.         }
  148.        
  149.        
  150.         // Helper to ensure the module name is unique underneath assemblyBuilder
  151.         [ResourceExposure(ResourceScope.None)]
  152.         [ResourceConsumption(ResourceScope.Assembly, ResourceScope.Assembly)]
  153.         internal void CheckNameConflict(string strNewModuleName)
  154.         {
  155.             int size = m_moduleBuilderList.Count;
  156.             int i;
  157.             for (i = 0; i < size; i++) {
  158.                 ModuleBuilder moduleBuilder = (ModuleBuilder)m_moduleBuilderList[i];
  159.                 if (moduleBuilder.m_moduleData.m_strModuleName.Equals(strNewModuleName)) {
  160.                     // Cannot have two dynamic modules with the same name
  161.                     throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateModuleName"));
  162.                 }
  163.             }
  164.             // Also check to see if there is any loaded module with the same name.
  165.             // This is to take care of the case where a Dynamic module might be
  166.             // added to a static assembly.
  167.             if (!(m_assembly is AssemblyBuilder)) {
  168.                 if (m_assembly.GetModule(strNewModuleName) != null) {
  169.                     // Cannot have two dynamic modules with the same name
  170.                     throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateModuleName"));
  171.                 }
  172.             }
  173.         }
  174.        
  175.         // Helper to ensure the type name is unique underneath assemblyBuilder
  176.         internal void CheckTypeNameConflict(string strTypeName, TypeBuilder enclosingType)
  177.         {
  178.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilderData.CheckTypeNameConflict( " + strTypeName + " )");
  179.             for (int i = 0; i < m_moduleBuilderList.Count; i++) {
  180.                 ModuleBuilder curModule = (ModuleBuilder)m_moduleBuilderList[i];
  181.                 for (int j = 0; j < curModule.m_TypeBuilderList.Count; j++) {
  182.                     Type curType = (Type)curModule.m_TypeBuilderList[j];
  183.                     if (curType.FullName.Equals(strTypeName) && curType.DeclaringType == enclosingType) {
  184.                         // Cannot have two types with the same name
  185.                         throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateTypeName"));
  186.                     }
  187.                 }
  188.             }
  189.            
  190.             // Also check to see if there is any loaded type with the same name.
  191.             // You only need to make this test for non-nested types since any
  192.             // duplicates in nested types will be caught at the top level.
  193.             if ((enclosingType == null) && !(m_assembly is AssemblyBuilder)) {
  194.                 if (m_assembly.GetType(strTypeName, false, false) != null) {
  195.                     // Cannot have two types with the same name
  196.                     throw new ArgumentException(Environment.GetResourceString("Argument_DuplicateTypeName"));
  197.                 }
  198.             }
  199.         }
  200.        
  201.        
  202.         // Helper to ensure the file name is unique underneath assemblyBuilder. This includes
  203.         // modules and resources.
  204.         //
  205.         //
  206.         //
  207.         internal void CheckFileNameConflict(string strFileName)
  208.         {
  209.             int size = m_moduleBuilderList.Count;
  210.             int i;
  211.             for (i = 0; i < size; i++) {
  212.                 ModuleBuilder moduleBuilder = (ModuleBuilder)m_moduleBuilderList[i];
  213.                 if (moduleBuilder.m_moduleData.m_strFileName != null) {
  214.                     if (String.Compare(moduleBuilder.m_moduleData.m_strFileName, strFileName, StringComparison.OrdinalIgnoreCase) == 0) {
  215.                         // Cannot have two dynamic module with the same name
  216.                         throw new ArgumentException(Environment.GetResourceString("Argument_DuplicatedFileName"));
  217.                     }
  218.                 }
  219.             }
  220.             size = m_resWriterList.Count;
  221.             for (i = 0; i < size; i++) {
  222.                 ResWriterData resWriter = (ResWriterData)m_resWriterList[i];
  223.                 if (resWriter.m_strFileName != null) {
  224.                     if (String.Compare(resWriter.m_strFileName, strFileName, StringComparison.OrdinalIgnoreCase) == 0) {
  225.                         // Cannot have two dynamic module with the same name
  226.                         throw new ArgumentException(Environment.GetResourceString("Argument_DuplicatedFileName"));
  227.                     }
  228.                 }
  229.             }
  230.            
  231.         }
  232.        
  233.         // Helper to look up which module that assembly is supposed to be stored at
  234.         //
  235.         //
  236.         //
  237.         internal ModuleBuilder FindModuleWithFileName(string strFileName)
  238.         {
  239.             int size = m_moduleBuilderList.Count;
  240.             int i;
  241.             for (i = 0; i < size; i++) {
  242.                 ModuleBuilder moduleBuilder = (ModuleBuilder)m_moduleBuilderList[i];
  243.                 if (moduleBuilder.m_moduleData.m_strFileName != null) {
  244.                     if (String.Compare(moduleBuilder.m_moduleData.m_strFileName, strFileName, StringComparison.OrdinalIgnoreCase) == 0) {
  245.                         return moduleBuilder;
  246.                     }
  247.                 }
  248.             }
  249.             return null;
  250.         }
  251.        
  252.         // Helper to look up module by name.
  253.         //
  254.         //
  255.         //
  256.         internal ModuleBuilder FindModuleWithName(string strName)
  257.         {
  258.             int size = m_moduleBuilderList.Count;
  259.             int i;
  260.             for (i = 0; i < size; i++) {
  261.                 ModuleBuilder moduleBuilder = (ModuleBuilder)m_moduleBuilderList[i];
  262.                 if (moduleBuilder.m_moduleData.m_strModuleName != null) {
  263.                     if (String.Compare(moduleBuilder.m_moduleData.m_strModuleName, strName, StringComparison.OrdinalIgnoreCase) == 0)
  264.                         return moduleBuilder;
  265.                 }
  266.             }
  267.             return null;
  268.         }
  269.        
  270.        
  271.         // add type to public COMType tracking list
  272.         internal void AddPublicComType(Type type)
  273.         {
  274.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilderData.AddPublicComType( " + type.FullName + " )");
  275.             if (m_isSaved == true) {
  276.                 // assembly has been saved before!
  277.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotAlterAssembly"));
  278.             }
  279.             EnsurePublicComTypeCapacity();
  280.             m_publicComTypeList[m_iPublicComTypeCount] = type;
  281.             m_iPublicComTypeCount++;
  282.         }
  283.        
  284.         // add security permission requests
  285.         internal void AddPermissionRequests(PermissionSet required, PermissionSet optional, PermissionSet refused)
  286.         {
  287.             BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilderData.AddPermissionRequests");
  288.             if (m_isSaved == true) {
  289.                 // assembly has been saved before!
  290.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotAlterAssembly"));
  291.             }
  292.             m_RequiredPset = required;
  293.             m_OptionalPset = optional;
  294.             m_RefusedPset = refused;
  295.         }
  296.        
  297.         internal void EnsurePublicComTypeCapacity()
  298.         {
  299.             if (m_publicComTypeList == null) {
  300.                 m_publicComTypeList = new Type[m_iInitialSize];
  301.             }
  302.             if (m_iPublicComTypeCount == m_publicComTypeList.Length) {
  303.                 Type[] tempTypeList = new Type[m_iPublicComTypeCount * 2];
  304.                 Array.Copy(m_publicComTypeList, tempTypeList, m_iPublicComTypeCount);
  305.                 m_publicComTypeList = tempTypeList;
  306.             }
  307.         }
  308.        
  309.         internal ModuleBuilder GetInMemoryAssemblyModule()
  310.         {
  311.             if (m_InMemoryAssemblyModule == null) {
  312.                 ModuleBuilder modBuilder = m_assembly.nGetInMemoryAssemblyModule();
  313.                 modBuilder.Init("RefEmit_InMemoryManifestModule", null, null);
  314.                 m_InMemoryAssemblyModule = modBuilder;
  315.             }
  316.             return m_InMemoryAssemblyModule;
  317.         }
  318.        
  319.         internal ModuleBuilder GetOnDiskAssemblyModule()
  320.         {
  321.             if (m_OnDiskAssemblyModule == null) {
  322.                 ModuleBuilder modBuilder = m_assembly.nGetOnDiskAssemblyModule();
  323.                 modBuilder.Init("RefEmit_OnDiskManifestModule", null, null);
  324.                 m_OnDiskAssemblyModule = modBuilder;
  325.             }
  326.             return m_OnDiskAssemblyModule;
  327.         }
  328.        
  329.         internal void SetOnDiskAssemblyModule(ModuleBuilder modBuilder)
  330.         {
  331.             m_OnDiskAssemblyModule = modBuilder;
  332.         }
  333.        
  334.         internal ArrayList m_moduleBuilderList;
  335.         internal ArrayList m_resWriterList;
  336.         internal string m_strAssemblyName;
  337.         internal AssemblyBuilderAccess m_access;
  338.         internal Assembly m_assembly;
  339.        
  340.         internal Type[] m_publicComTypeList;
  341.         internal int m_iPublicComTypeCount;
  342.        
  343.         internal ModuleBuilder m_entryPointModule;
  344.         internal bool m_isSaved;
  345.         internal const int m_iInitialSize = 16;
  346.         internal string m_strDir;
  347.        
  348.         // hard coding the assembly def token
  349.         internal const int m_tkAssembly = 536870913;
  350.        
  351.         // Security permission requests
  352.         internal PermissionSet m_RequiredPset;
  353.         internal PermissionSet m_OptionalPset;
  354.         internal PermissionSet m_RefusedPset;
  355.        
  356.         // Assembly builder may be optionally synchronized.
  357.         internal bool m_isSynchronized;
  358.        
  359.         // tracking AssemblyDef's CAs for persistence to disk
  360.         internal CustomAttributeBuilder[] m_CABuilders;
  361.         internal int m_iCABuilder;
  362.         internal byte[][] m_CABytes;
  363.         internal ConstructorInfo[] m_CACons;
  364.         internal int m_iCAs;
  365.         internal PEFileKinds m_peFileKind;
  366.         // assembly file kind
  367.         private ModuleBuilder m_InMemoryAssemblyModule;
  368.         private ModuleBuilder m_OnDiskAssemblyModule;
  369.         internal MethodInfo m_entryPointMethod;
  370.         internal Assembly m_ISymWrapperAssembly;
  371.        
  372.        
  373.     }
  374.    
  375.    
  376. /**********************************************
  377.     *
  378.     * Internal structure to track the list of ResourceWriter for
  379.     * AssemblyBuilder & ModuleBuilder.
  380.     *
  381.     **********************************************/   
  382.     internal class ResWriterData
  383.     {
  384.         internal ResWriterData(ResourceWriter resWriter, Stream memoryStream, string strName, string strFileName, string strFullFileName, ResourceAttributes attribute)
  385.         {
  386.             m_resWriter = resWriter;
  387.             m_memoryStream = memoryStream;
  388.             m_strName = strName;
  389.             m_strFileName = strFileName;
  390.             m_strFullFileName = strFullFileName;
  391.             m_nextResWriter = null;
  392.             m_attribute = attribute;
  393.         }
  394.        
  395.         internal ResourceWriter m_resWriter;
  396.         internal string m_strName;
  397.         internal string m_strFileName;
  398.         internal string m_strFullFileName;
  399.         internal Stream m_memoryStream;
  400.         internal ResWriterData m_nextResWriter;
  401.         internal ResourceAttributes m_attribute;
  402.     }
  403.    
  404.    
  405. }

Developer Fusion