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

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

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  16. namespace System.Reflection.Emit
  17. {
  18.     using System.Text;
  19.     using System;
  20.     using CultureInfo = System.Globalization.CultureInfo;
  21.     using System.Diagnostics.SymbolStore;
  22.     using System.Reflection;
  23.     using System.Security;
  24.     using System.Collections;
  25.     using System.Security.Permissions;
  26.     using System.Runtime.InteropServices;
  27.    
  28.     [HostProtection(MayLeakOnAbort = true)]
  29.     [ClassInterface(ClassInterfaceType.None)]
  30.     [ComDefaultInterface(typeof(_MethodBuilder))]
  31.     [System.Runtime.InteropServices.ComVisible(true)]
  32.     public sealed class MethodBuilder : MethodInfo, _MethodBuilder
  33.     {
  34.         #region Private Data Members
  35.         // Identity
  36.         internal string m_strName;
  37.         // The name of the method
  38.         private MethodToken m_tkMethod;
  39.         // The token of this method
  40.         internal Module m_module;
  41.         internal TypeBuilder m_containingType;
  42.         private MethodBuilder m_link;
  43.        
  44.         // IL
  45.         private int[] m_RVAFixups;
  46.         // The location of all RVA fixups. Primarily used for Strings.
  47.         private int[] m_mdMethodFixups;
  48.         // The location of all of the token fixups.
  49.         private SignatureHelper m_localSignature;
  50.         internal LocalSymInfo m_localSymInfo;
  51.         // keep track debugging local information
  52.         internal ILGenerator m_ilGenerator;
  53.         private byte[] m_ubBody;
  54.         // The IL for the method
  55.         private int m_numExceptions;
  56.         // The number of exceptions. Each try-catch tuple is a separate exception.
  57.         private __ExceptionInstance[] m_exceptions;
  58.         //The instance of each exception.
  59.         // Flags
  60.         internal bool m_bIsBaked;
  61.         private bool m_bIsGlobalMethod;
  62.         private bool m_fInitLocals;
  63.         // indicating if the method stack frame will be zero initialized or not.
  64.         // Attributes
  65.         private MethodAttributes m_iAttributes;
  66.         private CallingConventions m_callingConvention;
  67.         private MethodImplAttributes m_dwMethodImplFlags;
  68.        
  69.         // Parameters
  70.         private SignatureHelper m_signature;
  71.         internal Type[] m_parameterTypes;
  72.         private ParameterBuilder m_retParam;
  73.         internal Type m_returnType;
  74.         private Type[] m_returnTypeRequiredCustomModifiers;
  75.         private Type[] m_returnTypeOptionalCustomModifiers;
  76.         private Type[][] m_parameterTypeRequiredCustomModifiers;
  77.         private Type[][] m_parameterTypeOptionalCustomModifiers;
  78.        
  79.         // Generics
  80.         private GenericTypeParameterBuilder[] m_inst;
  81.         private bool m_bIsGenMethDef;
  82.         #endregion
  83.        
  84.         #region Constructor
  85.         internal MethodBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Module mod, TypeBuilder type, bool bIsGlobalMethod)
  86.         {
  87.             Init(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null, mod,
  88.             type, bIsGlobalMethod);
  89.         }
  90.        
  91.         internal MethodBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, Module mod,
  92.         TypeBuilder type, bool bIsGlobalMethod)
  93.         {
  94.             Init(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, mod,
  95.             type, bIsGlobalMethod);
  96.         }
  97.        
  98.         private void Init(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, Module mod,
  99.         TypeBuilder type, bool bIsGlobalMethod)
  100.         {
  101.             if (name == null)
  102.                 throw new ArgumentNullException("name");
  103.            
  104.             if (name.Length == 0)
  105.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
  106.            
  107.             if (name[0] == '\0')
  108.                 throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "name");
  109.            
  110.             if (mod == null)
  111.                 throw new ArgumentNullException("mod");
  112.            
  113.             if (parameterTypes != null) {
  114.                 foreach (Type t in parameterTypes) {
  115.                     if (t == null)
  116.                         throw new ArgumentNullException("parameterTypes");
  117.                 }
  118.             }
  119.            
  120.             m_link = type.m_currentMethod;
  121.             type.m_currentMethod = this;
  122.             m_strName = name;
  123.             m_module = mod;
  124.             m_containingType = type;
  125.             m_localSignature = SignatureHelper.GetLocalVarSigHelper(mod);
  126.            
  127.             //
  128.             //if (returnType == null)
  129.             //{
  130.             // m_returnType = typeof(void);
  131.             //}
  132.             //else
  133.             {
  134.                 m_returnType = returnType;
  135.             }
  136.            
  137.             if ((attributes & MethodAttributes.Static) == 0) {
  138.                 // turn on the has this calling convention
  139.                 callingConvention = callingConvention | CallingConventions.HasThis;
  140.             }
  141.             else if ((attributes & MethodAttributes.Virtual) != 0) {
  142.                 // A method can't be both static and virtual
  143.                 throw new ArgumentException(Environment.GetResourceString("Arg_NoStaticVirtual"));
  144.             }
  145.            
  146.             if ((attributes & MethodAttributes.SpecialName) != MethodAttributes.SpecialName) {
  147.                 if ((type.Attributes & TypeAttributes.Interface) == TypeAttributes.Interface) {
  148.                     // methods on interface have to be abstract + virtual except special name methods such as type initializer
  149.                     if ((attributes & (MethodAttributes.Abstract | MethodAttributes.Virtual)) != (MethodAttributes.Abstract | MethodAttributes.Virtual) && (attributes & MethodAttributes.Static) == 0)
  150.                         throw new ArgumentException(Environment.GetResourceString("Argument_BadAttributeOnInterfaceMethod"));
  151.                 }
  152.             }
  153.            
  154.             m_callingConvention = callingConvention;
  155.            
  156.             if (parameterTypes != null) {
  157.                 m_parameterTypes = new Type[parameterTypes.Length];
  158.                 Array.Copy(parameterTypes, m_parameterTypes, parameterTypes.Length);
  159.             }
  160.             else {
  161.                 m_parameterTypes = null;
  162.             }
  163.            
  164.             m_returnTypeRequiredCustomModifiers = returnTypeRequiredCustomModifiers;
  165.             m_returnTypeOptionalCustomModifiers = returnTypeOptionalCustomModifiers;
  166.             m_parameterTypeRequiredCustomModifiers = parameterTypeRequiredCustomModifiers;
  167.             m_parameterTypeOptionalCustomModifiers = parameterTypeOptionalCustomModifiers;
  168.            
  169.             // m_signature = SignatureHelper.GetMethodSigHelper(mod, callingConvention,
  170.             // returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers,
  171.             // parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
  172.            
  173.             m_iAttributes = attributes;
  174.             m_bIsGlobalMethod = bIsGlobalMethod;
  175.             m_bIsBaked = false;
  176.             m_fInitLocals = true;
  177.            
  178.             m_localSymInfo = new LocalSymInfo();
  179.             m_ubBody = null;
  180.             m_ilGenerator = null;
  181.            
  182.             // Default is managed IL. Manged IL has bit flag 0x0020 set off
  183.             m_dwMethodImplFlags = MethodImplAttributes.IL;
  184.            
  185.             //int i = MetadataTokenInternal;
  186.         }
  187.        
  188.         #endregion
  189.        
  190.         #region Internal Members
  191.         internal void CheckContext(params Type[][] typess)
  192.         {
  193.             ((AssemblyBuilder)Module.Assembly).CheckContext(typess);
  194.         }
  195.         internal void CheckContext(params Type[] types)
  196.         {
  197.             ((AssemblyBuilder)Module.Assembly).CheckContext(types);
  198.         }
  199.        
  200.         internal void CreateMethodBodyHelper(ILGenerator il)
  201.         {
  202.             // Sets the IL of the method. An ILGenerator is passed as an argument and the method
  203.             // queries this instance to get all of the information which it needs.
  204.            
  205.             __ExceptionInfo[] excp;
  206.             int counter = 0;
  207.             int[] filterAddrs;
  208.             int[] catchAddrs;
  209.             int[] catchEndAddrs;
  210.             Type[] catchClass;
  211.             int[] type;
  212.             int numCatch;
  213.             int start;
  214.             int end;
  215.             ModuleBuilder dynMod = (ModuleBuilder)m_module;
  216.            
  217.             m_containingType.ThrowIfCreated();
  218.            
  219.             if (m_bIsBaked) {
  220.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodHasBody"));
  221.             }
  222.            
  223.             if (il == null) {
  224.                 throw new ArgumentNullException("il");
  225.             }
  226.            
  227.             if (il.m_methodBuilder != this && il.m_methodBuilder != null) {
  228.                 // you don't need to call CreateMethodBody when you get your ILGenerator
  229.                 // through MethodBuilder::GetILGenerator.
  230.                 //
  231.                
  232.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_BadILGeneratorUsage"));
  233.             }
  234.            
  235.             ThrowIfShouldNotHaveBody();
  236.            
  237.             if (il.m_ScopeTree.m_iOpenScopeCount != 0) {
  238.                 // There are still unclosed local scope
  239.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_OpenLocalVariableScope"));
  240.             }
  241.            
  242.            
  243.             m_ubBody = il.BakeByteArray();
  244.            
  245.             m_RVAFixups = il.GetRVAFixups();
  246.             m_mdMethodFixups = il.GetTokenFixups();
  247.            
  248.             //Okay, now the fun part. Calculate all of the exceptions.
  249.             excp = il.GetExceptions();
  250.             m_numExceptions = CalculateNumberOfExceptions(excp);
  251.             if (m_numExceptions > 0) {
  252.                
  253.                 m_exceptions = new __ExceptionInstance[m_numExceptions];
  254.                
  255.                 for (int i = 0; i < excp.Length; i++) {
  256.                     filterAddrs = excp[i].GetFilterAddresses();
  257.                     catchAddrs = excp[i].GetCatchAddresses();
  258.                     catchEndAddrs = excp[i].GetCatchEndAddresses();
  259.                     catchClass = excp[i].GetCatchClass();
  260.                    
  261.                    
  262.                     // track the reference of the catch class
  263.                     for (int j = 0; j < catchClass.Length; j++) {
  264.                         if (catchClass[j] != null)
  265.                             dynMod.GetTypeToken(catchClass[j]);
  266.                     }
  267.                    
  268.                     numCatch = excp[i].GetNumberOfCatches();
  269.                     start = excp[i].GetStartAddress();
  270.                     end = excp[i].GetEndAddress();
  271.                     type = excp[i].GetExceptionTypes();
  272.                     for (int j = 0; j < numCatch; j++) {
  273.                         int tkExceptionClass = 0;
  274.                         if (catchClass[j] != null)
  275.                             tkExceptionClass = dynMod.GetTypeToken(catchClass[j]).Token;
  276.                         switch (type[j]) {
  277.                             case __ExceptionInfo.None:
  278.                             case __ExceptionInfo.Fault:
  279.                             case __ExceptionInfo.Filter:
  280.                                 m_exceptions[counter++] = new __ExceptionInstance(start, end, filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass);
  281.                                 break;
  282.                             case __ExceptionInfo.Finally:
  283.                                
  284.                                 m_exceptions[counter++] = new __ExceptionInstance(start, excp[i].GetFinallyEndAddress(), filterAddrs[j], catchAddrs[j], catchEndAddrs[j], type[j], tkExceptionClass);
  285.                                 break;
  286.                         }
  287.                     }
  288.                    
  289.                 }
  290.             }
  291.            
  292.            
  293.             m_bIsBaked = true;
  294.            
  295.             if (dynMod.GetSymWriter() != null) {
  296.                
  297.                 // set the debugging information such as scope and line number
  298.                 // if it is in a debug module
  299.                 //
  300.                 SymbolToken tk = new SymbolToken(MetadataTokenInternal);
  301.                 ISymbolWriter symWriter = dynMod.GetSymWriter();
  302.                
  303.                 // call OpenMethod to make this method the current method
  304.                 symWriter.OpenMethod(tk);
  305.                
  306.                 // call OpenScope because OpenMethod no longer implicitly creating
  307.                 // the top-levelsmethod scope
  308.                 //
  309.                 symWriter.OpenScope(0);
  310.                
  311.                 if (m_symCustomAttrs != null) {
  312.                     foreach (SymCustomAttr symCustomAttr in m_symCustomAttrs)
  313.                         dynMod.GetSymWriter().SetSymAttribute(new SymbolToken(MetadataTokenInternal), symCustomAttr.m_name, symCustomAttr.m_data);
  314.                 }
  315.                
  316.                 if (m_localSymInfo != null)
  317.                     m_localSymInfo.EmitLocalSymInfo(symWriter);
  318.                 il.m_ScopeTree.EmitScopeTree(symWriter);
  319.                 il.m_LineNumberInfo.EmitLineNumberInfo(symWriter);
  320.                 symWriter.CloseScope(il.m_length);
  321.                 symWriter.CloseMethod();
  322.             }
  323.         }
  324.        
  325.         internal override Type[] GetParameterTypes()
  326.         {
  327.             if (m_parameterTypes == null)
  328.                 m_parameterTypes = new Type[0];
  329.            
  330.             return m_parameterTypes;
  331.         }
  332.        
  333.         internal void SetToken(MethodToken token)
  334.         {
  335.             m_tkMethod = token;
  336.         }
  337.        
  338.         internal byte[] GetBody()
  339.         {
  340.             // Returns the il bytes of this method.
  341.             // This il is not valid until somebody has called BakeByteArray
  342.             return m_ubBody;
  343.         }
  344.        
  345.         internal int[] GetTokenFixups()
  346.         {
  347.             return m_mdMethodFixups;
  348.         }
  349.        
  350.         internal int[] GetRVAFixups()
  351.         {
  352.             return m_RVAFixups;
  353.         }
  354.        
  355.         internal SignatureHelper GetMethodSignature()
  356.         {
  357.             if (m_parameterTypes == null)
  358.                 m_parameterTypes = new Type[0];
  359.            
  360.             m_signature = SignatureHelper.GetMethodSigHelper(m_module, m_callingConvention, m_inst != null ? m_inst.Length : 0, m_returnType == null ? typeof(void) : m_returnType, m_returnTypeRequiredCustomModifiers, m_returnTypeOptionalCustomModifiers, m_parameterTypes, m_parameterTypeRequiredCustomModifiers, m_parameterTypeOptionalCustomModifiers);
  361.            
  362.             return m_signature;
  363.         }
  364.        
  365.         internal SignatureHelper GetLocalsSignature()
  366.         {
  367.             if (m_ilGenerator != null) {
  368.                 if (m_ilGenerator.m_localCount != 0) {
  369.                     // If user is using ILGenerator::DeclareLocal, then get local signaturefrom there.
  370.                     return m_ilGenerator.m_localSignature;
  371.                 }
  372.             }
  373.            
  374.             return m_localSignature;
  375.         }
  376.        
  377.         internal int GetNumberOfExceptions()
  378.         {
  379.             return m_numExceptions;
  380.         }
  381.        
  382.         internal __ExceptionInstance[] GetExceptionInstances()
  383.         {
  384.             return m_exceptions;
  385.         }
  386.        
  387.         internal int CalculateNumberOfExceptions(__ExceptionInfo[] excp)
  388.         {
  389.             int num = 0;
  390.            
  391.             if (excp == null) {
  392.                 return 0;
  393.             }
  394.            
  395.             for (int i = 0; i < excp.Length; i++) {
  396.                 num += excp[i].GetNumberOfCatches();
  397.             }
  398.            
  399.             return num;
  400.         }
  401.        
  402.         internal bool IsTypeCreated()
  403.         {
  404.             return (m_containingType != null && m_containingType.m_hasBeenCreated);
  405.         }
  406.        
  407.         internal TypeBuilder GetTypeBuilder()
  408.         {
  409.             return m_containingType;
  410.         }
  411.         #endregion
  412.        
  413.         #region Object Overrides
  414.         public override bool Equals(object obj)
  415.         {
  416.             if (!(obj is MethodBuilder)) {
  417.                 return false;
  418.             }
  419.             if (!(this.m_strName.Equals(((MethodBuilder)obj).m_strName))) {
  420.                 return false;
  421.             }
  422.            
  423.             if (m_iAttributes != (((MethodBuilder)obj).m_iAttributes)) {
  424.                 return false;
  425.             }
  426.            
  427.             SignatureHelper thatSig = ((MethodBuilder)obj).GetMethodSignature();
  428.             if (thatSig.Equals(GetMethodSignature())) {
  429.                 return true;
  430.             }
  431.             return false;
  432.         }
  433.        
  434.         public override int GetHashCode()
  435.         {
  436.             return this.m_strName.GetHashCode();
  437.         }
  438.        
  439.         public override string ToString()
  440.         {
  441.             StringBuilder sb = new StringBuilder(1000);
  442.             sb.Append("Name: " + m_strName + " " + Environment.NewLine);
  443.             sb.Append("Attributes: " + (int)m_iAttributes + Environment.NewLine);
  444.             sb.Append("Method Signature: " + GetMethodSignature() + Environment.NewLine);
  445.            
  446.             sb.Append(Environment.NewLine);
  447.             return sb.ToString();
  448.         }
  449.        
  450.         #endregion
  451.        
  452.         #region MemberInfo Overrides
  453.         public override string Name {
  454.             get { return m_strName; }
  455.         }
  456.        
  457.         internal override int MetadataTokenInternal {
  458.             get { return GetToken().Token; }
  459.         }
  460.        
  461.         public override Module Module {
  462.             get { return m_containingType.Module; }
  463.         }
  464.        
  465.         public override Type DeclaringType {
  466.             get {
  467.                 if (m_containingType.m_isHiddenGlobalType == true)
  468.                     return null;
  469.                 return m_containingType;
  470.             }
  471.         }
  472.        
  473.         public override ICustomAttributeProvider ReturnTypeCustomAttributes {
  474.             get { return null; }
  475.         }
  476.        
  477.         public override Type ReflectedType {
  478.             get {
  479.                 if (m_containingType.m_isHiddenGlobalType == true)
  480.                     return null;
  481.                 return m_containingType;
  482.             }
  483.         }
  484.        
  485.         #endregion
  486.        
  487.         #region MethodBase Overrides
  488.         public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  489.         {
  490.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  491.         }
  492.        
  493.         public override MethodImplAttributes GetMethodImplementationFlags()
  494.         {
  495.             return m_dwMethodImplFlags;
  496.         }
  497.        
  498.         public override MethodAttributes Attributes {
  499.             get { return m_iAttributes; }
  500.         }
  501.        
  502.         public override CallingConventions CallingConvention {
  503.             get { return m_callingConvention; }
  504.         }
  505.        
  506.         public override RuntimeMethodHandle MethodHandle {
  507.             get {
  508.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  509.             }
  510.         }
  511.        
  512.         #endregion
  513.        
  514.         #region MethodInfo Overrides
  515.         public override MethodInfo GetBaseDefinition()
  516.         {
  517.             return this;
  518.         }
  519.        
  520.         internal override Type GetReturnType()
  521.         {
  522.             return m_returnType;
  523.         }
  524.        
  525.         public override ParameterInfo[] GetParameters()
  526.         {
  527.             if (!m_bIsBaked)
  528.                 throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_TypeNotCreated"));
  529.            
  530.             Type rti = m_containingType.m_runtimeType;
  531.             MethodInfo rmi = rti.GetMethod(m_strName, m_parameterTypes);
  532.            
  533.             return rmi.GetParameters();
  534.         }
  535.        
  536.         public override ParameterInfo ReturnParameter {
  537.             get {
  538.                 if (!m_bIsBaked)
  539.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_TypeNotCreated"));
  540.                
  541.                 Type rti = m_containingType.m_runtimeType;
  542.                 MethodInfo rmi = rti.GetMethod(m_strName, m_parameterTypes);
  543.                
  544.                 return rmi.ReturnParameter;
  545.             }
  546.         }
  547.         #endregion
  548.        
  549.         #region ICustomAttributeProvider Implementation
  550.         public override object[] GetCustomAttributes(bool inherit)
  551.         {
  552.            
  553.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  554.         }
  555.        
  556.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  557.         {
  558.            
  559.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  560.         }
  561.        
  562.         public override bool IsDefined(Type attributeType, bool inherit)
  563.         {
  564.            
  565.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
  566.         }
  567.        
  568.         #endregion
  569.        
  570.         #region Generic Members
  571.         public override bool IsGenericMethodDefinition {
  572.             get { return m_bIsGenMethDef; }
  573.         }
  574.        
  575.         public override bool ContainsGenericParameters {
  576.             get {
  577.                 throw new NotSupportedException();
  578.             }
  579.         }
  580.        
  581.         public override MethodInfo GetGenericMethodDefinition()
  582.         {
  583.             if (!IsGenericMethod)
  584.                 throw new InvalidOperationException();
  585.             return this;
  586.         }
  587.        
  588.         public override bool IsGenericMethod {
  589.             get { return m_inst != null; }
  590.         }
  591.        
  592.         public override Type[] GetGenericArguments()
  593.         {
  594.             return m_inst;
  595.         }
  596.        
  597.         public override MethodInfo MakeGenericMethod(params Type[] typeArguments)
  598.         {
  599.             return new MethodBuilderInstantiation(this, typeArguments);
  600.         }
  601.        
  602.        
  603.         public GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names)
  604.         {
  605.             if (m_inst != null)
  606.                 throw new InvalidOperationException();
  607.            
  608.             if (names == null)
  609.                 throw new ArgumentNullException("names");
  610.            
  611.             for (int i = 0; i < names.Length; i++)
  612.                 if (names[i] == null)
  613.                     throw new ArgumentNullException("names");
  615.            
  616.             if (m_tkMethod.Token != 0)
  617.                 throw new InvalidOperationException();
  618.            
  619.             if (names.Length == 0)
  620.                 throw new ArgumentException();
  621.            
  622.             m_bIsGenMethDef = true;
  623.             m_inst = new GenericTypeParameterBuilder[names.Length];
  624.             for (int i = 0; i < names.Length; i++)
  625.                 m_inst[i] = new GenericTypeParameterBuilder(new TypeBuilder(names[i], i, this));
  626.            
  627.             return m_inst;
  628.         }
  629.        
  630.         internal void ThrowIfGeneric()
  631.         {
  632.             if (IsGenericMethod && !IsGenericMethodDefinition)
  633.                 throw new InvalidOperationException();
  634.         }
  635.         #endregion
  636.        
  637.         #region Public Members
  638.         public MethodToken GetToken()
  639.         {
  640.             if (m_tkMethod.Token == 0) {
  641.                 if (m_link != null)
  642.                     m_link.GetToken();
  643.                
  644.                 int sigLength;
  645.                 byte[] sigBytes = GetMethodSignature().InternalGetSignature(out sigLength);
  646.                
  647.                 m_tkMethod = new MethodToken(TypeBuilder.InternalDefineMethod(m_containingType.MetadataTokenInternal, m_strName, sigBytes, sigLength, Attributes, m_module));
  648.                
  649.                 if (m_inst != null)
  650.                     foreach (GenericTypeParameterBuilder tb in m_inst)
  651.                         if (!tb.m_type.IsCreated())
  652.                             tb.m_type.CreateType();
  655.                
  656.                 TypeBuilder.InternalSetMethodImpl(m_module, MetadataTokenInternal, m_dwMethodImplFlags);
  657.             }
  658.            
  659.             return m_tkMethod;
  660.         }
  661.        
  662.         public void SetParameters(params Type[] parameterTypes)
  663.         {
  664.             CheckContext(parameterTypes);
  665.             SetSignature(null, null, null, parameterTypes, null, null);
  666.         }
  667.        
  668.         public void SetReturnType(Type returnType)
  669.         {
  670.             CheckContext(returnType);
  671.             SetSignature(returnType, null, null, null, null, null);
  672.         }
  673.        
  674.         public void SetSignature(Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
  675.         {
  676.             CheckContext(returnType);
  677.             CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
  678.             CheckContext(parameterTypeRequiredCustomModifiers);
  679.             CheckContext(parameterTypeOptionalCustomModifiers);
  680.            
  681.             ThrowIfGeneric();
  682.            
  683.             if (returnType != null) {
  684.                 m_returnType = returnType;
  685.             }
  686.            
  687.             if (parameterTypes != null) {
  688.                 m_parameterTypes = new Type[parameterTypes.Length];
  689.                 Array.Copy(parameterTypes, m_parameterTypes, parameterTypes.Length);
  690.             }
  691.            
  692.             m_returnTypeRequiredCustomModifiers = returnTypeRequiredCustomModifiers;
  693.             m_returnTypeOptionalCustomModifiers = returnTypeOptionalCustomModifiers;
  694.             m_parameterTypeRequiredCustomModifiers = parameterTypeRequiredCustomModifiers;
  695.             m_parameterTypeOptionalCustomModifiers = parameterTypeOptionalCustomModifiers;
  696.         }
  697.        
  698.        
  699.         public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string strParamName)
  700.         {
  701.             ThrowIfGeneric();
  702.             m_containingType.ThrowIfCreated();
  703.            
  704.             if (position < 0)
  705.                 throw new ArgumentOutOfRangeException(Environment.GetResourceString("ArgumentOutOfRange_ParamSequence"));
  706.            
  707.             if (position > 0 && (m_parameterTypes == null || position > m_parameterTypes.Length))
  708.                 throw new ArgumentOutOfRangeException(Environment.GetResourceString("ArgumentOutOfRange_ParamSequence"));
  709.            
  710.             attributes = attributes & ~ParameterAttributes.ReservedMask;
  711.             return new ParameterBuilder(this, position, attributes, strParamName);
  712.         }
  713.        
  714.         [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
  715.         public void SetMarshal(UnmanagedMarshal unmanagedMarshal)
  716.         {
  717.             ThrowIfGeneric();
  718.            
  719.             // set Marshal info for the return type
  720.            
  721.             m_containingType.ThrowIfCreated();
  722.            
  723.             if (m_retParam == null) {
  724.                 m_retParam = new ParameterBuilder(this, 0, 0, null);
  725.             }
  726.            
  727.             m_retParam.SetMarshal(unmanagedMarshal);
  728.         }
  729.        
  730.         private ArrayList m_symCustomAttrs;
  731.         private struct SymCustomAttr
  732.         {
  733.             public SymCustomAttr(string name, byte[] data)
  734.             {
  735.                 m_name = name;
  736.                 m_data = data;
  737.             }
  738.             public string m_name;
  739.             public byte[] m_data;
  740.         }
  741.        
  742.         public void SetSymCustomAttribute(string name, byte[] data)
  743.         {
  744.             ThrowIfGeneric();
  745.            
  746.             // This is different from CustomAttribute. This is stored into the SymWriter.
  747.             m_containingType.ThrowIfCreated();
  748.            
  749.             ModuleBuilder dynMod = (ModuleBuilder)m_module;
  750.             if (dynMod.GetSymWriter() == null) {
  751.                 // Cannot SetSymCustomAttribute when it is not a debug module
  752.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotADebugModule"));
  753.             }
  754.            
  755.             if (m_symCustomAttrs == null)
  756.                 m_symCustomAttrs = new ArrayList();
  757.            
  758.             m_symCustomAttrs.Add(new SymCustomAttr(name, data));
  759.         }
  760.        
  761.         public void AddDeclarativeSecurity(SecurityAction action, PermissionSet pset)
  762.         {
  763.             ThrowIfGeneric();
  764.            
  765.             if (pset == null)
  766.                 throw new ArgumentNullException("pset");
  767.            
  768.             if (!Enum.IsDefined(typeof(SecurityAction), action) || action == SecurityAction.RequestMinimum || action == SecurityAction.RequestOptional || action == SecurityAction.RequestRefuse)
  769.                 throw new ArgumentOutOfRangeException("action");
  770.            
  771.             // cannot declarative security after type is created
  772.             m_containingType.ThrowIfCreated();
  773.            
  774.             // Translate permission set into serialized format (uses standard binary serialization format).
  775.             byte[] blob = null;
  776.             if (!pset.IsEmpty())
  777.                 blob = pset.EncodeXml();
  778.            
  779.             // Write the blob into the metadata.
  780.             TypeBuilder.InternalAddDeclarativeSecurity(m_module, MetadataTokenInternal, action, blob);
  781.         }
  782.        
  783.         public void CreateMethodBody(byte[] il, int count)
  784.         {
  785.             ThrowIfGeneric();
  786.            
  787.             // Note that when user calls this function, there are a few information that client is
  788.             // not able to supply: local signature, exception handlers, max stack size, a list of Token fixup, a list of RVA fixup
  789.            
  790.             if (m_bIsBaked) {
  791.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MethodBaked"));
  792.             }
  793.            
  794.             m_containingType.ThrowIfCreated();
  795.            
  796.             if (il != null && (count < 0 || count > il.Length))
  797.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  798.             if (il == null) {
  799.                 m_ubBody = null;
  800.                 return;
  801.             }
  802.             m_ubBody = new byte[count];
  803.             Array.Copy(il, m_ubBody, count);
  804.             m_bIsBaked = true;
  805.         }
  806.        
  807.