internal static void ReadMethodSignature(IMetadataImport importer, Instantiation instantiation, ref IntPtr pData, out CorCallingConvention cconv, out Type retType, out List <Type> argTypes, out int sentinelIndex)
{
cconv = MetadataHelperFunctions.CorSigUncompressCallingConv(ref pData);
uint numArgs = 0;
// FIXME: Use number of <T>s.
uint types = 0;
sentinelIndex = -1;
if ((cconv & CorCallingConvention.Generic) == CorCallingConvention.Generic)
{
types = MetadataHelperFunctions.CorSigUncompressData(ref pData);
}
if (cconv != CorCallingConvention.Field)
{
numArgs = MetadataHelperFunctions.CorSigUncompressData(ref pData);
}
retType = ReadType(importer, instantiation, ref pData);
argTypes = new List <Type> ();
for (int n = 0; n < numArgs; n++)
{
CorElementType elemType;
unsafe {
var pByte = (byte *)pData;
var b = *pByte;
elemType = (CorElementType)b;
if (elemType == CorElementType.ELEMENT_TYPE_SENTINEL)
{
// the case when SENTINEL is presented in a separate position, so we have to increment the pointer
sentinelIndex = n;
pData = (IntPtr)(pByte + 1);
}
else if ((elemType & CorElementType.ELEMENT_TYPE_SENTINEL) == CorElementType.ELEMENT_TYPE_SENTINEL)
{
// SENTINEL is just a flag on element type, so we haven't to promote the pointer
sentinelIndex = n;
}
}
argTypes.Add(ReadType(importer, instantiation, ref pData));
}
}
private static CorElementType GetEnumUnderlyingType(IMetadataImport importer, int tk)
{
IntPtr hEnum = IntPtr.Zero;
int mdFieldDef;
uint numFieldDefs;
int fieldAttributes;
int nameSize;
int cPlusTypeFlab;
IntPtr ppValue;
int pcchValue;
IntPtr ppvSig;
int size;
int classToken;
importer.EnumFields(ref hEnum, tk, out mdFieldDef, 1, out numFieldDefs);
while (numFieldDefs != 0)
{
importer.GetFieldProps(mdFieldDef, out classToken, null, 0, out nameSize, out fieldAttributes,
out ppvSig, out size, out cPlusTypeFlab, out ppValue, out pcchValue);
Debug.Assert(tk == classToken);
// Enums should have one instance field that indicates the underlying type
if ((((FieldAttributes)fieldAttributes) & FieldAttributes.Static) == 0)
{
Debug.Assert(size == 2); // Primitive type field sigs should be two bytes long
IntPtr ppvSigTemp = ppvSig;
CorCallingConvention callingConv =
MetadataHelperFunctions.CorSigUncompressCallingConv(ref ppvSigTemp);
Debug.Assert(callingConv == CorCallingConvention.Field);
return(MetadataHelperFunctions.CorSigUncompressElementType(ref ppvSigTemp));
}
importer.EnumFields(ref hEnum, tk, out mdFieldDef, 1, out numFieldDefs);
}
Debug.Fail("Should never get here.");
throw new ArgumentException("Non-enum passed to GetEnumUnderlyingType.");
}
internal static void ReadMethodSignature(IMetadataImport importer, ref IntPtr pData, out CorCallingConvention cconv, out Type retType, out List <Type> argTypes)
{
cconv = MetadataHelperFunctions.CorSigUncompressCallingConv(ref pData);
uint numArgs = 0;
// FIXME: Use number of <T>s.
uint types = 0;
if ((cconv & CorCallingConvention.Generic) == CorCallingConvention.Generic)
{
types = MetadataHelperFunctions.CorSigUncompressData(ref pData);
}
if (cconv != CorCallingConvention.Field)
{
numArgs = MetadataHelperFunctions.CorSigUncompressData(ref pData);
}
retType = ReadType(importer, ref pData);
argTypes = new List <Type> ();
for (int n = 0; n < numArgs; n++)
{
argTypes.Add(ReadType(importer, ref pData));
}
}
static Type ReadType(IMetadataImport importer, Instantiation instantiation, ref IntPtr pData)
{
CorElementType et;
unsafe {
var pBytes = (byte *)pData;
et = (CorElementType)(*pBytes);
pData = (IntPtr)(pBytes + 1);
}
if ((et & CorElementType.ELEMENT_TYPE_SENTINEL) == CorElementType.ELEMENT_TYPE_SENTINEL)
{
et ^= CorElementType.ELEMENT_TYPE_SENTINEL; // substract SENTINEL bits from element type to get clean ET
}
switch (et)
{
case CorElementType.ELEMENT_TYPE_VOID: return(typeof(void));
case CorElementType.ELEMENT_TYPE_BOOLEAN: return(typeof(bool));
case CorElementType.ELEMENT_TYPE_CHAR: return(typeof(char));
case CorElementType.ELEMENT_TYPE_I1: return(typeof(sbyte));
case CorElementType.ELEMENT_TYPE_U1: return(typeof(byte));
case CorElementType.ELEMENT_TYPE_I2: return(typeof(short));
case CorElementType.ELEMENT_TYPE_U2: return(typeof(ushort));
case CorElementType.ELEMENT_TYPE_I4: return(typeof(int));
case CorElementType.ELEMENT_TYPE_U4: return(typeof(uint));
case CorElementType.ELEMENT_TYPE_I8: return(typeof(long));
case CorElementType.ELEMENT_TYPE_U8: return(typeof(ulong));
case CorElementType.ELEMENT_TYPE_R4: return(typeof(float));
case CorElementType.ELEMENT_TYPE_R8: return(typeof(double));
case CorElementType.ELEMENT_TYPE_STRING: return(typeof(string));
case CorElementType.ELEMENT_TYPE_I: return(typeof(IntPtr));
case CorElementType.ELEMENT_TYPE_U: return(typeof(UIntPtr));
case CorElementType.ELEMENT_TYPE_OBJECT: return(typeof(object));
case CorElementType.ELEMENT_TYPE_TYPEDBYREF: return(typeof(TypedReference));
case CorElementType.ELEMENT_TYPE_VAR: {
var index = MetadataHelperFunctions.CorSigUncompressData(ref pData);
if (index < instantiation.TypeArgs.Count)
{
return(instantiation.TypeArgs[(int)index]);
}
return(new TypeGenericParameter((int)index));
}
case CorElementType.ELEMENT_TYPE_MVAR: {
// Generic args in methods not supported. Return a dummy type.
var index = MetadataHelperFunctions.CorSigUncompressData(ref pData);
return(new MethodGenericParameter((int)index));
}
case CorElementType.ELEMENT_TYPE_GENERICINST: {
Type t = ReadType(importer, instantiation, ref pData);
var typeArgs = new List <Type> ();
uint num = MetadataHelperFunctions.CorSigUncompressData(ref pData);
for (int n = 0; n < num; n++)
{
typeArgs.Add(ReadType(importer, instantiation, ref pData));
}
return(MetadataExtensions.MakeGeneric(t, typeArgs));
}
case CorElementType.ELEMENT_TYPE_PTR: {
Type t = ReadType(importer, instantiation, ref pData);
return(MetadataExtensions.MakePointer(t));
}
case CorElementType.ELEMENT_TYPE_BYREF: {
Type t = ReadType(importer, instantiation, ref pData);
return(MetadataExtensions.MakeByRef(t));
}
case CorElementType.ELEMENT_TYPE_END:
case CorElementType.ELEMENT_TYPE_VALUETYPE:
case CorElementType.ELEMENT_TYPE_CLASS: {
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref pData);
return(new MetadataType(importer, (int)token));
}
case CorElementType.ELEMENT_TYPE_ARRAY: {
Type t = ReadType(importer, instantiation, ref pData);
int rank = (int)MetadataHelperFunctions.CorSigUncompressData(ref pData);
if (rank == 0)
{
return(MetadataExtensions.MakeArray(t, null, null));
}
uint numSizes = MetadataHelperFunctions.CorSigUncompressData(ref pData);
var sizes = new List <int> (rank);
for (int n = 0; n < numSizes && n < rank; n++)
{
sizes.Add((int)MetadataHelperFunctions.CorSigUncompressData(ref pData));
}
uint numLoBounds = MetadataHelperFunctions.CorSigUncompressData(ref pData);
var loBounds = new List <int> (rank);
for (int n = 0; n < numLoBounds && n < rank; n++)
{
loBounds.Add((int)MetadataHelperFunctions.CorSigUncompressData(ref pData));
}
return(MetadataExtensions.MakeArray(t, sizes, loBounds));
}
case CorElementType.ELEMENT_TYPE_SZARRAY: {
Type t = ReadType(importer, instantiation, ref pData);
return(MetadataExtensions.MakeArray(t, null, null));
}
case CorElementType.ELEMENT_TYPE_FNPTR: {
CorCallingConvention cconv;
Type retType;
List <Type> argTypes;
int sentinelIndex;
ReadMethodSignature(importer, instantiation, ref pData, out cconv, out retType, out argTypes, out sentinelIndex);
return(MetadataExtensions.MakeDelegate(retType, argTypes));
}
case CorElementType.ELEMENT_TYPE_CMOD_REQD:
case CorElementType.ELEMENT_TYPE_CMOD_OPT: {
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref pData);
return(new MetadataType(importer, (int)token));
}
case CorElementType.ELEMENT_TYPE_INTERNAL:
return(typeof(object)); // hack to avoid the exceptions. CLR spec says that this type should never occurs, but it occurs sometimes, mystics
case CorElementType.ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG:
case CorElementType.ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG:
return(ReadType(importer, instantiation, ref pData));
case CorElementType.ELEMENT_TYPE_CANON_ZAPSIG:
return(typeof(object)); // this is representation of __Canon type, but it's inaccessible, using object instead
}
throw new NotSupportedException("Unknown sig element type: " + et);
}
static Type ReadType(IMetadataImport importer, ref IntPtr pData)
{
CorElementType et;
unsafe {
var pBytes = (byte *)pData;
et = (CorElementType)(*pBytes);
pData = (IntPtr)(pBytes + 1);
}
switch (et)
{
case CorElementType.ELEMENT_TYPE_VOID: return(typeof(void));
case CorElementType.ELEMENT_TYPE_BOOLEAN: return(typeof(bool));
case CorElementType.ELEMENT_TYPE_CHAR: return(typeof(char));
case CorElementType.ELEMENT_TYPE_I1: return(typeof(sbyte));
case CorElementType.ELEMENT_TYPE_U1: return(typeof(byte));
case CorElementType.ELEMENT_TYPE_I2: return(typeof(short));
case CorElementType.ELEMENT_TYPE_U2: return(typeof(ushort));
case CorElementType.ELEMENT_TYPE_I4: return(typeof(int));
case CorElementType.ELEMENT_TYPE_U4: return(typeof(uint));
case CorElementType.ELEMENT_TYPE_I8: return(typeof(long));
case CorElementType.ELEMENT_TYPE_U8: return(typeof(ulong));
case CorElementType.ELEMENT_TYPE_R4: return(typeof(float));
case CorElementType.ELEMENT_TYPE_R8: return(typeof(double));
case CorElementType.ELEMENT_TYPE_STRING: return(typeof(string));
case CorElementType.ELEMENT_TYPE_I: return(typeof(IntPtr));
case CorElementType.ELEMENT_TYPE_U: return(typeof(UIntPtr));
case CorElementType.ELEMENT_TYPE_OBJECT: return(typeof(object));
case CorElementType.ELEMENT_TYPE_VAR:
case CorElementType.ELEMENT_TYPE_MVAR:
// Generic args in methods not supported. Return a dummy type.
MetadataHelperFunctions.CorSigUncompressData(ref pData);
return(typeof(GenericType));
case CorElementType.ELEMENT_TYPE_GENERICINST: {
Type t = ReadType(importer, ref pData);
var typeArgs = new List <Type> ();
uint num = MetadataHelperFunctions.CorSigUncompressData(ref pData);
for (int n = 0; n < num; n++)
{
typeArgs.Add(ReadType(importer, ref pData));
}
return(MetadataExtensions.MakeGeneric(t, typeArgs));
}
case CorElementType.ELEMENT_TYPE_PTR: {
Type t = ReadType(importer, ref pData);
return(MetadataExtensions.MakePointer(t));
}
case CorElementType.ELEMENT_TYPE_BYREF: {
Type t = ReadType(importer, ref pData);
return(MetadataExtensions.MakeByRef(t));
}
case CorElementType.ELEMENT_TYPE_END:
case CorElementType.ELEMENT_TYPE_VALUETYPE:
case CorElementType.ELEMENT_TYPE_CLASS: {
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref pData);
return(new MetadataType(importer, (int)token));
}
case CorElementType.ELEMENT_TYPE_ARRAY: {
Type t = ReadType(importer, ref pData);
int rank = (int)MetadataHelperFunctions.CorSigUncompressData(ref pData);
if (rank == 0)
{
return(MetadataExtensions.MakeArray(t, null, null));
}
uint numSizes = MetadataHelperFunctions.CorSigUncompressData(ref pData);
var sizes = new List <int> (rank);
for (int n = 0; n < numSizes && n < rank; n++)
{
sizes.Add((int)MetadataHelperFunctions.CorSigUncompressData(ref pData));
}
uint numLoBounds = MetadataHelperFunctions.CorSigUncompressData(ref pData);
var loBounds = new List <int> (rank);
for (int n = 0; n < numLoBounds && n < rank; n++)
{
loBounds.Add((int)MetadataHelperFunctions.CorSigUncompressData(ref pData));
}
return(MetadataExtensions.MakeArray(t, sizes, loBounds));
}
case CorElementType.ELEMENT_TYPE_SZARRAY: {
Type t = ReadType(importer, ref pData);
return(MetadataExtensions.MakeArray(t, null, null));
}
case CorElementType.ELEMENT_TYPE_FNPTR: {
CorCallingConvention cconv;
Type retType;
List <Type> argTypes;
ReadMethodSignature(importer, ref pData, out cconv, out retType, out argTypes);
return(MetadataExtensions.MakeDelegate(retType, argTypes));
}
case CorElementType.ELEMENT_TYPE_CMOD_REQD:
case CorElementType.ELEMENT_TYPE_CMOD_OPT:
return(ReadType(importer, ref pData));
}
throw new NotSupportedException("Unknown sig element type: " + et);
}
public string[] GetGenericArgumentNames()
{
return(MetadataHelperFunctions.GetGenericArgumentNames(m_importer, m_typeToken));
}
static Type ReadType(CorApi.Portable.IMetaDataImport importer, Instantiation instantiation, ref IntPtr pData)
{
CorApi.Portable.CorElementType et;
unsafe {
var pBytes = (byte *)pData;
et = (CorApi.Portable.CorElementType)(*pBytes);
pData = (IntPtr)(pBytes + 1);
}
if ((et & CorApi.Portable.CorElementType.ElementTypeSentinel) == CorApi.Portable.CorElementType.ElementTypeSentinel)
{
et ^= CorApi.Portable.CorElementType.ElementTypeSentinel; // substract SENTINEL bits from element type to get clean ET
}
switch (et)
{
case CorApi.Portable.CorElementType.ElementTypeVoid: return(typeof(void));
case CorApi.Portable.CorElementType.ElementTypeBoolean: return(typeof(bool));
case CorApi.Portable.CorElementType.ElementTypeChar: return(typeof(char));
case CorApi.Portable.CorElementType.ElementTypeI1: return(typeof(sbyte));
case CorApi.Portable.CorElementType.ElementTypeU1: return(typeof(byte));
case CorApi.Portable.CorElementType.ElementTypeI2: return(typeof(short));
case CorApi.Portable.CorElementType.ElementTypeU2: return(typeof(ushort));
case CorApi.Portable.CorElementType.ElementTypeI4: return(typeof(int));
case CorApi.Portable.CorElementType.ElementTypeU4: return(typeof(uint));
case CorApi.Portable.CorElementType.ElementTypeI8: return(typeof(long));
case CorApi.Portable.CorElementType.ElementTypeU8: return(typeof(ulong));
case CorApi.Portable.CorElementType.ElementTypeR4: return(typeof(float));
case CorApi.Portable.CorElementType.ElementTypeR8: return(typeof(double));
case CorApi.Portable.CorElementType.ElementTypeString: return(typeof(string));
case CorApi.Portable.CorElementType.ElementTypeI: return(typeof(IntPtr));
case CorApi.Portable.CorElementType.ElementTypeU: return(typeof(UIntPtr));
case CorApi.Portable.CorElementType.ElementTypeObject: return(typeof(object));
case CorApi.Portable.CorElementType.ElementTypeTypedbyref: return(typeof(TypedReference));
case CorApi.Portable.CorElementType.ElementTypeVar: {
var index = MetadataHelperFunctions.CorSigUncompressData(ref pData);
if (index < instantiation.TypeArgs.Count)
{
return(instantiation.TypeArgs[(int)index]);
}
return(new TypeGenericParameter((int)index));
}
case CorApi.Portable.CorElementType.ElementTypeMvar: {
// Generic args in methods not supported. Return a dummy type.
var index = MetadataHelperFunctions.CorSigUncompressData(ref pData);
return(new MethodGenericParameter((int)index));
}
case CorApi.Portable.CorElementType.ElementTypeGenericinst: {
Type t = ReadType(importer, instantiation, ref pData);
var typeArgs = new List <Type> ();
uint num = MetadataHelperFunctions.CorSigUncompressData(ref pData);
for (int n = 0; n < num; n++)
{
typeArgs.Add(ReadType(importer, instantiation, ref pData));
}
return(MetadataExtensions.MakeGeneric(t, typeArgs));
}
case CorApi.Portable.CorElementType.ElementTypePtr: {
Type t = ReadType(importer, instantiation, ref pData);
return(MetadataExtensions.MakePointer(t));
}
case CorApi.Portable.CorElementType.ElementTypeByref: {
Type t = ReadType(importer, instantiation, ref pData);
return(MetadataExtensions.MakeByRef(t));
}
case CorApi.Portable.CorElementType.ElementTypeEnd:
case CorApi.Portable.CorElementType.ElementTypeValuetype:
case CorApi.Portable.CorElementType.ElementTypeClass: {
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref pData);
return(new MetadataType(importer, (int)token));
}
case CorApi.Portable.CorElementType.ElementTypeArray: {
Type t = ReadType(importer, instantiation, ref pData);
int rank = (int)MetadataHelperFunctions.CorSigUncompressData(ref pData);
if (rank == 0)
{
return(MetadataExtensions.MakeArray(t, null, null));
}
uint numSizes = MetadataHelperFunctions.CorSigUncompressData(ref pData);
var sizes = new List <int> (rank);
for (int n = 0; n < numSizes && n < rank; n++)
{
sizes.Add((int)MetadataHelperFunctions.CorSigUncompressData(ref pData));
}
uint numLoBounds = MetadataHelperFunctions.CorSigUncompressData(ref pData);
var loBounds = new List <int> (rank);
for (int n = 0; n < numLoBounds && n < rank; n++)
{
loBounds.Add((int)MetadataHelperFunctions.CorSigUncompressData(ref pData));
}
return(MetadataExtensions.MakeArray(t, sizes, loBounds));
}
case CorApi.Portable.CorElementType.ElementTypeSzarray: {
Type t = ReadType(importer, instantiation, ref pData);
return(MetadataExtensions.MakeArray(t, null, null));
}
case CorApi.Portable.CorElementType.ElementTypeFnptr: {
CorCallingConvention cconv;
Type retType;
List <Type> argTypes;
int sentinelIndex;
ReadMethodSignature(importer, instantiation, ref pData, out cconv, out retType, out argTypes, out sentinelIndex);
return(MetadataExtensions.MakeDelegate(retType, argTypes));
}
case CorApi.Portable.CorElementType.ElementTypeCmodReqd:
case CorApi.Portable.CorElementType.ElementTypeCmodOptimization: {
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref pData);
return(new MetadataType(importer, (int)token));
}
case CorApi.Portable.CorElementType.ElementTypeInternal:
return(typeof(object)); // hack to avoid the exceptions. CLR spec says that this type should never occurs, but it occurs sometimes, mystics
case (CorApi.Portable.CorElementType)CorApi.Portable.CorElementTypeExtra.ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG:
case (CorApi.Portable.CorElementType)CorApi.Portable.CorElementTypeExtra.ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG:
return(ReadType(importer, instantiation, ref pData));
case (CorApi.Portable.CorElementType)CorApi.Portable.CorElementTypeExtra.ELEMENT_TYPE_CANON_ZAPSIG:
return(typeof(object)); // this is representation of __Canon type, but it's inaccessible, using object instead
}
throw new NotSupportedException("Unknown sig element type: " + et);
}
private static object ParseDefaultValue(MetadataType declaringType, IntPtr ppvSigBlob, IntPtr ppvRawValue)
{
IntPtr ppvSigTemp = ppvSigBlob;
CorCallingConvention callingConv = MetadataHelperFunctions.CorSigUncompressCallingConv(ref ppvSigTemp);
Debug.Assert(callingConv == CorCallingConvention.Field);
CorElementType elementType = MetadataHelperFunctions.CorSigUncompressElementType(ref ppvSigTemp);
if (elementType == CorElementType.ELEMENT_TYPE_VALUETYPE)
{
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref ppvSigTemp);
if (token == declaringType.MetadataToken)
{
// Static literal field of the same type as the enclosing type
// may be one of the value fields of an enum
if (declaringType.ReallyIsEnum)
{
// If so, the value will be of the enum's underlying type,
// so we change it from VALUETYPE to be that type so that
// the following code will get the value
elementType = declaringType.EnumUnderlyingType;
}
}
}
switch (elementType)
{
case CorElementType.ELEMENT_TYPE_CHAR:
return((char)Marshal.ReadByte(ppvRawValue));
case CorElementType.ELEMENT_TYPE_I1:
return((sbyte)Marshal.ReadByte(ppvRawValue));
case CorElementType.ELEMENT_TYPE_U1:
return(Marshal.ReadByte(ppvRawValue));
case CorElementType.ELEMENT_TYPE_I2:
return(Marshal.ReadInt16(ppvRawValue));
case CorElementType.ELEMENT_TYPE_U2:
return((ushort)Marshal.ReadInt16(ppvRawValue));
case CorElementType.ELEMENT_TYPE_I4:
return(Marshal.ReadInt32(ppvRawValue));
case CorElementType.ELEMENT_TYPE_U4:
return((uint)Marshal.ReadInt32(ppvRawValue));
case CorElementType.ELEMENT_TYPE_I8:
return(Marshal.ReadInt64(ppvRawValue));
case CorElementType.ELEMENT_TYPE_U8:
return((ulong)Marshal.ReadInt64(ppvRawValue));
case CorElementType.ELEMENT_TYPE_I:
return(Marshal.ReadIntPtr(ppvRawValue));
case CorElementType.ELEMENT_TYPE_U:
case CorElementType.ELEMENT_TYPE_R4:
case CorElementType.ELEMENT_TYPE_R8:
// Technically U and the floating-point ones are options in the CLI, but not in the CLS or C#, so these are NYI
default:
return(null);
}
}
