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.Runtime.InteropServices \ InterfaceTypeAttribute

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. ////////////////////////////////////////////////////////////////////////////////
  16. ////////////////////////////////////////////////////////////////////////////////
  17. namespace System.Runtime.InteropServices
  18. {
  19.    
  20.     using System;
  21.     using System.Reflection;
  22.    
  23.     [AttributeUsage(AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
  24.     [System.Runtime.InteropServices.ComVisible(true)]
  25.     public sealed class UnmanagedFunctionPointerAttribute : Attribute
  26.     {
  27.         CallingConvention m_callingConvention;
  28.        
  29.         public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention)
  30.         {
  31.             m_callingConvention = callingConvention;
  32.         }
  33.        
  34.         public CallingConvention CallingConvention {
  35.             get { return m_callingConvention; }
  36.         }
  37.        
  38.         public CharSet CharSet;
  39.         public bool BestFitMapping;
  40.         public bool ThrowOnUnmappableChar;
  41.         public bool SetLastError;
  42.         //public bool PreserveSig;
  43.     }
  44.    
  45.     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Event, Inherited = false)]
  46.     [System.Runtime.InteropServices.ComVisible(true)]
  47.     public sealed class DispIdAttribute : Attribute
  48.     {
  49.         internal int _val;
  50.         public DispIdAttribute(int dispId)
  51.         {
  52.             _val = dispId;
  53.         }
  54.         public int Value {
  55.             get { return _val; }
  56.         }
  57.     }
  58.    
  59.     [Serializable()]
  60.     [System.Runtime.InteropServices.ComVisible(true)]
  61.     public enum ComInterfaceType
  62.     {
  63.         InterfaceIsDual = 0,
  64.         InterfaceIsIUnknown = 1,
  65.         InterfaceIsIDispatch = 2
  66.     }
  67.    
  68.     [AttributeUsage(AttributeTargets.Interface, Inherited = false)]
  69.     [System.Runtime.InteropServices.ComVisible(true)]
  70.     public sealed class InterfaceTypeAttribute : Attribute
  71.     {
  72.         internal ComInterfaceType _val;
  73.         public InterfaceTypeAttribute(ComInterfaceType interfaceType)
  74.         {
  75.             _val = interfaceType;
  76.         }
  77.         public InterfaceTypeAttribute(short interfaceType)
  78.         {
  79.             _val = (ComInterfaceType)interfaceType;
  80.         }
  81.         public ComInterfaceType Value {
  82.             get { return _val; }
  83.         }
  84.     }
  85.    
  86.     [AttributeUsage(AttributeTargets.Class, Inherited = false)]
  87.     [System.Runtime.InteropServices.ComVisible(true)]
  88.     public sealed class ComDefaultInterfaceAttribute : Attribute
  89.     {
  90.         internal Type _val;
  91.        
  92.         public ComDefaultInterfaceAttribute(Type defaultInterface)
  93.         {
  94.             _val = defaultInterface;
  95.         }
  96.        
  97.         public Type Value {
  98.             get { return _val; }
  99.         }
  100.     }
  101.    
  102.     [Serializable()]
  103.     [System.Runtime.InteropServices.ComVisible(true)]
  104.     public enum ClassInterfaceType
  105.     {
  106.         None = 0,
  107.         AutoDispatch = 1,
  108.         AutoDual = 2
  109.     }
  110.    
  111.     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, Inherited = false)]
  112.     [System.Runtime.InteropServices.ComVisible(true)]
  113.     public sealed class ClassInterfaceAttribute : Attribute
  114.     {
  115.         internal ClassInterfaceType _val;
  116.         public ClassInterfaceAttribute(ClassInterfaceType classInterfaceType)
  117.         {
  118.             _val = classInterfaceType;
  119.            
  120.         }
  121.         public ClassInterfaceAttribute(short classInterfaceType)
  122.         {
  123.             _val = (ClassInterfaceType)classInterfaceType;
  124.         }
  125.         public ClassInterfaceType Value {
  126.             get { return _val; }
  127.         }
  128.     }
  129.    
  130.     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Delegate | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)]
  131.     [System.Runtime.InteropServices.ComVisible(true)]
  132.     public sealed class ComVisibleAttribute : Attribute
  133.     {
  134.         internal bool _val;
  135.         public ComVisibleAttribute(bool visibility)
  136.         {
  137.             _val = visibility;
  138.         }
  139.         public bool Value {
  140.             get { return _val; }
  141.         }
  142.     }
  143.    
  144.     [AttributeUsage(AttributeTargets.Interface, Inherited = false)]
  145.     [System.Runtime.InteropServices.ComVisible(true)]
  146.     public sealed class TypeLibImportClassAttribute : Attribute
  147.     {
  148.         internal string _importClassName;
  149.         public TypeLibImportClassAttribute(Type importClass)
  150.         {
  151.             _importClassName = importClass.ToString();
  152.         }
  153.         public string Value {
  154.             get { return _importClassName; }
  155.         }
  156.     }
  157.    
  158.    
  159.     [Serializable()]
  160.     [System.Runtime.InteropServices.ComVisible(true)]
  161.     public enum VarEnum
  162.     {
  163.         VT_EMPTY = 0,
  164.         VT_NULL = 1,
  165.         VT_I2 = 2,
  166.         VT_I4 = 3,
  167.         VT_R4 = 4,
  168.         VT_R8 = 5,
  169.         VT_CY = 6,
  170.         VT_DATE = 7,
  171.         VT_BSTR = 8,
  172.         VT_ERROR = 10,
  173.         VT_BOOL = 11,
  174.         VT_VARIANT = 12,
  175.         VT_UNKNOWN = 13,
  176.         VT_DECIMAL = 14,
  177.         VT_I1 = 16,
  178.         VT_UI1 = 17,
  179.         VT_UI2 = 18,
  180.         VT_UI4 = 19,
  181.         VT_I8 = 20,
  182.         VT_UI8 = 21,
  183.         VT_INT = 22,
  184.         VT_UINT = 23,
  185.         VT_VOID = 24,
  186.         VT_HRESULT = 25,
  187.         VT_PTR = 26,
  188.         VT_SAFEARRAY = 27,
  189.         VT_CARRAY = 28,
  190.         VT_USERDEFINED = 29,
  191.         VT_LPSTR = 30,
  192.         VT_LPWSTR = 31,
  193.         VT_RECORD = 36,
  194.         VT_FILETIME = 64,
  195.         VT_BLOB = 65,
  196.         VT_STREAM = 66,
  197.         VT_STORAGE = 67,
  198.         VT_STREAMED_OBJECT = 68,
  199.         VT_STORED_OBJECT = 69,
  200.         VT_BLOB_OBJECT = 70,
  201.         VT_CF = 71,
  202.         VT_CLSID = 72,
  203.         VT_VECTOR = 4096,
  204.         VT_ARRAY = 8192,
  205.         VT_BYREF = 16384
  206.     }
  207.    
  208.     [Serializable()]
  209.     [System.Runtime.InteropServices.ComVisible(true)]
  210.     public enum UnmanagedType
  211.     {
  212.         Bool = 2,
  213.         // 4 byte boolean value (true != 0, false == 0)
  214.         I1 = 3,
  215.         // 1 byte signed value
  216.         U1 = 4,
  217.         // 1 byte unsigned value
  218.         I2 = 5,
  219.         // 2 byte signed value
  220.         U2 = 6,
  221.         // 2 byte unsigned value
  222.         I4 = 7,
  223.         // 4 byte signed value
  224.         U4 = 8,
  225.         // 4 byte unsigned value
  226.         I8 = 9,
  227.         // 8 byte signed value
  228.         U8 = 10,
  229.         // 8 byte unsigned value
  230.         R4 = 11,
  231.         // 4 byte floating point
  232.         R8 = 12,
  233.         // 8 byte floating point
  234.         Currency = 15,
  235.         // A currency
  236.        
  237.         LPStr = 20,
  238.         // Ptr to SBCS string
  239.         LPWStr = 21,
  240.         // Ptr to Unicode string
  241.         LPTStr = 22,
  242.         // Ptr to OS preferred (SBCS/Unicode) string
  243.         ByValTStr = 23,
  244.         // OS preferred (SBCS/Unicode) inline string (only valid in structs)
  245.         IUnknown = 25,
  246.         // COM IUnknown pointer.
  247.        
  248.         Struct = 27,
  249.         // Structure
  250.        
  251.         ByValArray = 30,
  252.         // Array of fixed size (only valid in structs)
  253.         SysInt = 31,
  254.         // Hardware natural sized signed integer
  255.         SysUInt = 32,
  256.        
  257.        
  258.         FunctionPtr = 38,
  259.         // Function pointer
  260.         AsAny = 40,
  261.         // Paired with Object type and does runtime marshalling determination
  262.         LPArray = 42,
  263.         // C style array
  264.         LPStruct = 43,
  265.         // Pointer to a structure
  266.         CustomMarshaler = 44,
  267.        
  268.         Error = 45
  269.     }
  270.    
  271.     [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.ReturnValue, Inherited = false)]
  272.     [System.Runtime.InteropServices.ComVisible(true)]
  273.     unsafe public sealed class MarshalAsAttribute : Attribute
  274.     {
  275.         static internal Attribute GetCustomAttribute(ParameterInfo parameter)
  276.         {
  277.             return GetCustomAttribute(parameter.MetadataToken, parameter.Member.Module);
  278.         }
  279.        
  280.         static internal bool IsDefined(ParameterInfo parameter)
  281.         {
  282.             return GetCustomAttribute(parameter) != null;
  283.         }
  284.        
  285.         static internal Attribute GetCustomAttribute(RuntimeFieldInfo field)
  286.         {
  287.             return GetCustomAttribute(field.MetadataToken, field.Module);
  288.             ;
  289.         }
  290.        
  291.         static internal bool IsDefined(RuntimeFieldInfo field)
  292.         {
  293.             return GetCustomAttribute(field) != null;
  294.         }
  295.        
  296.         static internal Attribute GetCustomAttribute(int token, Module scope)
  297.         {
  298.             UnmanagedType unmanagedType;
  299.             UnmanagedType arraySubType;
  300.             VarEnum safeArraySubType;
  301.             int sizeParamIndex = 0;
  302.             int sizeConst = 0;
  303.             string marshalTypeName = null;
  304.             string marshalCookie = null;
  305.             string safeArrayUserDefinedTypeName = null;
  306.             int iidParamIndex = 0;
  307.            
  308.             ConstArray nativeType = scope.ModuleHandle.GetMetadataImport().GetFieldMarshal(token);
  309.            
  310.             if (nativeType.Length == 0)
  311.                 return null;
  312.            
  313.             MetadataImport.GetMarshalAs(nativeType, out unmanagedType, out safeArraySubType, out safeArrayUserDefinedTypeName, out arraySubType, out sizeParamIndex, out sizeConst, out marshalTypeName, out marshalCookie, out iidParamIndex
  314.             );
  315.            
  316.             Type safeArrayUserDefinedType = safeArrayUserDefinedTypeName == null || safeArrayUserDefinedTypeName.Length == 0 ? null : RuntimeTypeHandle.GetTypeByNameUsingCARules(safeArrayUserDefinedTypeName, scope);
  317.             Type marshalTypeRef = null;
  318.            
  319.             try {
  320.                 marshalTypeRef = marshalTypeName == null ? null : RuntimeTypeHandle.GetTypeByNameUsingCARules(marshalTypeName, scope);
  321.             }
  322.             catch (System.TypeLoadException) {
  323.                 // The user may have supplied a bad type name string causing this TypeLoadException
  324.                 // Regardless, we return the bad type name
  325.                 ASSERT.CONSISTENCY_CHECK(marshalTypeName != null);
  326.             }
  327.            
  328.             return new MarshalAsAttribute(unmanagedType, safeArraySubType, safeArrayUserDefinedType, arraySubType, (short)sizeParamIndex, sizeConst, marshalTypeName, marshalTypeRef, marshalCookie, iidParamIndex
  329.             );
  330.         }
  331.        
  332.         internal MarshalAsAttribute(UnmanagedType val, VarEnum safeArraySubType, Type safeArrayUserDefinedSubType, UnmanagedType arraySubType, short sizeParamIndex, int sizeConst, string marshalType, Type marshalTypeRef, string marshalCookie, int iidParamIndex
  333.         )
  334.         {
  335.             _val = val;
  336.             ArraySubType = arraySubType;
  337.             SizeParamIndex = sizeParamIndex;
  338.             SizeConst = sizeConst;
  339.             MarshalType = marshalType;
  340.             MarshalTypeRef = marshalTypeRef;
  341.             MarshalCookie = marshalCookie;
  342.         }
  343.        
  344.         internal UnmanagedType _val;
  345.         public MarshalAsAttribute(UnmanagedType unmanagedType)
  346.         {
  347.             _val = unmanagedType;
  348.         }
  349.         public MarshalAsAttribute(short unmanagedType)
  350.         {
  351.             _val = (UnmanagedType)unmanagedType;
  352.         }
  353.         public UnmanagedType Value {
  354.             get { return _val; }
  355.         }
  356.        
  357.        
  358.         // Fields used with SubType = ByValArray and LPArray.
  359.         // Array size = parameter(PI) * PM + C
  360.         public UnmanagedType ArraySubType;
  361.         public short SizeParamIndex;
  362.         // param index PI
  363.         public int SizeConst;
  364.         // constant C
  365.         // Fields used with SubType = CustomMarshaler
  366.         [System.Runtime.InteropServices.ComVisible(true)]
  367.         public string MarshalType;
  368.         // Name of marshaler class
  369.         [System.Runtime.InteropServices.ComVisible(true)]
  370.         public Type MarshalTypeRef;
  371.         // Type of marshaler class
  372.         public string MarshalCookie;
  373.         // cookie to pass to marshaler
  374.     }
  375.    
  376.     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
  377.     [System.Runtime.InteropServices.ComVisible(true)]
  378.     public sealed class ComImportAttribute : Attribute
  379.     {
  380.         static internal Attribute GetCustomAttribute(RuntimeType type)
  381.         {
  382.             if ((type.Attributes & TypeAttributes.Import) == 0)
  383.                 return null;
  384.            
  385.             return new ComImportAttribute();
  386.         }
  387.        
  388.         static internal bool IsDefined(RuntimeType type)
  389.         {
  390.             return (type.Attributes & TypeAttributes.Import) != 0;
  391.         }
  392.        
  393.         public ComImportAttribute()
  394.         {
  395.         }
  396.     }
  397.    
  398.     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Delegate, Inherited = false)]
  399.     [System.Runtime.InteropServices.ComVisible(true)]
  400.     public sealed class GuidAttribute : Attribute
  401.     {
  402.         internal string _val;
  403.         public GuidAttribute(string guid)
  404.         {
  405.             _val = guid;
  406.         }
  407.         public string Value {
  408.             get { return _val; }
  409.         }
  410.     }
  411.    
  412.     [AttributeUsage(AttributeTargets.Method, Inherited = false)]
  413.     [System.Runtime.InteropServices.ComVisible(true)]
  414.     public sealed class PreserveSigAttribute : Attribute
  415.     {
  416.         static internal Attribute GetCustomAttribute(RuntimeMethodInfo method)
  417.         {
  418.             if ((method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) == 0)
  419.                 return null;
  420.            
  421.             return new PreserveSigAttribute();
  422.         }
  423.        
  424.         static internal bool IsDefined(RuntimeMethodInfo method)
  425.         {
  426.             return (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != 0;
  427.         }
  428.        
  429.         public PreserveSigAttribute()
  430.         {
  431.         }
  432.     }
  433.    
  434.     [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
  435.     [System.Runtime.InteropServices.ComVisible(true)]
  436.     public sealed class InAttribute : Attribute
  437.     {
  438.         static internal Attribute GetCustomAttribute(ParameterInfo parameter)
  439.         {
  440.             return parameter.IsIn ? new InAttribute() : null;
  441.         }
  442.         static internal bool IsDefined(ParameterInfo parameter)
  443.         {
  444.             return parameter.IsIn;
  445.         }
  446.        
  447.         public InAttribute()
  448.         {
  449.         }
  450.     }
  451.    
  452.     [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
  453.     [System.Runtime.InteropServices.ComVisible(true)]
  454.     public sealed class OutAttribute : Attribute
  455.     {
  456.         static internal Attribute GetCustomAttribute(ParameterInfo parameter)
  457.         {
  458.             return parameter.IsOut ? new OutAttribute() : null;
  459.         }
  460.         static internal bool IsDefined(ParameterInfo parameter)
  461.         {
  462.             return parameter.IsOut;
  463.         }
  464.        
  465.         public OutAttribute()
  466.         {
  467.         }
  468.     }
  469.    
  470.     [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
  471.     [System.Runtime.InteropServices.ComVisible(true)]
  472.     public sealed class OptionalAttribute : Attribute
  473.     {
  474.         static internal Attribute GetCustomAttribute(ParameterInfo parameter)
  475.         {
  476.             return parameter.IsOptional ? new OptionalAttribute() : null;
  477.         }
  478.         static internal bool IsDefined(ParameterInfo parameter)
  479.         {
  480.             return parameter.IsOptional;
  481.         }
  482.        
  483.         public OptionalAttribute()
  484.         {
  485.         }
  486.     }
  487.    
  488.     [AttributeUsage(AttributeTargets.Method, Inherited = false)]
  489.     [System.Runtime.InteropServices.ComVisible(true)]
  490.     unsafe public sealed class DllImportAttribute : Attribute
  491.     {
  492.         static internal Attribute GetCustomAttribute(RuntimeMethodInfo method)
  493.         {
  494.             if ((method.Attributes & MethodAttributes.PinvokeImpl) == 0)
  495.                 return null;
  496.            
  497.             MetadataImport scope = method.Module.ModuleHandle.GetMetadataImport();
  498.             string entryPoint;
  499.             string dllName = null;
  500.             int token = method.MetadataToken;
  501.             PInvokeAttributes flags = 0;
  502.            
  503.             scope.GetPInvokeMap(token, out flags, out entryPoint, out dllName);
  504.            
  505.             CharSet charSet = CharSet.None;
  506.            
  507.             switch (flags & PInvokeAttributes.CharSetMask) {
  508.                 case PInvokeAttributes.CharSetNotSpec:
  509.                     charSet = CharSet.None;
  510.                     break;
  511.                 case PInvokeAttributes.CharSetAnsi:
  512.                     charSet = CharSet.Ansi;
  513.                     break;
  514.                 case PInvokeAttributes.CharSetUnicode:
  515.                     charSet = CharSet.Unicode;
  516.                     break;
  517.                 case PInvokeAttributes.CharSetAuto:
  518.                     charSet = CharSet.Auto;
  519.                     break;
  520.                 default:
  521.                     ASSERT.UNREACHABLE();
  522.                     break;
  523.             }
  524.            
  525.             CallingConvention callingConvention = CallingConvention.Cdecl;
  526.            
  527.             switch (flags & PInvokeAttributes.CallConvMask) {
  528.                 case PInvokeAttributes.CallConvWinapi:
  529.                     callingConvention = CallingConvention.Winapi;
  530.                     break;
  531.                 case PInvokeAttributes.CallConvCdecl:
  532.                     callingConvention = CallingConvention.Cdecl;
  533.                     break;
  534.                 case PInvokeAttributes.CallConvStdcall:
  535.                     callingConvention = CallingConvention.StdCall;
  536.                     break;
  537.                 case PInvokeAttributes.CallConvThiscall:
  538.                     callingConvention = CallingConvention.ThisCall;
  539.                     break;
  540.                 case PInvokeAttributes.CallConvFastcall:
  541.                     callingConvention = CallingConvention.FastCall;
  542.                     break;
  543.                 default:
  544.                    
  545.                     ASSERT.UNREACHABLE();
  546.                     break;
  547.             }
  548.            
  549.             bool exactSpelling = (flags & PInvokeAttributes.NoMangle) != 0;
  550.             bool setLastError = (flags & PInvokeAttributes.SupportsLastError) != 0;
  551.             bool bestFitMapping = (flags & PInvokeAttributes.BestFitMask) == PInvokeAttributes.BestFitEnabled;
  552.             bool throwOnUnmappableChar = (flags & PInvokeAttributes.ThrowOnUnmappableCharMask) == PInvokeAttributes.ThrowOnUnmappableCharEnabled;
  553.             bool preserveSig = (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != 0;
  554.            
  555.             return new DllImportAttribute(dllName, entryPoint, charSet, exactSpelling, setLastError, preserveSig, callingConvention, bestFitMapping, throwOnUnmappableChar);
  556.         }
  557.        
  558.         static internal bool IsDefined(RuntimeMethodInfo method)
  559.         {
  560.             return (method.Attributes & MethodAttributes.PinvokeImpl) != 0;
  561.         }
  562.        
  563.        
  564.         internal DllImportAttribute(string dllName, string entryPoint, CharSet charSet, bool exactSpelling, bool setLastError, bool preserveSig, CallingConvention callingConvention, bool bestFitMapping, bool throwOnUnmappableChar)
  565.         {
  566.             _val = dllName;
  567.             EntryPoint = entryPoint;
  568.             CharSet = charSet;
  569.             ExactSpelling = exactSpelling;
  570.             SetLastError = setLastError;
  571.             PreserveSig = preserveSig;
  572.             CallingConvention = callingConvention;
  573.             BestFitMapping = bestFitMapping;
  574.             ThrowOnUnmappableChar = throwOnUnmappableChar;
  575.         }
  576.        
  577.         internal string _val;
  578.        
  579.         public DllImportAttribute(string dllName)
  580.         {
  581.             _val = dllName;
  582.         }
  583.         public string Value {
  584.             get { return _val; }
  585.         }
  586.        
  587.         public string EntryPoint;
  588.         public CharSet CharSet;
  589.         public bool SetLastError;
  590.         public bool ExactSpelling;
  591.         public bool PreserveSig;
  592.         public CallingConvention CallingConvention;
  593.         public bool BestFitMapping;
  594.         public bool ThrowOnUnmappableChar;
  595.        
  596.     }
  597.    
  598.     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
  599.     [System.Runtime.InteropServices.ComVisible(true)]
  600.     unsafe public sealed class StructLayoutAttribute : Attribute
  601.     {
  602.         private const int DEFAULT_PACKING_SIZE = 8;
  603.        
  604.         static internal Attribute GetCustomAttribute(Type type)
  605.         {
  606.             if (!IsDefined(type))
  607.                 return null;
  608.            
  609.             int pack = 0;
  610.             int size = 0;
  611.             LayoutKind layoutKind = LayoutKind.Auto;
  612.             switch (type.Attributes & TypeAttributes.LayoutMask) {
  613.                 case TypeAttributes.ExplicitLayout:
  614.                     layoutKind = LayoutKind.Explicit;
  615.                     break;
  616.                 case TypeAttributes.AutoLayout:
  617.                     layoutKind = LayoutKind.Auto;
  618.                     break;
  619.                 case TypeAttributes.SequentialLayout:
  620.                     layoutKind = LayoutKind.Sequential;
  621.                     break;
  622.                 default:
  623.                     ASSERT.UNREACHABLE();
  624.                     break;
  625.             }
  626.            
  627.             CharSet charSet = CharSet.None;
  628.             switch (type.Attributes & TypeAttributes.StringFormatMask) {
  629.                 case TypeAttributes.AnsiClass:
  630.                     charSet = CharSet.Ansi;
  631.                     break;
  632.                 case TypeAttributes.AutoClass:
  633.                     charSet = CharSet.Auto;
  634.                     break;
  635.                 case TypeAttributes.UnicodeClass:
  636.                     charSet = CharSet.Unicode;
  637.                     break;
  638.                 default:
  639.                     ASSERT.UNREACHABLE();
  640.                     break;
  641.             }
  642.             type.Module.MetadataImport.GetClassLayout(type.MetadataToken, out pack, out size);
  643.            
  644.             // Metadata parameter checking should not have allowed 0 for packing size.
  645.             // The runtime later converts a packing size of 0 to 8 so do the same here
  646.             // because it's more useful from a user perspective.
  647.             if (pack == 0)
  648.                 pack = DEFAULT_PACKING_SIZE;
  649.            
  650.             return new StructLayoutAttribute(layoutKind, pack, size, charSet);
  651.         }
  652.        
  653.         static internal bool IsDefined(Type type)
  654.         {
  655.             if (type.IsInterface || type.HasElementType || type.IsGenericParameter)
  656.                 return false;
  657.            
  658.             return true;
  659.         }
  660.        
  661.         internal LayoutKind _val;
  662.        
  663.         internal StructLayoutAttribute(LayoutKind layoutKind, int pack, int size, CharSet charSet)
  664.         {
  665.             _val = layoutKind;
  666.             Pack = pack;
  667.             Size = size;
  668.             CharSet = charSet;
  669.         }
  670.        
  671.         public StructLayoutAttribute(LayoutKind layoutKind)
  672.         {
  673.             _val = layoutKind;
  674.         }
  675.         public StructLayoutAttribute(short layoutKind)
  676.         {
  677.             _val = (LayoutKind)layoutKind;
  678.         }
  679.         public LayoutKind Value {
  680.             get { return _val; }
  681.         }
  682.         public int Pack;
  683.         public int Size;
  684.         public CharSet CharSet;
  685.     }
  686.    
  687.     [AttributeUsage(AttributeTargets.Field, Inherited = false)]
  688.     [System.Runtime.InteropServices.ComVisible(true)]
  689.     unsafe public sealed class FieldOffsetAttribute : Attribute
  690.     {
  691.         static internal Attribute GetCustomAttribute(RuntimeFieldInfo field)
  692.         {
  693.             int fieldOffset;
  694.            
  695.             if (field.DeclaringType != null && field.Module.MetadataImport.GetFieldOffset(field.DeclaringType.MetadataToken, field.MetadataToken, out fieldOffset))
  696.                 return new FieldOffsetAttribute(fieldOffset);
  697.            
  698.             return null;
  699.         }
  700.        
  701.         static internal bool IsDefined(RuntimeFieldInfo field)
  702.         {
  703.             return GetCustomAttribute(field) != null;
  704.         }
  705.        
  706.         internal int _val;
  707.         public FieldOffsetAttribute(int offset)
  708.         {
  709.             _val = offset;
  710.         }
  711.         public int Value {
  712.             get { return _val; }
  713.         }
  714.     }
  715.    
  716.    
  717.     [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
  718.     [System.Runtime.InteropServices.ComVisible(true)]
  719.     public sealed class BestFitMappingAttribute : Attribute
  720.     {
  721.         internal bool _bestFitMapping;
  722.        
  723.         public BestFitMappingAttribute(bool BestFitMapping)
  724.         {
  725.             _bestFitMapping = BestFitMapping;
  726.         }
  727.        
  728.         public bool BestFitMapping {
  729.             get { return _bestFitMapping; }
  730.         }
  731.         public bool ThrowOnUnmappableChar;
  732.     }
  733.    
  734.     [AttributeUsage(AttributeTargets.Module, Inherited = false)]
  735.     [System.Runtime.InteropServices.ComVisible(true)]
  736.     public sealed class DefaultCharSetAttribute : Attribute
  737.     {
  738.         internal CharSet _CharSet;
  739.        
  740.         public DefaultCharSetAttribute(CharSet charSet)
  741.         {
  742.             _CharSet = charSet;
  743.         }
  744.        
  745.         public CharSet CharSet {
  746.             get { return _CharSet; }
  747.         }
  748.     }
  749.    
  750.     [Obsolete("This attribute has been deprecated. Application Domains no longer respect Activation Context boundaries in IDispatch calls.", false)]
  751.     [AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
  752.     [System.Runtime.InteropServices.ComVisible(true)]
  753.     public sealed class SetWin32ContextInIDispatchAttribute : Attribute
  754.     {
  755.         public SetWin32ContextInIDispatchAttribute()
  756.         {
  757.         }
  758.     }
  759. }

Developer Fusion