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

  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.    
  18.     using System;
  19.     using System.Runtime.Remoting.Activation;
  20.     using System.Reflection;
  21.     using System.Security;
  22.     using System.Security.Permissions;
  23.     using System.Diagnostics;
  24.     using System.Runtime.InteropServices;
  25.     using System.Runtime.CompilerServices;
  26.     using ArrayList = System.Collections.ArrayList;
  27.     using CultureInfo = System.Globalization.CultureInfo;
  28.     using System.Threading;
  29.    
  30.    
  31.     [Serializable()]
  32.     [System.Runtime.InteropServices.ComVisible(true)]
  33.     public enum PackingSize
  34.     {
  35.         Unspecified = 0,
  36.         Size1 = 1,
  37.         Size2 = 2,
  38.         Size4 = 4,
  39.         Size8 = 8,
  40.         Size16 = 16,
  41.         Size32 = 32,
  42.         Size64 = 64,
  43.         Size128 = 128
  44.     }
  45.    
  46.    
  47.     [HostProtection(MayLeakOnAbort = true)]
  48.     [ClassInterface(ClassInterfaceType.None)]
  49.     [ComDefaultInterface(typeof(_TypeBuilder))]
  50.     [System.Runtime.InteropServices.ComVisible(true)]
  51.     public sealed class TypeBuilder : Type, _TypeBuilder
  52.     {
  53.         #region Declarations
  54.         internal class CustAttr
  55.         {
  56.             private ConstructorInfo m_con;
  57.             private byte[] m_binaryAttribute;
  58.             private CustomAttributeBuilder m_customBuilder;
  59.            
  60.             public CustAttr(ConstructorInfo con, byte[] binaryAttribute)
  61.             {
  62.                 if (con == null)
  63.                     throw new ArgumentNullException("con");
  64.                
  65.                 if (binaryAttribute == null)
  66.                     throw new ArgumentNullException("binaryAttribute");
  67.                
  68.                 m_con = con;
  69.                 m_binaryAttribute = binaryAttribute;
  70.             }
  71.            
  72.             public CustAttr(CustomAttributeBuilder customBuilder)
  73.             {
  74.                 if (customBuilder == null)
  75.                     throw new ArgumentNullException("customBuilder");
  76.                
  77.                 m_customBuilder = customBuilder;
  78.             }
  79.            
  80.             public void Bake(ModuleBuilder module, int token)
  81.             {
  82.                 if (m_customBuilder == null) {
  83.                     TypeBuilder.InternalCreateCustomAttribute(token, module.GetConstructorToken(m_con).Token, m_binaryAttribute, module, false);
  84.                 }
  85.                 else {
  86.                     m_customBuilder.CreateCustomAttribute(module, token);
  87.                 }
  88.             }
  89.         }
  90.         #endregion
  91.        
  92.         #region Public Static Methods
  93.         public static MethodInfo GetMethod(Type type, MethodInfo method)
  94.         {
  95.             if (!(type is TypeBuilder) && !(type is TypeBuilderInstantiation))
  96.                 throw new ArgumentException(Environment.GetResourceString("Argument_MustBeTypeBuilder"));
  97.            
  98.             // The following checks establishes invariants that more simply put require type to be generic and
  99.             // method to be a generic method definition declared on the generic type definition of type.
  100.             // To create generic method G<Foo>.M<Bar> these invariants require that G<Foo>.M<S> be created by calling
  101.             // this function followed by MakeGenericMethod on the resulting MethodInfo to finally get G<Foo>.M<Bar>.
  102.             // We could also allow G<T>.M<Bar> to be created before G<Foo>.M<Bar> (BindGenParm followed by this method)
  103.             // if we wanted to but that just complicates things so these checks are designed to prevent that scenario.
  104.            
  105.             if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
  106.                 throw new ArgumentException(Environment.GetResourceString("Argument_NeedGenericMethodDefinition"), "method");
  107.            
  108.             if (method.DeclaringType == null || !method.DeclaringType.IsGenericTypeDefinition)
  109.                 throw new ArgumentException(Environment.GetResourceString("Argument_MethodNeedGenericDeclaringType"), "method");
  110.            
  111.             if (type.GetGenericTypeDefinition() != method.DeclaringType)
  112.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidMethodDeclaringType"), "type");
  113.            
  114.             // The following converts from Type or TypeBuilder of G<T> to TypeBuilderInstantiation G<T>. These types
  115.             // both logically represent the same thing. The runtime displays a similar convention by having
  116.             // G<M>.M() be encoded by a typeSpec whose parent is the typeDef for G<M> and whose instantiation is also G<M>.
  117.             if (type.IsGenericTypeDefinition)
  118.                 type = type.MakeGenericType(type.GetGenericArguments());
  119.            
  120.             if (!(type is TypeBuilderInstantiation))
  121.                 throw new ArgumentException(Environment.GetResourceString("Argument_NeedNonGenericType"), "type");
  122.            
  123.             return MethodOnTypeBuilderInstantiation.GetMethod(method, type as TypeBuilderInstantiation);
  124.         }
  125.         public static ConstructorInfo GetConstructor(Type type, ConstructorInfo constructor)
  126.         {
  127.             if (!(type is TypeBuilder) && !(type is TypeBuilderInstantiation))
  128.                 throw new ArgumentException(Environment.GetResourceString("Argument_MustBeTypeBuilder"));
  129.            
  130.             if (!constructor.DeclaringType.IsGenericTypeDefinition)
  131.                 throw new ArgumentException(Environment.GetResourceString("Argument_ConstructorNeedGenericDeclaringType"), "constructor");
  132.            
  133.             if (!(type is TypeBuilderInstantiation))
  134.                 throw new ArgumentException(Environment.GetResourceString("Argument_NeedNonGenericType"), "type");
  135.            
  136.             // TypeBuilder G<T> ==> TypeBuilderInstantiation G<T>
  137.             if (type is TypeBuilder && type.IsGenericTypeDefinition)
  138.                 type = type.MakeGenericType(type.GetGenericArguments());
  139.            
  140.             if (type.GetGenericTypeDefinition() != constructor.DeclaringType)
  141.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidConstructorDeclaringType"), "type");
  142.            
  143.             return ConstructorOnTypeBuilderInstantiation.GetConstructor(constructor, type as TypeBuilderInstantiation);
  144.         }
  145.         public static FieldInfo GetField(Type type, FieldInfo field)
  146.         {
  147.             if (!(type is TypeBuilder) && !(type is TypeBuilderInstantiation))
  148.                 throw new ArgumentException(Environment.GetResourceString("Argument_MustBeTypeBuilder"));
  149.            
  150.             if (!field.DeclaringType.IsGenericTypeDefinition)
  151.                 throw new ArgumentException(Environment.GetResourceString("Argument_FieldNeedGenericDeclaringType"), "field");
  152.            
  153.             if (!(type is TypeBuilderInstantiation))
  154.                 throw new ArgumentException(Environment.GetResourceString("Argument_NeedNonGenericType"), "type");
  155.            
  156.             // TypeBuilder G<T> ==> TypeBuilderInstantiation G<T>
  157.             if (type is TypeBuilder && type.IsGenericTypeDefinition)
  158.                 type = type.MakeGenericType(type.GetGenericArguments());
  159.            
  160.             if (type.GetGenericTypeDefinition() != field.DeclaringType)
  161.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFieldDeclaringType"), "type");
  162.            
  163.             return FieldOnTypeBuilderInstantiation.GetField(field, type as TypeBuilderInstantiation);
  164.         }
  165.         #endregion
  166.        
  167.         #region Public Const
  168.         public const int UnspecifiedTypeSize = 0;
  169.         #endregion
  170.        
  171.         #region Private Static FCalls
  172.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  173.         private static extern void InternalSetParentType(int tdTypeDef, int tkParent, Module module);
  174.        
  175.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  176.         private static extern void InternalAddInterfaceImpl(int tdTypeDef, int tkInterface, Module module);
  177.         #endregion
  178.        
  179.         #region Internal Static FCalls
  180.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  181.         static internal extern int InternalDefineMethod(int handle, string name, byte[] signature, int sigLength, MethodAttributes attributes, Module module);
  182.        
  183.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  184.         static internal extern int InternalDefineMethodSpec(int handle, byte[] signature, int sigLength, Module module);
  185.        
  186.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  187.         static internal extern int InternalDefineField(int handle, string name, byte[] signature, int sigLength, FieldAttributes attributes, Module module);
  188.        
  189.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  190.         static internal extern void InternalSetMethodIL(int methodHandle, bool isInitLocals, byte[] body, byte[] LocalSig, int sigLength, int maxStackSize, int numExceptions, __ExceptionInstance[] exceptions, int[] tokenFixups, int[] rvaFixups,
  191.         Module module);
  192.        
  193.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  194.         static internal extern void InternalCreateCustomAttribute(int tkAssociate, int tkConstructor, byte[] attr, Module module, bool toDisk, bool updateCompilerFlags);
  195.        
  196.         static internal void InternalCreateCustomAttribute(int tkAssociate, int tkConstructor, byte[] attr, Module module, bool toDisk)
  197.         {
  198.             byte[] localAttr = null;
  199.            
  200.             if (attr != null) {
  201.                 localAttr = new byte[attr.Length];
  202.                 Array.Copy(attr, localAttr, attr.Length);
  203.             }
  204.             TypeBuilder.InternalCreateCustomAttribute(tkAssociate, tkConstructor, localAttr, module, toDisk, false);
  205.         }
  206.        
  207.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  208.         static internal extern void InternalSetPInvokeData(Module module, string DllName, string name, int token, int linkType, int linkFlags);
  209.        
  210.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  211.         static internal extern int InternalDefineProperty(Module module, int handle, string name, int attributes, byte[] signature, int sigLength, int notifyChanging, int notifyChanged);
  212.        
  213.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  214.         static internal extern int InternalDefineEvent(Module module, int handle, string name, int attributes, int tkEventType);
  215.        
  216.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  217.         static internal extern void InternalDefineMethodSemantics(Module module, int tkAssociation, MethodSemanticsAttributes semantics, int tkMethod);
  218.        
  219.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  220.         static internal extern void InternalDefineMethodImpl(ModuleBuilder module, int tkType, int tkBody, int tkDecl);
  221.        
  222.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  223.         static internal extern void InternalSetMethodImpl(Module module, int tkMethod, MethodImplAttributes MethodImplAttributes);
  224.        
  225.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  226.         static internal extern int InternalSetParamInfo(Module module, int tkMethod, int iSequence, ParameterAttributes iParamAttributes, string strParamName);
  227.        
  228.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  229.         static internal extern int InternalGetTokenFromSig(Module module, byte[] signature, int sigLength);
  230.        
  231.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  232.         static internal extern void InternalSetFieldOffset(Module module, int fdToken, int iOffset);
  233.        
  234.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  235.         static internal extern void InternalSetClassLayout(Module module, int tdToken, PackingSize iPackingSize, int iTypeSize);
  236.        
  237.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  238.         static internal extern void InternalSetMarshalInfo(Module module, int tk, byte[] ubMarshal, int ubSize);
  239.        
  240.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  241.         static internal extern void InternalSetConstantValue(Module module, int tk, ref Variant var);
  242.        
  243.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  244.         static internal extern void InternalAddDeclarativeSecurity(Module module, int parent, SecurityAction action, byte[] blob);
  245.         #endregion
  246.        
  247.         #region Internal\Private Static Members
  248.         private static bool IsPublicComType(Type type)
  249.         {
  250.             // Internal Helper to determine if a type should be added to ComType table.
  251.             // A top level type should be added if it is Public.
  252.             // A nested type should be added if the top most enclosing type is Public
  253.             // and all the enclosing types are NestedPublic
  254.            
  255.             Type enclosingType = type.DeclaringType;
  256.             if (enclosingType != null) {
  257.                 if (IsPublicComType(enclosingType)) {
  258.                     if ((type.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic) {
  259.                         return true;
  260.                     }
  261.                 }
  262.             }
  263.             else {
  264.                 if ((type.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.Public) {
  265.                     return true;
  266.                 }
  267.             }
  268.            
  269.             return false;
  270.         }
  271.        
  272.         static internal bool IsTypeEqual(Type t1, Type t2)
  273.         {
  274.             // Maybe we are lucky that they are equal in the first place
  275.             if (t1 == t2)
  276.                 return true;
  277.             TypeBuilder tb1 = null;
  278.             TypeBuilder tb2 = null;
  279.             Type runtimeType1 = null;
  280.             Type runtimeType2 = null;
  281.            
  282.             // set up the runtimeType and TypeBuilder type corresponding to t1 and t2
  283.             if (t1 is TypeBuilder) {
  284.                 tb1 = (TypeBuilder)t1;
  285.                 // This will be null if it is not baked.
  286.                 runtimeType1 = tb1.m_runtimeType;
  287.             }
  288.             else {
  289.                 runtimeType1 = t1;
  290.             }
  291.            
  292.             if (t2 is TypeBuilder) {
  293.                 tb2 = (TypeBuilder)t2;
  294.                 // This will be null if it is not baked.
  295.                 runtimeType2 = tb2.m_runtimeType;
  296.             }
  297.             else {
  298.                 runtimeType2 = t2;
  299.             }
  300.            
  301.             // If the type builder view is eqaul then it is equal
  302.             if (tb1 != null && tb2 != null && tb1 == tb2)
  303.                 return true;
  304.            
  305.             // if the runtimetype view is eqaul than it is equal
  306.             if (runtimeType1 != null && runtimeType2 != null && runtimeType1 == runtimeType2)
  307.                 return true;
  308.            
  309.             return false;
  310.         }
  311.        
  312.         static internal void SetConstantValue(Module module, int tk, Type destType, object value)
  313.         {
  314.             // This is a helper function that is used by ParameterBuilder, PropertyBuilder,
  315.             // and FieldBuilder to validate a default value and save it in the meta-data.
  316.            
  317.             if (value == null) {
  318.                 if (destType.IsValueType)
  319.                     throw new ArgumentException(Environment.GetResourceString("Argument_ConstantNull"));
  320.             }
  321.             else {
  322.                 // client is going to set non-null constant value
  323.                 Type type = value.GetType();
  324.                
  325.                 // The default value on the enum typed field/parameter is the underlying type.
  326.                 if (destType.IsEnum == false) {
  327.                     if (destType != type)
  328.                         throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch"));
  329.                    
  330.                     switch (Type.GetTypeCode(type)) {
  331.                         case TypeCode.Boolean:
  332.                         case TypeCode.Char:
  333.                         case TypeCode.SByte:
  334.                         case TypeCode.Byte:
  335.                         case TypeCode.Int16:
  336.                         case TypeCode.UInt16:
  337.                         case TypeCode.Int32:
  338.                         case TypeCode.UInt32:
  339.                         case TypeCode.Int64:
  340.                         case TypeCode.UInt64:
  341.                         case TypeCode.Single:
  342.                         case TypeCode.Double:
  343.                         case TypeCode.Decimal:
  344.                         case TypeCode.String:
  345.                             break;
  346.                         default:
  347.                            
  348.                             {
  349.                                 if (type != typeof(System.DateTime))
  350.                                     throw new ArgumentException(Environment.GetResourceString("Argument_ConstantNotSupported"));
  351.                                 break;
  352.                             }
  353.                             break;
  354.                        
  355.                     }
  356.                 }
  357.                 else {
  358.                     // The constant value supplied should match the underlying type of the enum
  359.                     if (destType.UnderlyingSystemType != type)
  360.                         throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch"));
  361.                 }
  362.             }
  363.            
  364.             // pass the variant by reference to avoid woes with passing valuetypes into FCALLs
  365.             Variant var = new Variant(value);
  366.            
  367.             InternalSetConstantValue(module, tk, ref var);
  368.         }
  369.        
  370.         #endregion
  371.        
  372.         #region Private Data Members
  373.         internal ArrayList m_ca;
  374.         internal MethodBuilder m_currentMethod;
  375.         private TypeToken m_tdType;
  376.         private ModuleBuilder m_module;
  377.         internal string m_strName;
  378.         private string m_strNameSpace;
  379.         private string m_strFullQualName;
  380.         private Type m_typeParent;
  381.         private Type[] m_typeInterfaces;
  382.         internal TypeAttributes m_iAttr;
  383.         internal GenericParameterAttributes m_genParamAttributes;
  384.         internal ArrayList m_listMethods;
  385.         private int m_constructorCount;
  386.         private int m_iTypeSize;
  387.         private PackingSize m_iPackingSize;
  388.         private TypeBuilder m_DeclaringType;
  389.         private Type m_underlyingSystemType;
  390.         // set when user calls UnderlyingSystemType on TypeBuilder if TypeBuilder is an Enum
  391.         internal bool m_isHiddenGlobalType;
  392.         internal bool m_isHiddenType;
  393.         internal bool m_hasBeenCreated;
  394.         internal RuntimeType m_runtimeType;
  395.        
  396.         private int m_genParamPos;
  397.         private GenericTypeParameterBuilder[] m_inst;
  398.         private bool m_bIsGenParam;
  399.         private bool m_bIsGenTypeDef;
  400.         private MethodBuilder m_declMeth;
  401.         private TypeBuilder m_genTypeDef;
  402.         #endregion
  403.        
  404.         #region Constructor
  405.         private TypeBuilder(TypeBuilder genTypeDef, GenericTypeParameterBuilder[] inst)
  406.         {
  407.             m_genTypeDef = genTypeDef;
  408.             m_DeclaringType = genTypeDef.m_DeclaringType;
  409.             m_typeParent = genTypeDef.m_typeParent;
  410.             m_runtimeType = genTypeDef.m_runtimeType;
  411.             m_tdType = genTypeDef.m_tdType;
  412.             m_strName = genTypeDef.m_strName;
  413.             m_bIsGenParam = false;
  414.             m_bIsGenTypeDef = false;
  415.             m_module = genTypeDef.m_module;
  416.             m_inst = inst;
  417.             m_hasBeenCreated = true;
  418.         }
  419.        
  420.         internal TypeBuilder(string szName, int genParamPos, MethodBuilder declMeth)
  421.         {
  422.             m_declMeth = declMeth;
  423.             m_DeclaringType = (TypeBuilder)m_declMeth.DeclaringType;
  424.             m_module = (ModuleBuilder)declMeth.Module;
  425.             InitAsGenericParam(szName, genParamPos);
  426.         }
  427.        
  428.         private TypeBuilder(string szName, int genParamPos, TypeBuilder declType)
  429.         {
  430.             m_DeclaringType = declType;
  431.             m_module = (ModuleBuilder)declType.Module;
  432.             InitAsGenericParam(szName, genParamPos);
  433.         }
  434.        
  435.         private void InitAsGenericParam(string szName, int genParamPos)
  436.         {
  437.             m_strName = szName;
  438.             m_genParamPos = genParamPos;
  439.             m_bIsGenParam = true;
  440.             m_bIsGenTypeDef = false;
  441.             m_typeInterfaces = new Type[0];
  442.         }
  443.        
  444.         internal TypeBuilder(string name, TypeAttributes attr, Type parent, Module module, PackingSize iPackingSize, int iTypeSize, TypeBuilder enclosingType)
  445.         {
  446.             Init(name, attr, parent, null, module, iPackingSize, iTypeSize, enclosingType);
  447.         }
  448.        
  449.         internal TypeBuilder(string name, TypeAttributes attr, Type parent, Type[] interfaces, Module module, PackingSize iPackingSize, TypeBuilder enclosingType)
  450.         {
  451.             Init(name, attr, parent, interfaces, module, iPackingSize, UnspecifiedTypeSize, enclosingType);
  452.         }
  453.        
  454.         internal TypeBuilder(ModuleBuilder module)
  455.         {
  456.             m_tdType = new TypeToken(SignatureHelper.mdtTypeDef);
  457.             m_isHiddenGlobalType = true;
  458.             m_module = (ModuleBuilder)module;
  459.             m_listMethods = new ArrayList();
  460.         }
  461.        
  462.         private void Init(string fullname, TypeAttributes attr, Type parent, Type[] interfaces, Module module, PackingSize iPackingSize, int iTypeSize, TypeBuilder enclosingType)
  463.         {
  464.             int i;
  465.             int[] interfaceTokens;
  466.             m_bIsGenTypeDef = false;
  467.             interfaceTokens = null;
  468.             m_bIsGenParam = false;
  469.             m_hasBeenCreated = false;
  470.             m_runtimeType = null;
  471.             m_isHiddenGlobalType = false;
  472.             m_isHiddenType = false;
  473.             m_module = (ModuleBuilder)module;
  474.             m_DeclaringType = enclosingType;
  475.             Assembly containingAssem = m_module.Assembly;
  476.             m_underlyingSystemType = null;
  477.             // used when client use TypeBuilder to define Enum
  478.             if (fullname == null)
  479.                 throw new ArgumentNullException("fullname");
  480.            
  481.             if (fullname.Length == 0)
  482.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "fullname");
  483.            
  484.             if (fullname[0] == '\0')
  485.                 throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "fullname");
  486.            
  487.            
  488.             if (fullname.Length > 1023)
  489.                 throw new ArgumentException(Environment.GetResourceString("Argument_TypeNameTooLong"), "fullname");
  490.            
  491.             // cannot have two types within the same assembly of the same name
  492.             containingAssem.m_assemblyData.CheckTypeNameConflict(fullname, enclosingType);
  493.            
  494.             if (enclosingType != null) {
  495.                 // Nested Type should have nested attribute set.
  496.                 // If we are renumbering TypeAttributes' bit, we need to change the logic here.
  497.                 if (((attr & TypeAttributes.VisibilityMask) == TypeAttributes.Public) || ((attr & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic))
  498.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadNestedTypeFlags"), "attr");
  499.             }
  500.            
  501.             if (interfaces != null) {
  502.                 for (i = 0; i < interfaces.Length; i++) {
  503.                     if (interfaces[i] == null) {
  504.                         // cannot contain null in the interface list
  505.                         throw new ArgumentNullException("interfaces");
  506.                     }
  507.                 }
  508.                 interfaceTokens = new int[interfaces.Length];
  509.                 for (i = 0; i < interfaces.Length; i++) {
  510.                     interfaceTokens[i] = m_module.GetTypeToken(interfaces[i]).Token;
  511.                 }
  512.             }
  513.            
  514.             int iLast = fullname.LastIndexOf('.');
  515.             if (iLast == -1 || iLast == 0) {
  516.                 // no name space
  517.                 m_strNameSpace = String.Empty;
  518.                 m_strName = fullname;
  519.             }
  520.             else {
  521.                 // split the name space
  522.                 m_strNameSpace = fullname.Substring(0, iLast);
  523.                 m_strName = fullname.Substring(iLast + 1);
  524.             }
  525.            
  526.             VerifyTypeAttributes(attr);
  527.            
  528.             m_iAttr = attr;
  529.            
  530.             SetParent(parent);
  531.            
  532.             m_listMethods = new ArrayList();
  533.            
  534.             SetInterfaces(interfaces);
  535.            
  536.             m_constructorCount = 0;
  537.            
  538.             int tkParent = 0;
  539.             if (m_typeParent != null)
  540.                 tkParent = m_module.GetTypeToken(m_typeParent).Token;
  541.            
  542.             int tkEnclosingType = 0;
  543.             if (enclosingType != null) {
  544.                 tkEnclosingType = enclosingType.m_tdType.Token;
  545.             }
  546.            
  547.             m_tdType = new TypeToken(InternalDefineClass(fullname, tkParent, interfaceTokens, m_iAttr, m_module, Guid.Empty, tkEnclosingType, 0));
  548.            
  549.             m_iPackingSize = iPackingSize;
  550.             m_iTypeSize = iTypeSize;
  551.             if ((m_iPackingSize != 0) || (m_iTypeSize != 0))
  552.                 InternalSetClassLayout(Module, m_tdType.Token, m_iPackingSize, m_iTypeSize);
  553.            
  554.             // If the type is public and it is contained in a assemblyBuilder,
  555.             // update the public COMType list.
  556.             if (IsPublicComType(this)) {
  557.                 if (containingAssem is AssemblyBuilder) {
  558.                     AssemblyBuilder assemBuilder = (AssemblyBuilder)containingAssem;
  559.                     if (assemBuilder.IsPersistable() && m_module.IsTransient() == false) {
  560.                         assemBuilder.m_assemblyData.AddPublicComType(this);
  561.                     }
  562.                 }
  563.             }
  564.         }
  565.        
  566.         #endregion
  567.        
  568.         #region Private Members
  569.         private MethodBuilder DefinePInvokeMethodHelper(string name, string dllName, string importName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers,
  570.         Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet)
  571.         {
  572.             CheckContext(returnType);
  573.             CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
  574.             CheckContext(parameterTypeRequiredCustomModifiers);
  575.             CheckContext(parameterTypeOptionalCustomModifiers);
  576.            
  577.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  578.                 lock (Module.Assembly.m_assemblyData) {
  579.                     return DefinePInvokeMethodHelperNoLock(name, dllName, importName, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers,
  580.                     parameterTypeOptionalCustomModifiers, nativeCallConv, nativeCharSet);
  581.                 }
  582.             }
  583.             else {
  584.                 return DefinePInvokeMethodHelperNoLock(name, dllName, importName, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers,
  585.                 parameterTypeOptionalCustomModifiers, nativeCallConv, nativeCharSet);
  586.             }
  587.         }
  588.        
  589.         private MethodBuilder DefinePInvokeMethodHelperNoLock(string name, string dllName, string importName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers,
  590.         Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet)
  591.         {
  592.            
  593.             ThrowIfCreated();
  594.            
  595.             if (name == null)
  596.                 throw new ArgumentNullException("name");
  597.            
  598.             if (name.Length == 0)
  599.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  600.            
  601.             if (dllName == null)
  602.                 throw new ArgumentNullException("dllName");
  603.            
  604.             if (dllName.Length == 0)
  605.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "dllName");
  606.            
  607.             if (importName == null)
  608.                 throw new ArgumentNullException("importName");
  609.            
  610.             if (importName.Length == 0)
  611.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "importName");
  612.            
  613.             if ((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface)
  614.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadPInvokeOnInterface"));
  615.            
  616.             if ((attributes & MethodAttributes.Abstract) != 0)
  617.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadPInvokeMethod"));
  618.            
  619.            
  620.            
  621.            
  622.            
  623.             attributes = attributes | MethodAttributes.PinvokeImpl;
  624.             MethodBuilder method = new MethodBuilder(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, m_module,
  625.             this, false);
  626.            
  627.             int sigLength;
  628.             byte[] sigBytes = method.GetMethodSignature().InternalGetSignature(out sigLength);
  629.            
  630.             if (m_listMethods.Contains(method)) {
  631.                 throw new ArgumentException(Environment.GetResourceString("Argument_MethodRedefined"));
  632.             }
  633.             m_listMethods.Add(method);
  634.            
  635.             MethodToken token = method.GetToken();
  636.            
  637.             int linkFlags = 0;
  638.             switch (nativeCallConv) {
  639.                 case CallingConvention.Winapi:
  640.                     linkFlags = (int)PInvokeMap.CallConvWinapi;
  641.                     break;
  642.                 case CallingConvention.Cdecl:
  643.                     linkFlags = (int)PInvokeMap.CallConvCdecl;
  644.                     break;
  645.                 case CallingConvention.StdCall:
  646.                     linkFlags = (int)PInvokeMap.CallConvStdcall;
  647.                     break;
  648.                 case CallingConvention.ThisCall:
  649.                     linkFlags = (int)PInvokeMap.CallConvThiscall;
  650.                     break;
  651.                 case CallingConvention.FastCall:
  652.                     linkFlags = (int)PInvokeMap.CallConvFastcall;
  653.                     break;
  654.             }
  655.             switch (nativeCharSet) {
  656.                 case CharSet.None:
  657.                     linkFlags |= (int)PInvokeMap.CharSetNotSpec;
  658.                     break;
  659.                 case CharSet.Ansi:
  660.                     linkFlags |= (int)PInvokeMap.CharSetAnsi;
  661.                     break;
  662.                 case CharSet.Unicode:
  663.                     linkFlags |= (int)PInvokeMap.CharSetUnicode;
  664.                     break;
  665.                 case CharSet.Auto:
  666.                     linkFlags |= (int)PInvokeMap.CharSetAuto;
  667.                     break;
  668.             }
  669.            
  670.             InternalSetPInvokeData(m_module, dllName, importName, token.Token, 0, linkFlags);
  671.             method.SetToken(token);
  672.            
  673.             return method;
  674.         }
  675.        
  676.         private FieldBuilder DefineDataHelper(string name, byte[] data, int size, FieldAttributes attributes)
  677.         {
  678.             string strValueClassName;
  679.             TypeBuilder valueClassType;
  680.             FieldBuilder fdBuilder;
  681.             TypeAttributes typeAttributes;
  682.            
  683.             if (name == null)
  684.                 throw new ArgumentNullException("name");
  685.            
  686.             if (name.Length == 0)
  687.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  688.            
  689.             if (size <= 0 || size >= 4128768)
  690.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadSizeForData"));
  691.            
  692.             ThrowIfCreated();
  693.            
  694.             // form the value class name
  695.             strValueClassName = ModuleBuilderData.MULTI_BYTE_VALUE_CLASS + size;
  696.            
  697.             // Is this already defined in this module?
  698.             Type temp = m_module.FindTypeBuilderWithName(strValueClassName, false);
  699.             valueClassType = temp as TypeBuilder;
  700.            
  701.             if (valueClassType == null) {
  702.                 typeAttributes = TypeAttributes.Public | TypeAttributes.ExplicitLayout | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.AnsiClass;
  703.                
  704.                 // Define the backing value class
  705.                 valueClassType = m_module.DefineType(strValueClassName, typeAttributes, typeof(System.ValueType), PackingSize.Size1, size);
  706.                 valueClassType.m_isHiddenType = true;
  707.                 valueClassType.CreateType();
  708.             }
  709.            
  710.             fdBuilder = DefineField(name, valueClassType, (attributes | FieldAttributes.Static));
  711.            
  712.             // now we need to set the RVA
  713.             fdBuilder.SetData(data, size);
  714.             return fdBuilder;
  715.         }
  716.        
  717.         private void VerifyTypeAttributes(TypeAttributes attr)
  718.         {
  719.            
  720.            
  721.            
  722.             // if (((attr & TypeAttributes.Sealed) != 0) &&((attr & TypeAttributes.Abstract) != 0))
  723.             // {
  724.             // throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeAttrAbstractNFinal"));
  725.             // }
  726.            
  727.             // Verify attr consistency for Nesting or otherwise.
  728.             if (DeclaringType == null) {
  729.                 // Not a nested class.
  730.                 if (((attr & TypeAttributes.VisibilityMask) != TypeAttributes.NotPublic) && ((attr & TypeAttributes.VisibilityMask) != TypeAttributes.Public)) {
  731.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeAttrNestedVisibilityOnNonNestedType"));
  732.                 }
  733.             }
  734.             else {
  735.                 // Nested class.
  736.                 if (((attr & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic) || ((attr & TypeAttributes.VisibilityMask) == TypeAttributes.Public)) {
  737.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeAttrNonNestedVisibilityNestedType"));
  738.                 }
  739.             }
  740.            
  741.             // Verify that the layout mask is valid.
  742.             if (((attr & TypeAttributes.LayoutMask) != TypeAttributes.AutoLayout) && ((attr & TypeAttributes.LayoutMask) != TypeAttributes.SequentialLayout) && ((attr & TypeAttributes.LayoutMask) != TypeAttributes.ExplicitLayout)) {
  743.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeAttrInvalidLayout"));
  744.             }
  745.            
  746.             // Check if the user attempted to set any reserved bits.
  747.             if ((attr & TypeAttributes.ReservedMask) != 0) {
  748.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeAttrReservedBitsSet"));
  749.             }
  750.         }
  751.        
  752.         public bool IsCreated()
  753.         {
  754.             return m_hasBeenCreated;
  755.         }
  756.        
  757.         #endregion
  758.        
  759.         #region FCalls
  760.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  761.         private extern int InternalDefineClass(string fullname, int tkParent, int[] interfaceTokens, TypeAttributes attr, Module module, Guid guid, int tkEnclosingType, int tkTypeDef);
  762.        
  763.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  764.         private extern int InternalDefineGenParam(string name, int tkParent, int position, int attributes, int[] interfaceTokens, Module module, int tkTypeDef);
  765.        
  766.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  767.         private extern Type TermCreateClass(int handle, Module module);
  768.         #endregion
  769.        
  770.         #region Internal Methods
  771.         internal void ThrowIfCreated()
  772.         {
  773.             if (IsCreated())
  774.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_TypeHasBeenCreated"));
  775.         }
  776.        
  777.         #endregion
  778.        
  779.         #region Object Overrides
  780.         public override string ToString()
  781.         {
  782.             return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.ToString);
  783.         }
  784.        
  785.         #endregion
  786.        
  787.         #region MemberInfo Overrides
  788.         public override Type DeclaringType {
  789.             get { return m_DeclaringType; }
  790.         }
  791.        
  792.         public override Type ReflectedType {
  793.             // Return the class that was used to obtain this field.
  794.            
  795.             get { return m_DeclaringType; }
  796.         }
  797.        
  798.         public override string Name {
  799.             get { return m_strName; }
  800.         }
  801.        
  802.         public override Module Module {
  803.             get { return m_module; }
  804.         }
  805.        
  806.         internal override int MetadataTokenInternal {
  807.             get { return m_tdType.Token; }
  808.         }
  809.        
  810.         #endregion
  811.        
  812.         #region Type Overrides
  813.         public override Guid GUID {
  814.             get {
  815.                 if (m_runtimeType == null)
  816.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  817.                
  818.                 return m_runtimeType.GUID;
  819.             }
  820.         }
  821.        
  822.         public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
  823.         {
  824.             if (m_runtimeType == null)
  825.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  826.            
  827.             return m_runtimeType.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
  828.         }
  829.        
  830.         public override Assembly Assembly {
  831.             get { return m_module.Assembly; }
  832.         }
  833.        
  834.         public override RuntimeTypeHandle TypeHandle {
  835.            
  836.             get {
  837.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  838.             }
  839.         }
  840.        
  841.         public override string FullName {
  842.             get {
  843.                 if (m_strFullQualName == null)
  844.                     m_strFullQualName = TypeNameBuilder.ToString(this, TypeNameBuilder.Format.FullName);
  845.                
  846.                 return m_strFullQualName;
  847.             }
  848.         }
  849.        
  850.         public override string Namespace {
  851.             get { return m_strNameSpace; }
  852.         }
  853.        
  854.         public override string AssemblyQualifiedName {
  855.             get { return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.AssemblyQualifiedName); }
  856.         }
  857.        
  858.         public override Type BaseType {
  859.             get { return m_typeParent; }
  860.         }
  861.        
  862.         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  863.         {
  864.             if (m_runtimeType == null)
  865.                
  866.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  867.            
  868.             return m_runtimeType.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
  869.         }
  870.        
  871.         [System.Runtime.InteropServices.ComVisible(true)]
  872.         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
  873.         {
  874.             if (m_runtimeType == null)
  875.                
  876.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  877.            
  878.             return m_runtimeType.GetConstructors(bindingAttr);
  879.         }
  880.        
  881.         protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  882.         {
  883.             if (m_runtimeType == null)
  884.                
  885.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  886.            
  887.             if (types == null) {
  888.                 return m_runtimeType.GetMethod(name, bindingAttr);
  889.             }
  890.             else {
  891.                 return m_runtimeType.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
  892.             }
  893.         }
  894.        
  895.         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
  896.         {
  897.             if (m_runtimeType == null)
  898.                
  899.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  900.            
  901.             return m_runtimeType.GetMethods(bindingAttr);
  902.         }
  903.        
  904.         public override FieldInfo GetField(string name, BindingFlags bindingAttr)
  905.         {
  906.             if (m_runtimeType == null)
  907.                
  908.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  909.            
  910.             return m_runtimeType.GetField(name, bindingAttr);
  911.         }
  912.        
  913.         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
  914.         {
  915.             if (m_runtimeType == null)
  916.                
  917.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  918.            
  919.             return m_runtimeType.GetFields(bindingAttr);
  920.         }
  921.        
  922.         public override Type GetInterface(string name, bool ignoreCase)
  923.         {
  924.             if (m_runtimeType == null)
  925.                
  926.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  927.            
  928.             return m_runtimeType.GetInterface(name, ignoreCase);
  929.         }
  930.        
  931.         public override Type[] GetInterfaces()
  932.         {
  933.             if (m_runtimeType != null) {
  934.                 return m_runtimeType.GetInterfaces();
  935.             }
  936.            
  937.             if (m_typeInterfaces == null) {
  938.                 return new Type[0];
  939.             }
  940.            
  941.             Type[] interfaces = new Type[m_typeInterfaces.Length];
  942.             Array.Copy(m_typeInterfaces, interfaces, m_typeInterfaces.Length);
  943.             return interfaces;
  944.         }
  945.        
  946.         public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
  947.         {
  948.             if (m_runtimeType == null)
  949.                
  950.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  951.            
  952.             return m_runtimeType.GetEvent(name, bindingAttr);
  953.         }
  954.        
  955.         public override EventInfo[] GetEvents()
  956.         {
  957.             if (m_runtimeType == null)
  958.                
  959.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  960.            
  961.             return m_runtimeType.GetEvents();
  962.         }
  963.        
  964.         protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  965.         {
  966.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  967.         }
  968.        
  969.         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
  970.         {
  971.             if (m_runtimeType == null)
  972.                
  973.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  974.            
  975.             return m_runtimeType.GetProperties(bindingAttr);
  976.         }
  977.        
  978.         public override Type[] GetNestedTypes(BindingFlags bindingAttr)
  979.         {
  980.             if (m_runtimeType == null)
  981.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  982.            
  983.             return m_runtimeType.GetNestedTypes(bindingAttr);
  984.         }
  985.        
  986.         public override Type GetNestedType(string name, BindingFlags bindingAttr)
  987.         {
  988.             if (m_runtimeType == null)
  989.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  990.            
  991.             return m_runtimeType.GetNestedType(name, bindingAttr);
  992.         }
  993.        
  994.         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
  995.         {
  996.             if (m_runtimeType == null)
  997.                
  998.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  999.            
  1000.             return m_runtimeType.GetMember(name, type, bindingAttr);
  1001.         }
  1002.        
  1003.         [System.Runtime.InteropServices.ComVisible(true)]
  1004.         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
  1005.         {
  1006.             if (m_runtimeType == null)
  1007.                
  1008.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1009.            
  1010.             return m_runtimeType.GetInterfaceMap(interfaceType);
  1011.         }
  1012.        
  1013.         public override EventInfo[] GetEvents(BindingFlags bindingAttr)
  1014.         {
  1015.             if (m_runtimeType == null)
  1016.                
  1017.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1018.            
  1019.             return m_runtimeType.GetEvents(bindingAttr);
  1020.         }
  1021.        
  1022.         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
  1023.         {
  1024.             if (m_runtimeType == null)
  1025.                
  1026.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1027.            
  1028.             return m_runtimeType.GetMembers(bindingAttr);
  1029.         }
  1030.        
  1031.         public override bool IsAssignableFrom(Type c)
  1032.         {
  1033.             if (TypeBuilder.IsTypeEqual(c, this))
  1034.                 return true;
  1035.            
  1036.             RuntimeType fromRuntimeType = c as RuntimeType;
  1037.             TypeBuilder fromTypeBuilder = c as TypeBuilder;
  1038.            
  1039.             if (fromTypeBuilder != null && fromTypeBuilder.m_runtimeType != null)
  1040.                 fromRuntimeType = (RuntimeType)fromTypeBuilder.m_runtimeType;
  1041.            
  1042.             if (fromRuntimeType != null) {
  1043.                 // fromType is baked. So if this type is not baked, it cannot be assignable to!
  1044.                 if (m_runtimeType == null)
  1045.                     return false;
  1046.                
  1047.                 // since toType is also baked, delegate to the base
  1048.                 return ((RuntimeType)m_runtimeType).IsAssignableFrom(fromRuntimeType);
  1049.             }
  1050.            
  1051.             // So if c is not a runtimeType nor TypeBuilder. We don't know how to deal with it.
  1052.             // return false then.
  1053.             if (fromTypeBuilder == null)
  1054.                 return false;
  1055.            
  1056.             // If fromTypeBuilder is a subclass of this class, then c can be cast to this type.
  1057.             if (fromTypeBuilder.IsSubclassOf(this))
  1058.                 return true;
  1059.            
  1060.             if (this.IsInterface == false)
  1061.                 return false;
  1062.            
  1063.             // now is This type a base type on one of the interface impl?
  1064.             Type[] interfaces = fromTypeBuilder.GetInterfaces();
  1065.             for (int i = 0; i < interfaces.Length; i++) {
  1066.                 if (TypeBuilder.IsTypeEqual(interfaces[i], this))
  1067.                     return true;
  1068.                
  1069.                 if (interfaces[i].IsSubclassOf(this))
  1070.                     return true;
  1071.             }
  1072.             return false;
  1073.         }
  1074.        
  1075.         protected override TypeAttributes GetAttributeFlagsImpl()
  1076.         {
  1077.             return m_iAttr;
  1078.         }
  1079.        
  1080.         protected override bool IsArrayImpl()
  1081.         {
  1082.             return false;
  1083.         }
  1084.         protected override bool IsByRefImpl()
  1085.         {
  1086.             return false;
  1087.         }
  1088.         protected override bool IsPointerImpl()
  1089.         {
  1090.             return false;
  1091.         }
  1092.         protected override bool IsPrimitiveImpl()
  1093.         {
  1094.             return false;
  1095.         }
  1096.        
  1097.         protected override bool IsCOMObjectImpl()
  1098.         {
  1099.             return ((GetAttributeFlagsImpl() & TypeAttributes.Import) != 0) ? true : false;
  1100.         }
  1101.        
  1102.         public override Type GetElementType()
  1103.         {
  1104.            
  1105.             // You will never have to deal with a TypeBuilder if you are just referring to arrays.
  1106.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1107.         }
  1108.        
  1109.         protected override bool HasElementTypeImpl()
  1110.         {
  1111.             return false;
  1112.         }
  1113.        
  1114.         [System.Runtime.InteropServices.ComVisible(true)]
  1115.         public override bool IsSubclassOf(Type c)
  1116.         {
  1117.             Type p = this;
  1118.            
  1119.             if (TypeBuilder.IsTypeEqual(p, c))
  1120.                 return false;
  1121.            
  1122.             p = p.BaseType;
  1123.            
  1124.             while (p != null) {
  1125.                 if (TypeBuilder.IsTypeEqual(p, c))
  1126.                     return true;
  1127.                
  1128.                 p = p.BaseType;
  1129.             }
  1130.            
  1131.             return false;
  1132.         }
  1133.        
  1134.         public override Type UnderlyingSystemType {
  1135.             get {
  1136.                 if (m_runtimeType != null)
  1137.                     return m_runtimeType.UnderlyingSystemType;
  1138.                
  1139.                 if (!IsEnum)
  1140.                     return this;
  1141.                
  1142.                 if (m_underlyingSystemType == null)
  1143.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NoUnderlyingTypeOnEnum"));
  1144.                
  1145.                 return m_underlyingSystemType;
  1146.             }
  1147.         }
  1148.        
  1149.         public override Type MakePointerType()
  1150.         {
  1151.             return SymbolType.FormCompoundType("*".ToCharArray(), this, 0);
  1152.         }
  1153.        
  1154.         public override Type MakeByRefType()
  1155.         {
  1156.             return SymbolType.FormCompoundType("&".ToCharArray(), this, 0);
  1157.         }
  1158.        
  1159.         public override Type MakeArrayType()
  1160.         {
  1161.             return SymbolType.FormCompoundType("[]".ToCharArray(), this, 0);
  1162.         }
  1163.        
  1164.         public override Type MakeArrayType(int rank)
  1165.         {
  1166.             if (rank <= 0)
  1167.                 throw new IndexOutOfRangeException();
  1168.            
  1169.             string szrank = "";
  1170.             if (rank == 1) {
  1171.                 szrank = "*";
  1172.             }
  1173.             else {
  1174.                 for (int i = 1; i < rank; i++)
  1175.                     szrank += ",";
  1176.             }
  1177.            
  1178.             string s = String.Format(CultureInfo.InvariantCulture, "[{0}]", szrank);
  1179.             // [,,]
  1180.             return SymbolType.FormCompoundType((s).ToCharArray(), this, 0);
  1181.         }
  1182.        
  1183.         #endregion
  1184.        
  1185.         #region ICustomAttributeProvider Implementation
  1186.         public override object[] GetCustomAttributes(bool inherit)
  1187.         {
  1188.             if (m_runtimeType == null)
  1189.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1190.            
  1191.             return CustomAttribute.GetCustomAttributes(m_runtimeType, typeof(object) as RuntimeType, inherit);
  1192.         }
  1193.        
  1194.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  1195.         {
  1196.             if (m_runtimeType == null)
  1197.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1198.            
  1199.             if (attributeType == null)
  1200.                 throw new ArgumentNullException("attributeType");
  1201.            
  1202.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  1203.            
  1204.             if (attributeRuntimeType == null)
  1205.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  1206.            
  1207.             return CustomAttribute.GetCustomAttributes(m_runtimeType, attributeRuntimeType, inherit);
  1208.         }
  1209.        
  1210.         public override bool IsDefined(Type attributeType, bool inherit)
  1211.         {
  1212.             if (m_runtimeType == null)
  1213.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1214.            
  1215.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  1216.            
  1217.             if (attributeRuntimeType == null)
  1218.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "caType");
  1219.            
  1220.             return CustomAttribute.IsDefined(m_runtimeType, attributeRuntimeType, inherit);
  1221.         }
  1222.        
  1223.         #endregion
  1224.        
  1225.         #region Public Member
  1226.        
  1227.         #region DefineType
  1228.         internal void ThrowIfGeneric()
  1229.         {
  1230.             if (IsGenericType && !IsGenericTypeDefinition)
  1231.                 throw new InvalidOperationException();
  1232.         }
  1233.        
  1234.         public override GenericParameterAttributes GenericParameterAttributes {
  1235.             get { return m_genParamAttributes; }
  1236.         }
  1237.        
  1238.         internal void SetInterfaces(params Type[] interfaces)
  1239.         {
  1240.             ThrowIfCreated();
  1241.            
  1242.             if (interfaces == null) {
  1243.                 m_typeInterfaces = new Type[0];
  1244.             }
  1245.             else {
  1246.                 m_typeInterfaces = new Type[interfaces.Length];
  1247.                 Array.Copy(interfaces, m_typeInterfaces, interfaces.Length);
  1248.             }
  1249.         }
  1250.        
  1251.        
  1252.         public GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names)
  1253.         {
  1254.             if (m_inst != null)
  1255.                 throw new InvalidOperationException();
  1256.            
  1257.             if (names == null)
  1258.                 throw new ArgumentNullException("names");
  1259.            
  1260.             for (int i = 0; i < names.Length; i++)
  1261.                 if (names[i] == null)
  1262.                     throw new ArgumentNullException("names");
  1263.            
  1264.             if (names.Length == 0)
  1265.                 throw new ArgumentException();
  1266.            
  1267.             m_bIsGenTypeDef = true;
  1268.             m_inst = new GenericTypeParameterBuilder[names.Length];
  1269.             for (int i = 0; i < names.Length; i++)
  1270.                 m_inst[i] = new GenericTypeParameterBuilder(new TypeBuilder(names[i], i, this));
  1271.            
  1272.             return m_inst;
  1273.         }
  1274.        
  1275.        
  1276.         public override Type MakeGenericType(params Type[] typeArguments)
  1277.         {
  1278.             CheckContext(typeArguments);
  1279.            
  1280.             if (!IsGenericTypeDefinition)
  1281.                 throw new InvalidOperationException();
  1282.            
  1283.             return new TypeBuilderInstantiation(this, typeArguments);
  1284.         }
  1285.        
  1286.         public override Type[] GetGenericArguments()
  1287.         {
  1288.             return m_inst;
  1289.         }
  1290.         public override bool IsGenericTypeDefinition {
  1291.             get { return m_bIsGenTypeDef; }
  1292.         }
  1293.         public override bool IsGenericType {
  1294.             get { return m_inst != null; }
  1295.         }
  1296.         public override bool IsGenericParameter {
  1297.             get { return m_bIsGenParam; }
  1298.         }
  1299.         public override int GenericParameterPosition {
  1300.             get { return m_genParamPos; }
  1301.         }
  1302.         public override MethodBase DeclaringMethod {
  1303.             get { return m_declMeth; }
  1304.         }
  1305.         public override Type GetGenericTypeDefinition()
  1306.         {
  1307.             if (IsGenericTypeDefinition)
  1308.                 return this;
  1309.             if (m_genTypeDef == null)
  1310.                 throw new InvalidOperationException();
  1311.             return m_genTypeDef;
  1312.         }
  1313.         #endregion
  1314.        
  1315.         #region Define Method
  1316.         public void DefineMethodOverride(MethodInfo methodInfoBody, MethodInfo methodInfoDeclaration)
  1317.         {
  1318.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1319.                 lock (Module.Assembly.m_assemblyData) {
  1320.                     DefineMethodOverrideNoLock(methodInfoBody, methodInfoDeclaration);
  1321.                 }
  1322.             }
  1323.             else {
  1324.                 DefineMethodOverrideNoLock(methodInfoBody, methodInfoDeclaration);
  1325.             }
  1326.         }
  1327.        
  1328.         private void DefineMethodOverrideNoLock(MethodInfo methodInfoBody, MethodInfo methodInfoDeclaration)
  1329.         {
  1330.             ThrowIfGeneric();
  1331.             ThrowIfCreated();
  1332.            
  1333.             if (methodInfoBody == null)
  1334.                 throw new ArgumentNullException("methodInfoBody");
  1335.            
  1336.             if (methodInfoDeclaration == null)
  1337.                 throw new ArgumentNullException("methodInfoDeclaration");
  1338.            
  1339.             if (methodInfoBody.DeclaringType != this)
  1340.                 // Loader restriction: body method has to be from this class
  1341.                 throw new ArgumentException(Environment.GetResourceString("ArgumentException_BadMethodImplBody"));
  1342.            
  1343.             MethodToken tkBody;
  1344.             MethodToken tkDecl;
  1345.            
  1346.             tkBody = m_module.GetMethodToken(methodInfoBody);
  1347.             tkDecl = m_module.GetMethodToken(methodInfoDeclaration);
  1348.            
  1349.             InternalDefineMethodImpl(m_module, m_tdType.Token, tkBody.Token, tkDecl.Token);
  1350.         }
  1351.        
  1352.         public MethodBuilder DefineMethod(string name, MethodAttributes attributes, Type returnType, Type[] parameterTypes)
  1353.         {
  1354.             return DefineMethod(name, attributes, CallingConventions.Standard, returnType, parameterTypes);
  1355.         }
  1356.        
  1357.         public MethodBuilder DefineMethod(string name, MethodAttributes attributes)
  1358.         {
  1359.             return DefineMethod(name, attributes, CallingConventions.Standard, null, null);
  1360.         }
  1361.        
  1362.         public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention)
  1363.         {
  1364.             return DefineMethod(name, attributes, callingConvention, null, null);
  1365.         }
  1366.        
  1367.         public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
  1368.         {
  1369.             return DefineMethod(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
  1370.         }
  1371.        
  1372.         public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
  1373.         {
  1374.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1375.                 lock (Module.Assembly.m_assemblyData) {
  1376.                     return DefineMethodNoLock(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
  1377.                 }
  1378.             }
  1379.             else {
  1380.                 return DefineMethodNoLock(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
  1381.             }
  1382.         }
  1383.        
  1384.         private MethodBuilder DefineMethodNoLock(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
  1385.         {
  1386.             CheckContext(returnType);
  1387.             CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
  1388.             CheckContext(parameterTypeRequiredCustomModifiers);
  1389.             CheckContext(parameterTypeOptionalCustomModifiers);
  1390.            
  1391.             if (name == null)
  1392.                 throw new ArgumentNullException("name");
  1393.            
  1394.             if (name.Length == 0)
  1395.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  1396.            
  1397.             if (parameterTypes != null) {
  1398.                 if (parameterTypeOptionalCustomModifiers != null && parameterTypeOptionalCustomModifiers.Length != parameterTypes.Length)
  1399.                     throw new ArgumentException(Environment.GetResourceString("Argument_MismatchedArrays", "parameterTypeOptionalCustomModifiers", "parameterTypes"));
  1400.                
  1401.                 if (parameterTypeRequiredCustomModifiers != null && parameterTypeRequiredCustomModifiers.Length != parameterTypes.Length)
  1402.                     throw new ArgumentException(Environment.GetResourceString("Argument_MismatchedArrays", "parameterTypeRequiredCustomModifiers", "parameterTypes"));
  1403.             }
  1404.            
  1405.             ThrowIfGeneric();
  1406.             ThrowIfCreated();
  1407.            
  1408.             if (!m_isHiddenGlobalType) {
  1409.                 if (((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface) && (attributes & MethodAttributes.Abstract) == 0 && (attributes & MethodAttributes.Static) == 0)
  1410.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadAttributeOnInterfaceMethod"));
  1411.             }
  1412.            
  1413.             // pass in Method attributes
  1414.             MethodBuilder method = new MethodBuilder(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, m_module,
  1415.             this, false);
  1416.            
  1417.             if (!m_isHiddenGlobalType) {
  1418.                 //If this method is declared to be a constructor, increment our constructor count.
  1419.                 if ((method.Attributes & MethodAttributes.SpecialName) != 0 && method.Name.Equals(ConstructorInfo.ConstructorName)) {
  1420.                     m_constructorCount++;
  1421.                 }
  1422.             }
  1423.            
  1424.             m_listMethods.Add(method);
  1425.            
  1426.             return method;
  1427.         }
  1428.        
  1429.         #endregion
  1430.        
  1431.         #region Define Constructor
  1432.         [System.Runtime.InteropServices.ComVisible(true)]
  1433.         public ConstructorBuilder DefineTypeInitializer()
  1434.         {
  1435.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1436.                 lock (Module.Assembly.m_assemblyData) {
  1437.                     return DefineTypeInitializerNoLock();
  1438.                 }
  1439.             }
  1440.             else {
  1441.                 return DefineTypeInitializerNoLock();
  1442.             }
  1443.         }
  1444.        
  1445.         private ConstructorBuilder DefineTypeInitializerNoLock()
  1446.         {
  1447.             ThrowIfGeneric();
  1448.             ThrowIfCreated();
  1449.            
  1450.             // change the attributes and the class constructor's name
  1451.             MethodAttributes attr = MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.SpecialName;
  1452.            
  1453.             ConstructorBuilder constBuilder = new ConstructorBuilder(ConstructorInfo.TypeConstructorName, attr, CallingConventions.Standard, null, m_module, this);
  1454.            
  1455.             return constBuilder;
  1456.         }
  1457.        
  1458.         [System.Runtime.InteropServices.ComVisible(true)]
  1459.         public ConstructorBuilder DefineDefaultConstructor(MethodAttributes attributes)
  1460.         {
  1461.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1462.                 lock (Module.Assembly.m_assemblyData) {
  1463.                     return DefineDefaultConstructorNoLock(attributes);
  1464.                 }
  1465.             }
  1466.             else {
  1467.                 return DefineDefaultConstructorNoLock(attributes);
  1468.             }
  1469.         }
  1470.        
  1471.         private ConstructorBuilder DefineDefaultConstructorNoLock(MethodAttributes attributes)
  1472.         {
  1473.             ThrowIfGeneric();
  1474.            
  1475.             ConstructorBuilder constBuilder;
  1476.            
  1477.             // get the parent class's default constructor
  1478.             // We really don't want(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic) here. We really want
  1479.             // constructors visible from the subclass, but that is not currently
  1480.             // available in BindingFlags. This more open binding is open to
  1481.             // runtime binding failures(like if we resolve to a private
  1482.             // constructor).
  1483.             ConstructorInfo con = null;
  1484.            
  1485.             if (m_typeParent is TypeBuilderInstantiation) {
  1486.                 Type genericTypeDefinition = m_typeParent.GetGenericTypeDefinition();
  1487.                
  1488.                 if (genericTypeDefinition is TypeBuilder)
  1489.                     genericTypeDefinition = ((TypeBuilder)genericTypeDefinition).m_runtimeType;
  1490.                
  1491.                 if (genericTypeDefinition == null)
  1492.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  1493.                
  1494.                 Type inst = genericTypeDefinition.MakeGenericType(m_typeParent.GetGenericArguments());
  1495.                
  1496.                 if (inst is TypeBuilderInstantiation)
  1497.                     con = TypeBuilder.GetConstructor(inst, genericTypeDefinition.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null));
  1498.                 else
  1499.                     con = inst.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
  1500.             }
  1501.            
  1502.             if (con == null) {
  1503.                 con = m_typeParent.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
  1504.             }
  1505.            
  1506.             if (con == null)
  1507.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_NoParentDefaultConstructor"));
  1508.            
  1509.             // Define the constructor Builder
  1510.             constBuilder = DefineConstructor(attributes, CallingConventions.Standard, null);
  1511.             m_constructorCount++;
  1512.            
  1513.             // generate the code to call the parent's default constructor
  1514.             ILGenerator il = constBuilder.GetILGenerator();
  1515.             il.Emit(OpCodes.Ldarg_0);
  1516.             il.Emit(OpCodes.Call, con);
  1517.             il.Emit(OpCodes.Ret);
  1518.            
  1519.             constBuilder.m_ReturnILGen = false;
  1520.             return constBuilder;
  1521.         }
  1522.        
  1523.         [System.Runtime.InteropServices.ComVisible(true)]
  1524.         public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes)
  1525.         {
  1526.             return DefineConstructor(attributes, callingConvention, parameterTypes, null, null);
  1527.         }
  1528.        
  1529.         [System.Runtime.InteropServices.ComVisible(true)]
  1530.         public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers)
  1531.         {
  1532.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1533.                 lock (Module.Assembly.m_assemblyData) {
  1534.                     return DefineConstructorNoLock(attributes, callingConvention, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
  1535.                 }
  1536.             }
  1537.             else {
  1538.                 return DefineConstructorNoLock(attributes, callingConvention, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
  1539.             }
  1540.         }
  1541.        
  1542.         private ConstructorBuilder DefineConstructorNoLock(MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers)
  1543.         {
  1544.             CheckContext(parameterTypes);
  1545.             CheckContext(requiredCustomModifiers);
  1546.             CheckContext(optionalCustomModifiers);
  1547.            
  1548.             ThrowIfGeneric();
  1549.             ThrowIfCreated();
  1550.            
  1551.             string name;
  1552.            
  1553.             if ((attributes & MethodAttributes.Static) == 0) {
  1554.                 name = ConstructorInfo.ConstructorName;
  1555.             }
  1556.             else {
  1557.                 name = ConstructorInfo.TypeConstructorName;
  1558.             }
  1559.            
  1560.             attributes = attributes | MethodAttributes.SpecialName;
  1561.            
  1562.             ConstructorBuilder constBuilder = new ConstructorBuilder(name, attributes, callingConvention, parameterTypes, requiredCustomModifiers, optionalCustomModifiers, m_module, this);
  1563.            
  1564.             m_constructorCount++;
  1565.            
  1566.             return constBuilder;
  1567.         }
  1568.        
  1569.         #endregion
  1570.        
  1571.         #region Define PInvoke
  1572.         public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
  1573.         {
  1574.             ThrowIfGeneric();
  1575.            
  1576.             MethodBuilder method = DefinePInvokeMethodHelper(name, dllName, name, attributes, callingConvention, returnType, null, null, parameterTypes, null,
  1577.             null, nativeCallConv, nativeCharSet);
  1578.             return method;
  1579.         }
  1580.        
  1581.         public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
  1582.         {
  1583.             MethodBuilder method = DefinePInvokeMethodHelper(name, dllName, entryName, attributes, callingConvention, returnType, null, null, parameterTypes, null,
  1584.             null, nativeCallConv, nativeCharSet);
  1585.             return method;
  1586.         }
  1587.        
  1588.         public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers,
  1589.         Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet)
  1590.         {
  1591.             ThrowIfGeneric();
  1592.            
  1593.             MethodBuilder method = DefinePInvokeMethodHelper(name, dllName, entryName, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers,
  1594.             parameterTypeOptionalCustomModifiers, nativeCallConv, nativeCharSet);
  1595.             return method;
  1596.         }
  1597.        
  1598.         #endregion
  1599.        
  1600.         #region Define Nested Type
  1601.         public TypeBuilder DefineNestedType(string name)
  1602.         {
  1603.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1604.                 lock (Module.Assembly.m_assemblyData) {
  1605.                     return DefineNestedTypeNoLock(name);
  1606.                 }
  1607.             }
  1608.             else {
  1609.                 return DefineNestedTypeNoLock(name);
  1610.             }
  1611.         }
  1612.        
  1613.         private TypeBuilder DefineNestedTypeNoLock(string name)
  1614.         {
  1615.             ThrowIfGeneric();
  1616.             TypeBuilder typeBuilder;
  1617.             typeBuilder = new TypeBuilder(name, TypeAttributes.NestedPrivate, null, null, m_module, PackingSize.Unspecified, this);
  1618.             m_module.m_TypeBuilderList.Add(typeBuilder);
  1619.             return typeBuilder;
  1620.         }
  1621.        
  1622.         [System.Runtime.InteropServices.ComVisible(true)]
  1623.         public TypeBuilder DefineNestedType(string name, TypeAttributes attr, Type parent, Type[] interfaces)
  1624.         {
  1625.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1626.                 lock (Module.Assembly.m_assemblyData) {
  1627.                     return DefineNestedTypeNoLock(name, attr, parent, interfaces);
  1628.                 }
  1629.             }
  1630.             else {
  1631.                 return DefineNestedTypeNoLock(name, attr, parent, interfaces);
  1632.             }
  1633.         }
  1634.        
  1635.         private TypeBuilder DefineNestedTypeNoLock(string name, TypeAttributes attr, Type parent, Type[] interfaces)
  1636.         {
  1637.             CheckContext(parent);
  1638.             CheckContext(interfaces);
  1639.            
  1640.             ThrowIfGeneric();
  1641.            
  1642.             TypeBuilder typeBuilder;
  1643.             typeBuilder = new TypeBuilder(name, attr, parent, interfaces, m_module, PackingSize.Unspecified, this);
  1644.             m_module.m_TypeBuilderList.Add(typeBuilder);
  1645.             return typeBuilder;
  1646.         }
  1647.        
  1648.         public TypeBuilder DefineNestedType(string name, TypeAttributes attr, Type parent)
  1649.         {
  1650.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1651.                 lock (Module.Assembly.m_assemblyData) {
  1652.                     return DefineNestedTypeNoLock(name, attr, parent);
  1653.                 }
  1654.             }
  1655.             else {
  1656.                 return DefineNestedTypeNoLock(name, attr, parent);
  1657.             }
  1658.         }
  1659.        
  1660.         private TypeBuilder DefineNestedTypeNoLock(string name, TypeAttributes attr, Type parent)
  1661.         {
  1662.             ThrowIfGeneric();
  1663.             TypeBuilder typeBuilder;
  1664.             typeBuilder = new TypeBuilder(name, attr, parent, null, m_module, PackingSize.Unspecified, this);
  1665.             m_module.m_TypeBuilderList.Add(typeBuilder);
  1666.             return typeBuilder;
  1667.         }
  1668.        
  1669.         public TypeBuilder DefineNestedType(string name, TypeAttributes attr)
  1670.         {
  1671.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1672.                 lock (Module.Assembly.m_assemblyData) {
  1673.                     return DefineNestedTypeNoLock(name, attr);
  1674.                 }
  1675.             }
  1676.             else {
  1677.                 return DefineNestedTypeNoLock(name, attr);
  1678.             }
  1679.         }
  1680.        
  1681.         private TypeBuilder DefineNestedTypeNoLock(string name, TypeAttributes attr)
  1682.         {
  1683.             ThrowIfGeneric();
  1684.            
  1685.             TypeBuilder typeBuilder;
  1686.             typeBuilder = new TypeBuilder(name, attr, null, null, m_module, PackingSize.Unspecified, this);
  1687.             m_module.m_TypeBuilderList.Add(typeBuilder);
  1688.             return typeBuilder;
  1689.         }
  1690.        
  1691.         public TypeBuilder DefineNestedType(string name, TypeAttributes attr, Type parent, int typeSize)
  1692.         {
  1693.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1694.                 lock (Module.Assembly.m_assemblyData) {
  1695.                     return DefineNestedTypeNoLock(name, attr, parent, typeSize);
  1696.                 }
  1697.             }
  1698.             else {
  1699.                 return DefineNestedTypeNoLock(name, attr, parent, typeSize);
  1700.             }
  1701.         }
  1702.        
  1703.         private TypeBuilder DefineNestedTypeNoLock(string name, TypeAttributes attr, Type parent, int typeSize)
  1704.         {
  1705.             TypeBuilder typeBuilder;
  1706.             typeBuilder = new TypeBuilder(name, attr, parent, m_module, PackingSize.Unspecified, typeSize, this);
  1707.             m_module.m_TypeBuilderList.Add(typeBuilder);
  1708.             return typeBuilder;
  1709.         }
  1710.        
  1711.         public TypeBuilder DefineNestedType(string name, TypeAttributes attr, Type parent, PackingSize packSize)
  1712.         {
  1713.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1714.                 lock (Module.Assembly.m_assemblyData) {
  1715.                     return DefineNestedTypeNoLock(name, attr, parent, packSize);
  1716.                 }
  1717.             }
  1718.             else {
  1719.                 return DefineNestedTypeNoLock(name, attr, parent, packSize);
  1720.             }
  1721.         }
  1722.        
  1723.         private TypeBuilder DefineNestedTypeNoLock(string name, TypeAttributes attr, Type parent, PackingSize packSize)
  1724.         {
  1725.             ThrowIfGeneric();
  1726.            
  1727.             TypeBuilder typeBuilder;
  1728.             typeBuilder = new TypeBuilder(name, attr, parent, null, m_module, packSize, this);
  1729.             m_module.m_TypeBuilderList.Add(typeBuilder);
  1730.             return typeBuilder;
  1731.         }
  1732.        
  1733.         #endregion
  1734.        
  1735.         #region Define Field
  1736.         public FieldBuilder DefineField(string fieldName, Type type, FieldAttributes attributes)
  1737.         {
  1738.             return DefineField(fieldName, type, null, null, attributes);
  1739.         }
  1740.        
  1741.         public FieldBuilder DefineField(string fieldName, Type type, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
  1742.         {
  1743.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1744.                 lock (Module.Assembly.m_assemblyData) {
  1745.                     return DefineFieldNoLock(fieldName, type, requiredCustomModifiers, optionalCustomModifiers, attributes);
  1746.                 }
  1747.             }
  1748.             else {
  1749.                 return DefineFieldNoLock(fieldName, type, requiredCustomModifiers, optionalCustomModifiers, attributes);
  1750.             }
  1751.         }
  1752.        
  1753.         private FieldBuilder DefineFieldNoLock(string fieldName, Type type, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
  1754.         {
  1755.             ThrowIfGeneric();
  1756.             ThrowIfCreated();
  1757.             CheckContext(type);
  1758.             CheckContext(requiredCustomModifiers);
  1759.            
  1760.             if (m_underlyingSystemType == null && IsEnum == true) {
  1761.                 if ((attributes & FieldAttributes.Static) == 0) {
  1762.                     // remember the underlying type for enum type
  1763.                     m_underlyingSystemType = type;
  1764.                 }
  1765.             }
  1766.            
  1767.             return new FieldBuilder(this, fieldName, type, requiredCustomModifiers, optionalCustomModifiers, attributes);
  1768.         }
  1769.        
  1770.         public FieldBuilder DefineInitializedData(string name, byte[] data, FieldAttributes attributes)
  1771.         {
  1772.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1773.                 lock (Module.Assembly.m_assemblyData) {
  1774.                     return DefineInitializedDataNoLock(name, data, attributes);
  1775.                 }
  1776.             }
  1777.             else {
  1778.                 return DefineInitializedDataNoLock(name, data, attributes);
  1779.             }
  1780.         }
  1781.        
  1782.         private FieldBuilder DefineInitializedDataNoLock(string name, byte[] data, FieldAttributes attributes)
  1783.         {
  1784.             // This method will define an initialized Data in .sdata.
  1785.             // We will create a fake TypeDef to represent the data with size. This TypeDef
  1786.             // will be the signature for the Field.
  1787.             ThrowIfGeneric();
  1788.            
  1789.             if (data == null)
  1790.                 throw new ArgumentNullException("data");
  1791.            
  1792.             return DefineDataHelper(name, data, data.Length, attributes);
  1793.         }
  1794.        
  1795.         public FieldBuilder DefineUninitializedData(string name, int size, FieldAttributes attributes)
  1796.         {
  1797.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1798.                 lock (Module.Assembly.m_assemblyData) {
  1799.                     return DefineUninitializedDataNoLock(name, size, attributes);
  1800.                 }
  1801.             }
  1802.             else {
  1803.                 return DefineUninitializedDataNoLock(name, size, attributes);
  1804.             }
  1805.         }
  1806.        
  1807.         private FieldBuilder DefineUninitializedDataNoLock(string name, int size, FieldAttributes attributes)
  1808.         {
  1809.             // This method will define an uninitialized Data in .sdata.
  1810.             // We will create a fake TypeDef to represent the data with size. This TypeDef
  1811.             // will be the signature for the Field.
  1812.             ThrowIfGeneric();
  1813.             return DefineDataHelper(name, null, size, attributes);
  1814.         }
  1815.        
  1816.         #endregion
  1817.        
  1818.         #region Define Properties and Events
  1819.         public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, Type returnType, Type[] parameterTypes)
  1820.         {
  1821.             return DefineProperty(name, attributes, returnType, null, null, parameterTypes, null, null);
  1822.         }
  1823.        
  1824.         public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
  1825.         {
  1826.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1827.                 lock (Module.Assembly.m_assemblyData) {
  1828.                     return DefinePropertyNoLock(name, attributes, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
  1829.                 }
  1830.             }
  1831.             else {
  1832.                 return DefinePropertyNoLock(name, attributes, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
  1833.             }
  1834.         }
  1835.        
  1836.         private PropertyBuilder DefinePropertyNoLock(string name, PropertyAttributes attributes, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
  1837.         {
  1838.             ThrowIfGeneric();
  1839.            
  1840.             CheckContext(returnType);
  1841.             CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
  1842.             CheckContext(parameterTypeRequiredCustomModifiers);
  1843.             CheckContext(parameterTypeOptionalCustomModifiers);
  1844.            
  1845.             SignatureHelper sigHelper;
  1846.             int sigLength;
  1847.             byte[] sigBytes;
  1848.            
  1849.             if (name == null)
  1850.                 throw new ArgumentNullException("name");
  1851.             if (name.Length == 0)
  1852.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  1853.             ThrowIfCreated();
  1854.            
  1855.             // get the signature in SignatureHelper form
  1856.             sigHelper = SignatureHelper.GetPropertySigHelper(m_module, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
  1857.            
  1858.             // get the signature in byte form
  1859.             sigBytes = sigHelper.InternalGetSignature(out sigLength);
  1860.            
  1861.             PropertyToken prToken = new PropertyToken(InternalDefineProperty(m_module, m_tdType.Token, name, (int)attributes, sigBytes, sigLength, 0, 0));
  1862.            
  1863.             // create the property builder now.
  1864.             return new PropertyBuilder(m_module, name, sigHelper, attributes, returnType, prToken, this);
  1865.         }
  1866.        
  1867.         public EventBuilder DefineEvent(string name, EventAttributes attributes, Type eventtype)
  1868.         {
  1869.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1870.                 lock (Module.Assembly.m_assemblyData) {
  1871.                     return DefineEventNoLock(name, attributes, eventtype);
  1872.                 }
  1873.             }
  1874.             else {
  1875.                 return DefineEventNoLock(name, attributes, eventtype);
  1876.             }
  1877.         }
  1878.        
  1879.         private EventBuilder DefineEventNoLock(string name, EventAttributes attributes, Type eventtype)
  1880.         {
  1881.             int tkType;
  1882.             EventToken evToken;
  1883.            
  1884.             CheckContext(eventtype);
  1885.            
  1886.             ThrowIfGeneric();
  1887.             ThrowIfCreated();
  1888.            
  1889.             if (name == null)
  1890.                 throw new ArgumentNullException("name");
  1891.             if (name.Length == 0)
  1892.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  1893.             if (name[0] == '\0')
  1894.                 throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "name");
  1895.            
  1896.             tkType = m_module.GetTypeToken(eventtype).Token;
  1897.            
  1898.             // Internal helpers to define property records
  1899.             evToken = new EventToken(InternalDefineEvent(m_module, m_tdType.Token, name, (int)attributes, tkType));
  1900.            
  1901.             // create the property builder now.
  1902.             return new EventBuilder(m_module, name, attributes, tkType, this, evToken);
  1903.         }
  1904.        
  1905.         #endregion
  1906.        
  1907.         #region Create Type
  1908.         public Type CreateType()
  1909.         {
  1910.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  1911.                 lock (Module.Assembly.m_assemblyData) {
  1912.                     return CreateTypeNoLock();
  1913.                 }
  1914.             }
  1915.             else {
  1916.                 return CreateTypeNoLock();
  1917.             }
  1918.         }
  1919.        
  1920.         internal void CheckContext(params Type[][] typess)
  1921.         {
  1922.             ((AssemblyBuilder)Module.Assembly).CheckContext(typess);
  1923.         }
  1924.         internal void CheckContext(params Type[] types)
  1925.         {
  1926.             ((AssemblyBuilder)Module.Assembly).CheckContext(types);
  1927.         }
  1928.        
  1929.         private Type CreateTypeNoLock()
  1930.         {
  1931.            
  1932.             if (IsCreated())
  1933.                 return m_runtimeType;
  1934.            
  1935.             ThrowIfGeneric();
  1936.             ThrowIfCreated();
  1937.            
  1938.             if (m_typeInterfaces == null)
  1939.                 m_typeInterfaces = new Type[0];
  1940.            
  1941.             int[] interfaceTokens = new int[m_typeInterfaces.Length];
  1942.             for (int i = 0; i < m_typeInterfaces.Length; i++) {
  1943.                 interfaceTokens[i] = m_module.GetTypeToken(m_typeInterfaces[i]).Token;
  1944.             }
  1945.            
  1946.             int tkParent = 0;
  1947.             if (m_typeParent != null)
  1948.                 tkParent = m_module.GetTypeToken(m_typeParent).Token;
  1949.            
  1950.             if (IsGenericParameter) {
  1951.                 int[] constraints = new int[m_typeInterfaces.Length];
  1952.                
  1953.                 if (m_typeParent != null) {
  1954.                     constraints = new int[m_typeInterfaces.Length + 1];
  1955.                     constraints[constraints.Length - 1] = tkParent;
  1956.                 }
  1957.                
  1958.                 for (int i = 0; i < m_typeInterfaces.Length; i++) {
  1959.                     constraints[i] = m_module.GetTypeToken(m_typeInterfaces[i]).Token;
  1960.                 }
  1961.                
  1962.                 int declMember = m_declMeth == null ? m_DeclaringType.m_tdType.Token : m_declMeth.GetToken().Token;
  1963.                 m_tdType = new TypeToken(InternalDefineGenParam(m_strName, declMember, m_genParamPos, (int)m_genParamAttributes, constraints, m_module, 0));
  1964.                
  1965.                 if (m_ca != null) {
  1966.                     foreach (CustAttr ca in m_ca)
  1967.                         ca.Bake(m_module, MetadataTokenInternal);
  1968.                 }
  1969.                
  1970.                 m_hasBeenCreated = true;
  1971.                 return this;
  1972.             }
  1973.             else {
  1974.                 // Check for global typebuilder
  1975.                 if (((m_tdType.Token & 16777215) != 0) && ((tkParent & 16777215) != 0))
  1976.                     InternalSetParentType(m_tdType.Token, tkParent, m_module);
  1977.                
  1978.                 if (m_inst != null)
  1979.                     foreach (Type tb in m_inst)
  1980.                         if (tb is GenericTypeParameterBuilder)
  1981.                             ((GenericTypeParameterBuilder)tb).m_type.CreateType();
  1982.             }
  1983.            
  1984.             byte[] body;
  1985.             MethodAttributes methodAttrs;
  1986.             int maxstack;
  1987.            
  1988.             if (!m_isHiddenGlobalType) {
  1989.                 // create a public default constructor if this class has no constructor.
  1990.                 // except if the type is Interface, ValueType, Enum, or a static class.
  1991.                 if (m_constructorCount == 0 && ((m_iAttr & TypeAttributes.Interface) == 0) && !IsValueType && ((m_iAttr & (TypeAttributes.Abstract | TypeAttributes.Sealed)) != (TypeAttributes.Abstract | TypeAttributes.Sealed))) {
  1992.                     DefineDefaultConstructor(MethodAttributes.Public);
  1993.                 }
  1994.             }
  1995.            
  1996.             int size = m_listMethods.Count;
  1997.            
  1998.             for (int i = 0; i < size; i++) {
  1999.                 MethodBuilder meth = (MethodBuilder)m_listMethods[i];
  2000.                
  2001.                
  2002.                 if (meth.IsGenericMethodDefinition)
  2003.                     meth.GetToken();
  2004.                 // Doubles as "CreateMethod" for MethodBuilder -- analagous to CreateType()
  2005.                 methodAttrs = meth.Attributes;
  2006.                
  2007.                 // Any of these flags in the implemenation flags is set, we will not attach the IL method body
  2008.                 if (((meth.GetMethodImplementationFlags() & (MethodImplAttributes.CodeTypeMask | MethodImplAttributes.PreserveSig | MethodImplAttributes.Unmanaged)) != MethodImplAttributes.IL) || ((methodAttrs & MethodAttributes.PinvokeImpl) != (MethodAttributes)0)) {
  2009.                     continue;
  2010.                 }
  2011.                
  2012.                 int sigLength;
  2013.                 byte[] LocalSig = meth.GetLocalsSignature().InternalGetSignature(out sigLength);
  2014.                
  2015.                
  2016.                 // Check that they haven't declared an abstract method on a non-abstract class
  2017.                 if (((methodAttrs & MethodAttributes.Abstract) != 0) && ((m_iAttr & TypeAttributes.Abstract) == 0)) {
  2018.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadTypeAttributesNotAbstract"));
  2019.                 }
  2020.                
  2021.                 body = meth.GetBody();
  2022.                
  2023.                 // If this is an abstract method or an interface, we don't need to set the IL.
  2024.                
  2025.                 if ((methodAttrs & MethodAttributes.Abstract) != 0) {
  2026.                     // We won't check on Interface because we can have class static initializer on interface.
  2027.                     // We will just let EE or validator to catch the problem.
  2028.                    
  2029.                     //((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface))
  2030.                    
  2031.                     if (body != null)
  2032.                         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadMethodBody"));
  2033.                 }
  2034.                 else if (body == null || body.Length == 0) {
  2035.                     // If it's not an abstract or an interface, set the IL.
  2036.                     if (meth.m_ilGenerator != null) {
  2037.                         // we need to bake the method here.
  2038.                         meth.CreateMethodBodyHelper(meth.GetILGenerator());
  2039.                     }
  2040.                    
  2041.                     body = meth.GetBody();
  2042.                    
  2043.                     if ((body == null || body.Length == 0) && !meth.m_canBeRuntimeImpl)
  2044.                         throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidOperation_BadEmptyMethodBody"), meth.Name));
  2045.                 }
  2046.                
  2047.                 if (meth.m_ilGenerator != null) {
  2048.                     maxstack = meth.m_ilGenerator.GetMaxStackSize();
  2049.                 }
  2050.                 else {
  2051.                     // this is the case when client provide an array of IL byte stream rather than going through ILGenerator.
  2052.                     maxstack = 16;
  2053.                 }
  2054.                
  2055.                 __ExceptionInstance[] Exceptions = meth.GetExceptionInstances();
  2056.                 int[] TokenFixups = meth.GetTokenFixups();
  2057.                 int[] RVAFixups = meth.GetRVAFixups();
  2058.                
  2059.                
  2060.                 __ExceptionInstance[] localExceptions = null;
  2061.                 int[] localTokenFixups = null;
  2062.                 int[] localRVAFixups = null;
  2063.                
  2064.                 if (Exceptions != null) {
  2065.                     localExceptions = new __ExceptionInstance[Exceptions.Length];
  2066.                     Array.Copy(Exceptions, localExceptions, Exceptions.Length);
  2067.                 }
  2068.                
  2069.                 if (TokenFixups != null) {
  2070.                     localTokenFixups = new int[TokenFixups.Length];
  2071.                     Array.Copy(TokenFixups, localTokenFixups, TokenFixups.Length);
  2072.                 }
  2073.                
  2074.                 if (RVAFixups != null) {
  2075.                     localRVAFixups = new int[RVAFixups.Length];
  2076.                     Array.Copy(RVAFixups, localRVAFixups, RVAFixups.Length);
  2077.                 }
  2078.                
  2079.                 InternalSetMethodIL(meth.GetToken().Token, meth.InitLocals, body, LocalSig, sigLength, maxstack, meth.GetNumberOfExceptions(), localExceptions, localTokenFixups, localRVAFixups,
  2080.                 m_module);
  2081.             }
  2082.            
  2083.             m_hasBeenCreated = true;
  2084.            
  2085.             // Terminate the process.
  2086.             Type cls = TermCreateClass(m_tdType.Token, m_module);
  2087.            
  2088.             if (!m_isHiddenGlobalType) {
  2089.                 m_runtimeType = (RuntimeType)cls;
  2090.                
  2091.                 // if this type is a nested type, we need to invalidate the cached nested runtime type on the nesting type
  2092.                 if (m_DeclaringType != null && (RuntimeType)m_DeclaringType.m_runtimeType != null) {
  2093.                     ((RuntimeType)m_DeclaringType.m_runtimeType).InvalidateCachedNestedType();
  2094.                 }
  2095.                
  2096.                 return cls;
  2097.             }
  2098.             else {
  2099.                 return null;
  2100.             }
  2101.         }
  2102.        
  2103.         #endregion
  2104.        
  2105.         #region Misc
  2106.         public int Size {
  2107.             get { return m_iTypeSize; }
  2108.         }
  2109.        
  2110.         public PackingSize PackingSize {
  2111.             get { return m_iPackingSize; }
  2112.         }
  2113.        
  2114.         public void SetParent(Type parent)
  2115.         {
  2116.             ThrowIfGeneric();
  2117.             ThrowIfCreated();
  2118.             CheckContext(parent);
  2119.            
  2120.             if (parent != null) {
  2121.                 m_typeParent = parent;
  2122.             }
  2123.             else {
  2124.                 if ((m_iAttr & TypeAttributes.Interface) != TypeAttributes.Interface) {
  2125.                     m_typeParent = typeof(object);
  2126.                 }
  2127.                 else {
  2128.                     if ((m_iAttr & TypeAttributes.Abstract) == 0)
  2129.                         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadInterfaceNotAbstract"));
  2130.                    
  2131.                     // there is no extends for interface class
  2132.                     m_typeParent = null;
  2133.                 }
  2134.             }
  2135.         }
  2136.        
  2137.         [System.Runtime.InteropServices.ComVisible(true)]
  2138.         public void AddInterfaceImplementation(Type interfaceType)
  2139.         {
  2140.             ThrowIfGeneric();
  2141.            
  2142.             CheckContext(interfaceType);
  2143.            
  2144.             if (interfaceType == null) {
  2145.                 throw new ArgumentNullException("interfaceType");
  2146.             }
  2147.             ThrowIfCreated();
  2148.            
  2149.             TypeToken tkInterface = m_module.GetTypeToken(interfaceType);
  2150.             InternalAddInterfaceImpl(m_tdType.Token, tkInterface.Token, m_module);
  2151.         }
  2152.        
  2153.         public void AddDeclarativeSecurity(SecurityAction action, PermissionSet pset)
  2154.         {
  2155.             if (Module.Assembly.m_assemblyData.m_isSynchronized) {
  2156.                 lock (Module.Assembly.m_assemblyData) {
  2157.                     AddDeclarativeSecurityNoLock(action, pset);
  2158.                 }
  2159.             }
  2160.             else {
  2161.                 AddDeclarativeSecurityNoLock(action, pset);
  2162.             }
  2163.         }
  2164.        
  2165.         private void AddDeclarativeSecurityNoLock(SecurityAction action, PermissionSet pset)
  2166.         {
  2167.             ThrowIfGeneric();
  2168.            
  2169.             if (pset == null)
  2170.                 throw new ArgumentNullException("pset");
  2171.            
  2172.             if (!Enum.IsDefined(typeof(SecurityAction), action) || action == SecurityAction.RequestMinimum || action == SecurityAction.RequestOptional || action == SecurityAction.RequestRefuse)
  2173.                 throw new ArgumentOutOfRangeException("action");
  2174.            
  2175.             ThrowIfCreated();
  2176.            
  2177.             // Translate permission set into serialized format(uses standard binary serialization format).
  2178.             byte[] blob = null;
  2179.             if (!pset.IsEmpty())
  2180.                 blob = pset.EncodeXml();
  2181.            
  2182.             // Write the blob into the metadata.
  2183.             InternalAddDeclarativeSecurity(m_module, m_tdType.Token, action, blob);
  2184.         }
  2185.        
  2186.         public TypeToken TypeToken {
  2187.             get {
  2188.                 if (IsGenericParameter)
  2189.                     ThrowIfCreated();
  2190.                
  2191.                 return m_tdType;
  2192.             }
  2193.         }
  2194.        
  2195.         [System.Runtime.InteropServices.ComVisible(true)]
  2196.        
  2197.         public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
  2198.         {
  2199.             ThrowIfGeneric();
  2200.            
  2201.             if (con == null)
  2202.                 throw new ArgumentNullException("con");
  2203.            
  2204.             if (binaryAttribute == null)
  2205.                 throw new ArgumentNullException("binaryAttribute");
  2206.            
  2207.             TypeBuilder.InternalCreateCustomAttribute(m_tdType.Token, ((ModuleBuilder)m_module).GetConstructorToken(con).Token, binaryAttribute, m_module, false);
  2208.         }
  2209.        
  2210.         public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
  2211.         {
  2212.             ThrowIfGeneric();
  2213.            
  2214.             if (customBuilder == null)
  2215.                 throw new ArgumentNullException("customBuilder");
  2216.            
  2217.             customBuilder.CreateCustomAttribute((ModuleBuilder)m_module, m_tdType.Token);
  2218.         }
  2219.        
  2220.         #endregion
  2221.        
  2222.         #endregion
  2223.        
  2224.         void _TypeBuilder.GetTypeInfoCount(out uint pcTInfo)
  2225.         {
  2226.             throw new NotImplementedException();
  2227.         }
  2228.        
  2229.         void _TypeBuilder.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  2230.         {
  2231.             throw new NotImplementedException();
  2232.         }
  2233.        
  2234.         void _TypeBuilder.GetIDsOfNames(        [In()]
  2235. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  2236.         {
  2237.             throw new NotImplementedException();
  2238.         }
  2239.        
  2240.         void _TypeBuilder.Invoke(uint dispIdMember,         [In()]
  2241. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  2242.         {
  2243.             throw new NotImplementedException();
  2244.         }
  2245.     }
  2246. }

Developer Fusion