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

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

Developer Fusion