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

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 System.Reflection;
  21.     using System.Runtime.CompilerServices;
  22.     using System.Runtime.InteropServices;
  23.     using System.Security.Permissions;
  24.    
  25.     [ClassInterface(ClassInterfaceType.None)]
  26.     [ComDefaultInterface(typeof(_SignatureHelper))]
  27.     [System.Runtime.InteropServices.ComVisible(true)]
  28.     public sealed class SignatureHelper : _SignatureHelper
  29.     {
  30.         #region Consts Fields
  31.         internal const int mdtTypeRef = 16777216;
  32.         internal const int mdtTypeDef = 33554432;
  33.         internal const int mdtTypeSpec = 553648128;
  34.        
  35.         #region ElementType
  36.         //The following fields are duplicated from cor.h and must be kept in sync
  37.         internal const byte ELEMENT_TYPE_END = 0;
  38.         internal const byte ELEMENT_TYPE_VOID = 1;
  39.         internal const byte ELEMENT_TYPE_BOOLEAN = 2;
  40.         internal const byte ELEMENT_TYPE_CHAR = 3;
  41.         internal const byte ELEMENT_TYPE_I1 = 4;
  42.         internal const byte ELEMENT_TYPE_U1 = 5;
  43.         internal const byte ELEMENT_TYPE_I2 = 6;
  44.         internal const byte ELEMENT_TYPE_U2 = 7;
  45.         internal const byte ELEMENT_TYPE_I4 = 8;
  46.         internal const byte ELEMENT_TYPE_U4 = 9;
  47.         internal const byte ELEMENT_TYPE_I8 = 10;
  48.         internal const byte ELEMENT_TYPE_U8 = 11;
  49.         internal const byte ELEMENT_TYPE_R4 = 12;
  50.         internal const byte ELEMENT_TYPE_R8 = 13;
  51.         internal const byte ELEMENT_TYPE_STRING = 14;
  52.        
  53.         internal const byte ELEMENT_TYPE_PTR = 15;
  54.         // PTR <type>
  55.         internal const byte ELEMENT_TYPE_BYREF = 16;
  56.         // BYREF <type>
  57.         internal const byte ELEMENT_TYPE_VALUETYPE = 17;
  58.         // VALUETYPE <class Token>
  59.         internal const byte ELEMENT_TYPE_CLASS = 18;
  60.         // CLASS <class Token>
  61.         internal const byte ELEMENT_TYPE_VAR = 19;
  62.         // VAR <U1>
  63.         internal const byte ELEMENT_TYPE_ARRAY = 20;
  64.         // MDARRAY <type> <rank> <bcount> <bound1> ... <lbcount> <lb1> ...
  65.         internal const byte ELEMENT_TYPE_GENERICINST = 21;
  66.         // WITH <type> <ntypars> <type1> ... <typen>
  67.         internal const byte ELEMENT_TYPE_TYPEDBYREF = 22;
  68.         // This is a simple type.
  69.         internal const byte ELEMENT_TYPE_I = 24;
  70.         // native-pointer-sized integer.
  71.         internal const byte ELEMENT_TYPE_U = 25;
  72.         // native-pointer-sized unsigned integer.
  73.         internal const byte ELEMENT_TYPE_FNPTR = 27;
  74.         // FNPTR <complete sig for the function including calling convention>
  75.         internal const byte ELEMENT_TYPE_OBJECT = 28;
  76.         // Shortcut for System.Object
  77.         internal const byte ELEMENT_TYPE_SZARRAY = 29;
  78.         // SZARRAY <type> : Shortcut for single dimension zero lower bound array
  79.         internal const byte ELEMENT_TYPE_MVAR = 30;
  80.         // MVAR <U1>
  81.         internal const byte ELEMENT_TYPE_CMOD_REQD = 31;
  82.         // required C modifier : E_T_CMOD_REQD <mdTypeRef/mdTypeDef>
  83.         internal const byte ELEMENT_TYPE_CMOD_OPT = 32;
  84.         // optional C modifier : E_T_CMOD_OPT <mdTypeRef/mdTypeDef>
  85.         internal const byte ELEMENT_TYPE_INTERNAL = 33;
  86.        
  87.         internal const byte ELEMENT_TYPE_MAX = 34;
  88.         // first invalid element type
  89.         internal const byte ELEMENT_TYPE_SENTINEL = 65;
  90.         // SENTINEL for vararg
  91.         internal const byte ELEMENT_TYPE_PINNED = 69;
  92.         #endregion
  93.        
  94.         #region Unmanged Calling Convetions
  95.         internal const int IMAGE_CEE_UNMANAGED_CALLCONV_C = 1;
  96.         internal const int IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL = 2;
  97.         internal const int IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL = 3;
  98.         internal const int IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL = 4;
  99.         #endregion
  100.        
  101.         #region Managed Calling Conventions
  102.         internal const int IMAGE_CEE_CS_CALLCONV_DEFAULT = 0;
  103.         internal const int IMAGE_CEE_CS_CALLCONV_VARARG = 5;
  104.         internal const int IMAGE_CEE_CS_CALLCONV_FIELD = 6;
  105.         internal const int IMAGE_CEE_CS_CALLCONV_LOCAL_SIG = 7;
  106.         internal const int IMAGE_CEE_CS_CALLCONV_PROPERTY = 8;
  107.         internal const int IMAGE_CEE_CS_CALLCONV_UNMGD = 9;
  108.         internal const int IMAGE_CEE_CS_CALLCONV_GENERICINST = 10;
  109.         internal const int IMAGE_CEE_CS_CALLCONV_MAX = 11;
  110.         // first invalid calling convention
  111.         #endregion
  112.         #region Misc
  113.         // The high bits of the calling convention convey additional info
  114.         internal const int IMAGE_CEE_CS_CALLCONV_MASK = 15;
  115.         // Calling convention is bottom 4 bits
  116.         internal const int IMAGE_CEE_CS_CALLCONV_GENERIC = 16;
  117.         // Generic method sig with explicit number of type parameters
  118.         internal const int IMAGE_CEE_CS_CALLCONV_HASTHIS = 32;
  119.         // Top bit indicates a 'this' parameter
  120.         internal const int IMAGE_CEE_CS_CALLCONV_RETPARAM = 64;
  121.         // The first param in the sig is really the return value
  122.         internal const int NO_SIZE_IN_SIG = -1;
  123.         #endregion
  124.        
  125.         #endregion
  126.        
  127.         #region Static Members
  128.         public static SignatureHelper GetMethodSigHelper(Module mod, Type returnType, Type[] parameterTypes)
  129.         {
  130.             return GetMethodSigHelper(mod, CallingConventions.Standard, returnType, null, null, parameterTypes, null, null);
  131.         }
  132.        
  133.         /// <include file='doc\SignatureHelper.uex' path='docs/doc[@for="SignatureHelper.GetMethodSigHelper"]/*' />
  134.         static internal SignatureHelper GetMethodSigHelper(Module mod, CallingConventions callingConvention, Type returnType, int cGenericParam)
  135.         {
  136.             return GetMethodSigHelper(mod, callingConvention, cGenericParam, returnType, null, null, null, null, null);
  137.         }
  138.        
  139.         public static SignatureHelper GetMethodSigHelper(Module mod, CallingConventions callingConvention, Type returnType)
  140.         {
  141.             return GetMethodSigHelper(mod, callingConvention, returnType, null, null, null, null, null);
  142.         }
  143.        
  144.         static internal SignatureHelper GetMethodSpecSigHelper(Module scope, Type[] inst)
  145.         {
  146.             SignatureHelper sigHelp = new SignatureHelper(scope, IMAGE_CEE_CS_CALLCONV_GENERICINST);
  147.             sigHelp.AddData(inst.Length);
  148.             foreach (Type t in inst)
  149.                 sigHelp.AddArgument(t);
  150.             return sigHelp;
  151.         }
  152.        
  153.         static internal SignatureHelper GetMethodSigHelper(Module scope, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
  154.         {
  155.             return GetMethodSigHelper(scope, callingConvention, 0, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
  156.         }
  157.        
  158.         static internal SignatureHelper GetMethodSigHelper(Module scope, CallingConventions callingConvention, int cGenericParam, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
  159.         {
  160.             SignatureHelper sigHelp;
  161.             int intCall;
  162.            
  163.             if (returnType == null) {
  164.                 returnType = typeof(void);
  165.             }
  166.            
  167.             intCall = IMAGE_CEE_CS_CALLCONV_DEFAULT;
  168.            
  169.             if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
  170.                 intCall = IMAGE_CEE_CS_CALLCONV_VARARG;
  171.            
  172.             if (cGenericParam > 0) {
  173.                 intCall |= IMAGE_CEE_CS_CALLCONV_GENERIC;
  174.             }
  175.            
  176.             if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
  177.                 intCall |= IMAGE_CEE_CS_CALLCONV_HASTHIS;
  178.            
  179.             sigHelp = new SignatureHelper(scope, intCall, cGenericParam, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers);
  180.             sigHelp.AddArguments(parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
  181.            
  182.             return sigHelp;
  183.         }
  184.        
  185.         public static SignatureHelper GetMethodSigHelper(Module mod, CallingConvention unmanagedCallConv, Type returnType)
  186.         {
  187.             SignatureHelper sigHelp;
  188.             int intCall;
  189.            
  190.             if (returnType == null)
  191.                 returnType = typeof(void);
  192.            
  193.             if (unmanagedCallConv == CallingConvention.Cdecl) {
  194.                 intCall = IMAGE_CEE_UNMANAGED_CALLCONV_C;
  195.             }
  196.             else if (unmanagedCallConv == CallingConvention.StdCall || unmanagedCallConv == CallingConvention.Winapi) {
  197.                 intCall = IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL;
  198.             }
  199.             else if (unmanagedCallConv == CallingConvention.ThisCall) {
  200.                 intCall = IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL;
  201.             }
  202.             else if (unmanagedCallConv == CallingConvention.FastCall) {
  203.                 intCall = IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL;
  204.             }
  205.             else {
  206.                 throw new ArgumentException(Environment.GetResourceString("Argument_UnknownUnmanagedCallConv"), "unmanagedCallConv");
  207.             }
  208.            
  209.             sigHelp = new SignatureHelper(mod, intCall, returnType, null, null);
  210.            
  211.             return sigHelp;
  212.         }
  213.        
  214.         public static SignatureHelper GetLocalVarSigHelper()
  215.         {
  216.             return GetLocalVarSigHelper(null);
  217.         }
  218.        
  219.         public static SignatureHelper GetMethodSigHelper(CallingConventions callingConvention, Type returnType)
  220.         {
  221.             return GetMethodSigHelper(null, callingConvention, returnType);
  222.         }
  223.        
  224.         public static SignatureHelper GetMethodSigHelper(CallingConvention unmanagedCallingConvention, Type returnType)
  225.         {
  226.             return GetMethodSigHelper(null, unmanagedCallingConvention, returnType);
  227.         }
  228.        
  229.         public static SignatureHelper GetLocalVarSigHelper(Module mod)
  230.         {
  231.             return new SignatureHelper(mod, IMAGE_CEE_CS_CALLCONV_LOCAL_SIG);
  232.         }
  233.        
  234.         public static SignatureHelper GetFieldSigHelper(Module mod)
  235.         {
  236.             return new SignatureHelper(mod, IMAGE_CEE_CS_CALLCONV_FIELD);
  237.         }
  238.        
  239.         public static SignatureHelper GetPropertySigHelper(Module mod, Type returnType, Type[] parameterTypes)
  240.         {
  241.             return GetPropertySigHelper(mod, returnType, null, null, parameterTypes, null, null);
  242.         }
  243.        
  244.         public static SignatureHelper GetPropertySigHelper(Module mod, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
  245.         {
  246.             SignatureHelper sigHelp;
  247.            
  248.             if (returnType == null) {
  249.                 returnType = typeof(void);
  250.             }
  251.            
  252.             sigHelp = new SignatureHelper(mod, IMAGE_CEE_CS_CALLCONV_PROPERTY, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers);
  253.             sigHelp.AddArguments(parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
  254.            
  255.             return sigHelp;
  256.         }
  257.        
  258.         static internal SignatureHelper GetTypeSigToken(Module mod, Type type)
  259.         {
  260.             if (mod == null)
  261.                 throw new ArgumentNullException("module");
  262.            
  263.             if (type == null)
  264.                 throw new ArgumentNullException("type");
  265.            
  266.             return new SignatureHelper(mod, type);
  267.         }
  268.         #endregion
  269.        
  270.         #region Private Data Members
  271.         private byte[] m_signature;
  272.         private int m_currSig;
  273.         // index into m_signature buffer for next available byte
  274.         private int m_sizeLoc;
  275.         // size of the m_signature buffer
  276.         private ModuleBuilder m_module;
  277.         private bool m_sigDone;
  278.         private int m_argCount;
  279.         // tracking number of arguments in the signature
  280.         #endregion
  281.         #region Constructor
  282.         private SignatureHelper(Module mod, int callingConvention)
  283.         {
  284.             // Use this constructor to instantiate a local var sig or Field where return type is not applied.
  285.             Init(mod, callingConvention);
  286.         }
  287.        
  288.         private SignatureHelper(Module mod, int callingConvention, int cGenericParameters, Type returnType, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers)
  289.         {
  290.             // Use this constructor to instantiate a any signatures that will require a return type.
  291.             Init(mod, callingConvention, cGenericParameters);
  292.            
  293.             if (callingConvention == IMAGE_CEE_CS_CALLCONV_FIELD)
  294.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadFieldSig"));
  295.            
  296.             AddOneArgTypeHelper(returnType, requiredCustomModifiers, optionalCustomModifiers);
  297.         }
  298.        
  299.         private SignatureHelper(Module mod, int callingConvention, Type returnType, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers) : this(mod, callingConvention, 0, returnType, requiredCustomModifiers, optionalCustomModifiers)
  300.         {
  301.         }
  302.        
  303.         private SignatureHelper(Module mod, Type type)
  304.         {
  305.             Init(mod);
  306.            
  307.             AddOneArgTypeHelper(type);
  308.         }
  309.        
  310.         private void Init(Module mod)
  311.         {
  312.             m_signature = new byte[32];
  313.             m_currSig = 0;
  314.             m_module = mod as ModuleBuilder;
  315.             m_argCount = 0;
  316.             m_sigDone = false;
  317.             m_sizeLoc = NO_SIZE_IN_SIG;
  318.            
  319.             if (m_module == null && mod != null)
  320.                 throw new ArgumentException(Environment.GetResourceString("NotSupported_MustBeModuleBuilder"));
  321.         }
  322.        
  323.         private void Init(Module mod, int callingConvention)
  324.         {
  325.             Init(mod, callingConvention, 0);
  326.         }
  327.        
  328.         private void Init(Module mod, int callingConvention, int cGenericParam)
  329.         {
  330.             Init(mod);
  331.            
  332.             AddData(callingConvention);
  333.            
  334.             if (callingConvention == IMAGE_CEE_CS_CALLCONV_FIELD || callingConvention == IMAGE_CEE_CS_CALLCONV_GENERICINST) {
  335.                 m_sizeLoc = NO_SIZE_IN_SIG;
  336.             }
  337.             else {
  338.                 if (cGenericParam > 0)
  339.                     AddData(cGenericParam);
  340.                
  341.                 m_sizeLoc = m_currSig++;
  342.             }
  343.         }
  344.        
  345.         #endregion
  346.        
  347.         #region Private Members
  348.         private void AddOneArgTypeHelper(Type argument, bool pinned)
  349.         {
  350.             if (pinned)
  351.                 AddElementType(ELEMENT_TYPE_PINNED);
  352.            
  353.             AddOneArgTypeHelper(argument);
  354.         }
  355.        
  356.         private void AddOneArgTypeHelper(Type clsArgument, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers)
  357.         {
  358.             // This function will not increase the argument count. It only fills in bytes
  359.             // in the signature based on clsArgument. This helper is called for return type.
  360.            
  361.             ASSERT.PRECONDITION(clsArgument != null);
  362.             ASSERT.PRECONDITION((optionalCustomModifiers == null && requiredCustomModifiers == null) || !clsArgument.ContainsGenericParameters);
  363.             ASSERT.PRECONDITION(requiredCustomModifiers == null || Array.IndexOf(requiredCustomModifiers, null) == -1);
  364.             ASSERT.PRECONDITION(optionalCustomModifiers == null || Array.IndexOf(optionalCustomModifiers, null) == -1);
  365.            
  366.             if (optionalCustomModifiers != null) {
  367.                 for (int i = 0; i < optionalCustomModifiers.Length; i++) {
  368.                     AddElementType(ELEMENT_TYPE_CMOD_OPT);
  369.                     ASSERT.CONSISTENCY_CHECK(!MetadataToken.IsNullToken(optionalCustomModifiers[i].MetadataTokenInternal));
  370.                     AddToken(m_module.GetTypeToken(optionalCustomModifiers[i]).Token);
  371.                 }
  372.             }
  373.            
  374.             if (requiredCustomModifiers != null) {
  375.                 for (int i = 0; i < requiredCustomModifiers.Length; i++) {
  376.                     AddElementType(ELEMENT_TYPE_CMOD_REQD);
  377.                     ASSERT.CONSISTENCY_CHECK(!MetadataToken.IsNullToken(requiredCustomModifiers[i].MetadataTokenInternal));
  378.                     AddToken(m_module.GetTypeToken(requiredCustomModifiers[i]).Token);
  379.                 }
  380.             }
  381.            
  382.             AddOneArgTypeHelper(clsArgument);
  383.         }
  384.        
  385.         private void AddOneArgTypeHelper(Type clsArgument)
  386.         {
  387.             AddOneArgTypeHelperWorker(clsArgument, false);
  388.         }
  389.         private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst)
  390.         {
  391.             if (clsArgument.IsGenericParameter) {
  392.                 if (clsArgument.DeclaringMethod != null)
  393.                     AddData(ELEMENT_TYPE_MVAR);
  394.                 else
  395.                     AddData(ELEMENT_TYPE_VAR);
  396.                
  397.                 AddData(clsArgument.GenericParameterPosition);
  398.             }
  399.             else if (clsArgument.IsGenericType && (!clsArgument.IsGenericTypeDefinition || !lastWasGenericInst)) {
  400.                 AddElementType(ELEMENT_TYPE_GENERICINST);
  401.                
  402.                 AddOneArgTypeHelperWorker(clsArgument.GetGenericTypeDefinition(), true);
  403.                
  404.                 Type[] args = clsArgument.GetGenericArguments();
  405.                
  406.                 AddData(args.Length);
  407.                
  408.                 foreach (Type t in args)
  409.                     AddOneArgTypeHelper(t);
  410.             }
  411.             else if (clsArgument is TypeBuilder) {
  412.                 TypeBuilder clsBuilder = (TypeBuilder)clsArgument;
  413.                 TypeToken tkType;
  414.                
  415.                 if (clsBuilder.Module == m_module) {
  416.                     tkType = clsBuilder.TypeToken;
  417.                 }
  418.                 else {
  419.                     tkType = m_module.GetTypeToken(clsArgument);
  420.                 }
  421.                
  422.                 if (clsArgument.IsValueType) {
  423.                     InternalAddTypeToken(tkType, ELEMENT_TYPE_VALUETYPE);
  424.                 }
  425.                 else {
  426.                     InternalAddTypeToken(tkType, ELEMENT_TYPE_CLASS);
  427.                 }
  428.             }
  429.             else if (clsArgument is EnumBuilder) {
  430.                 TypeBuilder clsBuilder = ((EnumBuilder)clsArgument).m_typeBuilder;
  431.                 TypeToken tkType;
  432.                
  433.                 if (clsBuilder.Module == m_module) {
  434.                     tkType = clsBuilder.TypeToken;
  435.                 }
  436.                 else {
  437.                     tkType = m_module.GetTypeToken(clsArgument);
  438.                 }
  439.                
  440.                 if (clsArgument.IsValueType) {
  441.                     InternalAddTypeToken(tkType, ELEMENT_TYPE_VALUETYPE);
  442.                 }
  443.                 else {
  444.                     InternalAddTypeToken(tkType, ELEMENT_TYPE_CLASS);
  445.                 }
  446.             }
  447.             else if (clsArgument.IsByRef) {
  448.                 AddElementType(ELEMENT_TYPE_BYREF);
  449.                 clsArgument = clsArgument.GetElementType();
  450.                 AddOneArgTypeHelper(clsArgument);
  451.             }
  452.             else if (clsArgument.IsPointer) {
  453.                 AddElementType(ELEMENT_TYPE_PTR);
  454.                 AddOneArgTypeHelper(clsArgument.GetElementType());
  455.             }
  456.             else if (clsArgument.IsArray) {
  457.                 if (clsArgument.IsSzArray) {
  458.                     AddElementType(ELEMENT_TYPE_SZARRAY);
  459.                    
  460.                     AddOneArgTypeHelper(clsArgument.GetElementType());
  461.                 }
  462.                 else {
  463.                     AddElementType(ELEMENT_TYPE_ARRAY);
  464.                    
  465.                     AddOneArgTypeHelper(clsArgument.GetElementType());
  466.                    
  467.                     // put the rank information
  468.                     AddData(clsArgument.GetArrayRank());
  469.                    
  470.                     AddData(0);
  471.                     AddData(0);
  472.                 }
  473.             }
  474.             else {
  475.                 RuntimeType rType = clsArgument as RuntimeType;
  476.                 int type = rType != null ? GetCorElementTypeFromClass(rType) : ELEMENT_TYPE_MAX;
  477.                
  478.                 if (IsSimpleType(type)) {
  479.                     AddElementType(type);
  480.                 }
  481.                 else {
  482.                     if (clsArgument == typeof(object)) {
  483.                         AddElementType(ELEMENT_TYPE_OBJECT);
  484.                     }
  485.                     else if (clsArgument == typeof(string)) {
  486.                         AddElementType(ELEMENT_TYPE_STRING);
  487.                     }
  488.                     else {
  489.                         if (m_module == null) {
  490.                             InternalAddRuntimeType(rType);
  491.                         }
  492.                         else {
  493.                             if (clsArgument.IsValueType) {
  494.                                 InternalAddTypeToken(m_module.GetTypeToken(clsArgument), ELEMENT_TYPE_VALUETYPE);
  495.                             }
  496.                             else {
  497.                                 InternalAddTypeToken(m_module.GetTypeToken(clsArgument), ELEMENT_TYPE_CLASS);
  498.                             }
  499.                         }
  500.                     }
  501.                 }
  502.             }
  503.         }
  504.        
  505.         private void AddData(int data)
  506.         {
  507.             // A managed representation of CorSigCompressData;
  508.            
  509.             if (m_currSig + 4 >= m_signature.Length) {
  510.                 m_signature = ExpandArray(m_signature);
  511.             }
  512.            
  513.             if (data <= 127) {
  514.                 m_signature[m_currSig++] = (byte)(data & 255);
  515.             }
  516.             else if (data <= 16383) {
  517.                 m_signature[m_currSig++] = (byte)((data >> 8) | 128);
  518.                 m_signature[m_currSig++] = (byte)(data & 255);
  519.             }
  520.             else if (data <= 536870911) {
  521.                 m_signature[m_currSig++] = (byte)((data >> 24) | 192);
  522.                 m_signature[m_currSig++] = (byte)((data >> 16) & 255);
  523.                 m_signature[m_currSig++] = (byte)((data >> 8) & 255);
  524.                 m_signature[m_currSig++] = (byte)((data)&255);
  525.             }
  526.             else {
  527.                 throw new ArgumentException(Environment.GetResourceString("Argument_LargeInteger"));
  528.             }
  529.            
  530.         }
  531.        
  532.         private void AddData(uint data)
  533.         {
  534.             if (m_currSig + 4 >= m_signature.Length) {
  535.                 m_signature = ExpandArray(m_signature);
  536.             }
  537.            
  538.             m_signature[m_currSig++] = (byte)((data)&255);
  539.             m_signature[m_currSig++] = (byte)((data >> 8) & 255);
  540.             m_signature[m_currSig++] = (byte)((data >> 16) & 255);
  541.             m_signature[m_currSig++] = (byte)((data >> 24) & 255);
  542.         }
  543.        
  544.         private void AddData(ulong data)
  545.         {
  546.             if (m_currSig + 8 >= m_signature.Length) {
  547.                 m_signature = ExpandArray(m_signature);
  548.             }
  549.            
  550.             m_signature[m_currSig++] = (byte)((data)&255);
  551.             m_signature[m_currSig++] = (byte)((data >> 8) & 255);
  552.             m_signature[m_currSig++] = (byte)((data >> 16) & 255);
  553.             m_signature[m_currSig++] = (byte)((data >> 24) & 255);
  554.             m_signature[m_currSig++] = (byte)((data >> 32) & 255);
  555.             m_signature[m_currSig++] = (byte)((data >> 40) & 255);
  556.             m_signature[m_currSig++] = (byte)((data >> 48) & 255);
  557.             m_signature[m_currSig++] = (byte)((data >> 56) & 255);
  558.         }
  559.        
  560.         private void AddElementType(int cvt)
  561.         {
  562.             // Adds an element to the signature. A managed represenation of CorSigCompressElement
  563.             if (m_currSig + 1 >= m_signature.Length)
  564.                 m_signature = ExpandArray(m_signature);
  565.            
  566.             m_signature[m_currSig++] = (byte)cvt;
  567.         }
  568.        
  569.         private void AddToken(int token)
  570.         {
  571.             // A managed represenation of CompressToken
  572.             // Pulls the token appart to get a rid, adds some appropriate bits
  573.             // to the token and then adds this to the signature.
  574.            
  575.             int rid = (token & 16777215);
  576.             //This is RidFromToken;
  577.             int type = (token & unchecked((int)4278190080u));
  578.             //This is TypeFromToken;
  579.             if (rid > 67108863) {
  580.                 // token is too big to be compressed
  581.                 throw new ArgumentException(Environment.GetResourceString("Argument_LargeInteger"));
  582.             }
  583.            
  584.             rid = (rid << 2);
  585.            
  586.             // TypeDef is encoded with low bits 00
  587.             // TypeRef is encoded with low bits 01
  588.             // TypeSpec is encoded with low bits 10
  589.             if (type == mdtTypeRef) {
  590.                 //if type is mdtTypeRef
  591.                 rid |= 1;
  592.             }
  593.             else if (type == mdtTypeSpec) {
  594.                 //if type is mdtTypeSpec
  595.                 rid |= 2;
  596.             }
  597.            
  598.             AddData(rid);
  599.         }
  600.        
  601.         private void InternalAddTypeToken(TypeToken clsToken, int CorType)
  602.         {
  603.             // Add a type token into signature. CorType will be either ELEMENT_TYPE_CLASS or ELEMENT_TYPE_VALUECLASS
  604.             AddElementType(CorType);
  605.             AddToken(clsToken.Token);
  606.         }
  607.        
  608.         unsafe private void InternalAddRuntimeType(Type type)
  609.         {
  610.             // Add a runtime type into the signature.
  611.            
  612.             AddElementType(ELEMENT_TYPE_INTERNAL);
  613.         }
  614.        
  615.         void* handle = (void*)type.GetTypeHandleInternal().Value;
  616.     }
  617. }

Developer Fusion