public static void Fill_FieldDef(tMD_TypeDef *pParentType, FieldInfo fieldInfo, tMD_FieldDef *pFieldDef,
uint memOffset, uint *pAlignment, tMD_TypeDef **ppClassTypeArgs)
{
tMetaData *pMetaData;
uint fieldSize;
uint fieldAlignment;
if (pFieldDef->isFilled == 1)
{
return;
}
pFieldDef->isFilled = 1;
pFieldDef->pParentType = pParentType;
pFieldDef->pType = MonoType.GetTypeForMonoType(fieldInfo.FieldType, ppClassTypeArgs, null);
if (pFieldDef->pType == null)
{
// If the field is a core generic type definition, then we can't do anything more
return;
}
if (pFieldDef->pType->fillState < Type.TYPE_FILL_LAYOUT)
{
MetaData.Fill_TypeDef(pFieldDef->pType, null, null);
}
else if (pFieldDef->pType->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_Defer(pFieldDef->pType, null, null);
}
if (pFieldDef->pType->isValueType != 0)
{
fieldSize = pFieldDef->pType->instanceMemSize;
fieldAlignment = (pFieldDef->pType->isValueType == 0 || pFieldDef->pType->alignment == 0) ? sizeof(PTR) : pFieldDef->pType->alignment;
}
else
{
fieldSize = fieldAlignment = sizeof(PTR);
}
if (pAlignment != null && *pAlignment < fieldAlignment)
{
*pAlignment = fieldAlignment;
}
pFieldDef->memOffset = (memOffset + fieldAlignment - 1) & ~(fieldAlignment - 1);
pFieldDef->memSize = fieldSize;
pFieldDef->pFieldDef = pFieldDef;
pFieldDef->monoFieldInfo = new H(fieldInfo);
pFieldDef->monoGetter = new H(GetFieldTrampoline);
pFieldDef->monoSetter = new H(SetFieldTrampoline);
pMetaData = pFieldDef->pMetaData;
}
public static void Fill_TypeDef(tMD_TypeDef *pTypeDef, tMD_TypeDef **ppClassTypeArgs,
tMD_TypeDef **ppMethodTypeArgs, uint resolve = Type.TYPE_FILL_ALL)
{
uint instanceMemSize, staticMemSize, virtualOfs, isDeferred, i, j;
int lastPeriod;
tMetaData * pMetaData;
tMD_TypeDef *pParent;
System.Type monoType;
tMD_FieldDef * pFieldDefs;
tMD_MethodDef *pMethodDefs;
FieldInfo[] fieldInfos = null;
FieldInfo fieldInfo;
MethodInfo[] methodInfos = null;
ConstructorInfo[] constructorInfos = null;
MethodBase methodBase;
tMD_MethodDef * pMethodDef;
if (pTypeDef->fillState >= resolve)
{
return;
}
if (pTypeDef->monoType == null)
{
MetaData.Fill_TypeDef(pTypeDef, ppClassTypeArgs, ppMethodTypeArgs, resolve);
return;
}
//Sys.printf("FILLING TYPE: %s\n", (PTR)pTypeDef->name);
if (MetaData.typesToFill == null)
{
MetaData.Fill_StartDefer();
isDeferred = 1;
}
else
{
isDeferred = 0;
}
if (resolve < Type.TYPE_FILL_ALL)
{
MetaData.Fill_Defer(pTypeDef, ppClassTypeArgs, ppMethodTypeArgs);
}
MetaData.Fill_GetDeferredTypeArgs(pTypeDef, ref ppClassTypeArgs, ref ppMethodTypeArgs);
monoType = H.ToObj(pTypeDef->monoType) as System.Type;
pMetaData = pTypeDef->pMetaData;
if (pTypeDef->fillState < Type.TYPE_FILL_PARENTS)
{
pTypeDef->fillState = Type.TYPE_FILL_PARENTS;
// For Methods, we get only public if sealed, or public/protected if not sealed
methodInfos = GetMethods(monoType);
// For fields, we only get private fields for value types
fieldInfos = GetFields(monoType);
// For constructors, we get only public if sealed, or public/protected if not sealed
constructorInfos = GetConstructors(monoType);
pTypeDef->pTypeDef = pTypeDef;
pTypeDef->pParent = MonoType.GetTypeForMonoType(monoType.BaseType, null, null);
pParent = pTypeDef->pParent;
pTypeDef->isValueType = (byte)(monoType.IsValueType ? 1 : 0);
if (pParent != null)
{
MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_PARENTS);
if (pParent->hasMonoBase == 0)
{
// If we have a mono base type, we have at least 1 non-blittable field
pTypeDef->blittable = pParent->blittable;
pTypeDef->fixedBlittable = pParent->fixedBlittable;
}
else
{
pTypeDef->blittable = pTypeDef->fixedBlittable = 0;
}
}
else
{
// For mono types - reference types are NEVER blittable in our implementation
pTypeDef->blittable = pTypeDef->fixedBlittable = pTypeDef->isValueType;
}
pTypeDef->alignment = 1;
// Mark all ref types as having a base Mono Handle pointer as the first slot in their instance data. This allows
// the Heap system to call FREE on this Handle whenever we garbage collect mono wrapped or derived heap objects.
pTypeDef->hasMonoBase = (byte)(monoType.IsValueType ? 0 : 1);
// If not primed, then work out how many methods & fields there are.
if (pTypeDef->isPrimed == 0)
{
// Methods
pTypeDef->numMethods = (uint)(constructorInfos.Length + methodInfos.Length);
// Fields
pTypeDef->numFields = (uint)fieldInfos.Length;
}
// If this is an enum type, then pretend its stack type is its underlying type
if (pTypeDef->pParent == Type.types[Type.TYPE_SYSTEM_ENUM])
{
pTypeDef->stackType = EvalStack.EVALSTACK_INT32;
pTypeDef->stackSize = sizeof(PTR);
pTypeDef->instanceMemSize = 4;
pTypeDef->arrayElementSize = 4;
pTypeDef->blittable = pTypeDef->fixedBlittable = 1;
}
if (pTypeDef->fillState >= resolve)
{
return;
}
}
else
{
pParent = pTypeDef->pParent;
}
if (pTypeDef->fillState < Type.TYPE_FILL_LAYOUT)
{
pTypeDef->fillState = Type.TYPE_FILL_LAYOUT;
if (pParent != null)
{
if (pParent->fillState < Type.TYPE_FILL_LAYOUT)
{
MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_LAYOUT);
}
else if (pParent->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_Defer(pParent, null, null);
}
}
// This only needs to be done for non-generic Type.types, or for generic type that are not a definition
// I.e. Fully instantiated generic Type.types
if (pTypeDef->isGenericDefinition == 0)
{
// For fields, we only get private fields for value types
if (fieldInfos == null)
{
fieldInfos = GetFields(monoType);
}
// Resolve fields, members, interfaces.
// Only needs to be done if it's not a generic definition type
// It it's not a value-type and the stack-size is not preset, then set it up now.
// It needs to be done here as non-static fields in non-value type can point to the containing type
if (pTypeDef->stackSize == 0 && pTypeDef->isValueType == 0)
{
pTypeDef->stackType = EvalStack.EVALSTACK_O;
pTypeDef->stackSize = sizeof(PTR);
pTypeDef->alignment = sizeof(PTR);
}
// Resolve all fields - instance ONLY at this point,
// because static fields in value-Type.types can be of the containing type, and the size is not yet known.
staticMemSize = 0;
if (pTypeDef->numFields > 0)
{
pTypeDef->ppFields = (tMD_FieldDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef *)));
pFieldDefs = (tMD_FieldDef *)Mem.mallocForever((SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef)));
Mem.memset(pFieldDefs, 0, (SIZE_T)(pTypeDef->numFields * sizeof(tMD_FieldDef)));
}
else
{
pFieldDefs = null;
}
instanceMemSize = 0;
for (i = 0; i < fieldInfos.Length; i++)
{
fieldInfo = fieldInfos[i];
tMD_FieldDef *pFieldDef = &pFieldDefs[i];
pFieldDef->name = new S(fieldInfo.Name);
pFieldDef->flags = (ushort)(
(fieldInfo.IsStatic ? MetaData.FIELDATTRIBUTES_STATIC : 0) |
(fieldInfo.IsLiteral ? MetaData.FIELDATTRIBUTES_LITERAL : 0)
);
if (!fieldInfo.IsStatic)
{
if (fieldInfo.IsLiteral /*|| MetaData.FIELD_HASFIELDRVA(pFieldDef)*/)
{
// If it's a literal, then analyse the field, but don't include it in any memory allocation
// If is has an RVA, then analyse the field, but don't include it in any memory allocation
MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, 0, null, ppClassTypeArgs);
}
else
{
MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, instanceMemSize, &(pTypeDef->alignment), ppClassTypeArgs);
instanceMemSize = pFieldDef->memOffset + pFieldDef->memSize;
}
// Update blittable and fixedBlittable status for type - if any non-blittable fields are included set to 0
if (pTypeDef->blittable != 0 || pTypeDef->fixedBlittable != 0)
{
if (pFieldDef->pType->isValueType == 0 || pFieldDef->pType->blittable == 0)
{
pTypeDef->blittable = pTypeDef->fixedBlittable = 0;
}
else if (pFieldDef->pType->typeInitId == Type.TYPE_SYSTEM_INTPTR ||
pFieldDef->pType->typeInitId == Type.TYPE_SYSTEM_UINTPTR)
{
pTypeDef->fixedBlittable = 0;
}
}
pTypeDef->ppFields[i] = pFieldDef;
}
}
if (pTypeDef->instanceMemSize == 0)
{
if (pTypeDef->isValueType != 0)
{
// Our dna value types are the same size as they are in mono (hopefully!)
pTypeDef->instanceMemSize = (instanceMemSize + (pTypeDef->alignment - 1)) & ~(pTypeDef->alignment - 1);
}
else
{
// For mono reference types, the instance size is ALWAYS ptr size because we're wrapping a mono GCHandle pointer
pTypeDef->instanceMemSize = sizeof(PTR);
}
}
// Sort out stack type and size.
// Note that this may already be set, as some basic type have this preset;
// or if it's not a value-type it'll already be set
if (pTypeDef->stackSize == 0)
{
// if it gets here then it must be a value type
pTypeDef->stackType = EvalStack.EVALSTACK_VALUETYPE;
pTypeDef->stackSize = pTypeDef->instanceMemSize;
}
// Sort out array element size. Note that some basic type will have this preset.
if (pTypeDef->arrayElementSize == 0)
{
pTypeDef->arrayElementSize = pTypeDef->stackSize;
}
// Make sure stack size is even multiple of stack alignment
pTypeDef->stackSize = (pTypeDef->stackSize + (STACK_ALIGNMENT - 1)) & ~(STACK_ALIGNMENT - 1);
// Handle static fields
for (i = 0; i < fieldInfos.Length; i++)
{
fieldInfo = fieldInfos[i];
tMD_FieldDef *pFieldDef = &pFieldDefs[i];
if (fieldInfo.IsStatic)
{
if (fieldInfo.IsLiteral /*|| MetaData.FIELD_HASFIELDRVA(pFieldDef)*/)
{
// If it's a literal, then analyse the field, but don't include it in any memory allocation
// If is has an RVA, then analyse the field, but don't include it in any memory allocation
MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, 0, null, ppClassTypeArgs);
}
else
{
MonoType.Fill_FieldDef(pTypeDef, fieldInfo, pFieldDef, staticMemSize, null, ppClassTypeArgs);
staticMemSize += pFieldDef->memSize;
}
pTypeDef->ppFields[i] = pFieldDef;
}
}
}
if (pTypeDef->fillState >= resolve)
{
return;
}
}
if (pTypeDef->fillState < Type.TYPE_FILL_VTABLE)
{
pTypeDef->fillState = Type.TYPE_FILL_VTABLE;
if (pParent != null)
{
if (pParent->fillState < Type.TYPE_FILL_VTABLE)
{
MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_VTABLE);
}
else if (pParent->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_Defer(pParent, null, null);
}
}
// This only needs to be done for non-generic Type.types, or for generic type that are not a definition
// I.e. Fully instantiated generic Type.types
if (pTypeDef->isGenericDefinition == 0)
{
virtualOfs = (pParent != null) ? pParent->numVirtualMethods : 0;
// For Methods, we get only public if sealed, or public/protected if not sealed
if (methodInfos == null)
{
methodInfos = GetMethods(monoType);
}
// For constructors, we get only public if sealed, or public/protected if not sealed
if (constructorInfos == null)
{
constructorInfos = GetConstructors(monoType);
}
// Populate methods
pTypeDef->ppMethods = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef *)));
pMethodDefs = (tMD_MethodDef *)Mem.mallocForever((SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef)));
Mem.memset(pMethodDefs, 0, (SIZE_T)(pTypeDef->numMethods * sizeof(tMD_MethodDef)));
for (i = 0; i < pTypeDef->numMethods; i++)
{
methodBase = (i < constructorInfos.Length) ?
(MethodBase)constructorInfos[i] : methodInfos[i - constructorInfos.Length];
pMethodDef = &pMethodDefs[i];
lastPeriod = methodBase.Name.LastIndexOf('.');
if (methodBase is ConstructorInfo || lastPeriod == -1)
{
pMethodDef->name = new S(methodBase.Name);
}
else
{
string nameMinusExclInterfaceName = methodBase.Name.Substring(lastPeriod + 1);
pMethodDef->name = new S(nameMinusExclInterfaceName);
}
pMethodDef->monoMethodInfo = new H(methodBase);
pMethodDef->pMetaData = pMetaData;
pMethodDef->pParentType = pTypeDef;
pMethodDef->flags = (ushort)(
(methodBase.IsVirtual ? MetaData.METHODATTRIBUTES_VIRTUAL : 0) |
(methodBase.IsStatic ? MetaData.METHODATTRIBUTES_STATIC : 0));
// NOTE: All mono calls are considered internal calls
pMethodDef->implFlags = (ushort)MetaData.METHODIMPLATTRIBUTES_INTERNALCALL;
pTypeDef->ppMethods[i] = pMethodDef;
// Assign vtable slots
if (methodBase.IsVirtual)
{
if (((MethodInfo)methodBase).GetBaseDefinition().DeclaringType == monoType)
{
// Allocate a new vTable slot if method is explicitly marked as NewSlot, or
// this is of type Object.
pMethodDef->vTableOfs = virtualOfs++;
}
else
{
tMD_MethodDef *pVirtualOveriddenMethod;
pVirtualOveriddenMethod = MetaData.FindVirtualOverriddenMethod(pTypeDef->pParent, pMethodDef);
if (pVirtualOveriddenMethod == null)
{
if (pTypeDef->pParent->monoType == null)
{
// DNA types don't always have all base methods that Unity/Mono has. In those
// cases, just add the missing method to the VTable as a new virtual method.
pMethodDef->vTableOfs = virtualOfs++;
}
else
{
Sys.Crash("Unable to find virtual override %s", (PTR)(pMethodDef->name));
}
}
else
{
pMethodDef->vTableOfs = pVirtualOveriddenMethod->vTableOfs;
}
}
}
else
{
// Dummy value - make it obvious it's not valid!
pMethodDef->vTableOfs = 0xffffffff;
}
pTypeDef->ppMethods[i] = pMethodDef;
}
// Create the virtual method table
pTypeDef->numVirtualMethods = virtualOfs;
// Resolve all members
pTypeDef->pVTable = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pTypeDef->numVirtualMethods * sizeof(tMD_MethodDef *)));
// Copy initial vTable from parent
if (pTypeDef->pParent != null)
{
Mem.memcpy(pTypeDef->pVTable, pTypeDef->pParent->pVTable, (SIZE_T)(pTypeDef->pParent->numVirtualMethods * sizeof(tMD_MethodDef *)));
}
for (i = 0; i < pTypeDef->numMethods; i++)
{
pMethodDef = pTypeDef->ppMethods[i];
methodBase = H.ToObj(pMethodDef->monoMethodInfo) as MethodBase;
if (methodBase.IsStatic && methodBase.Name == ".cctor")
{
// This is a static constructor
pTypeDef->pStaticConstructor = pMethodDef;
}
if (methodBase.IsStatic && pTypeDef->pParent != null &&
methodBase.Name == "Finalize")
{
// This is a Finalizer method, but not for Object.
// Delibrately miss out Object's Finalizer because it's empty and will cause every object
// of any type to have a Finalizer which will be terrible for performance.
pTypeDef->pFinalizer = pMethodDef;
}
if (methodBase.IsVirtual)
{
if (pMethodDef->vTableOfs == 0xffffffff)
{
Sys.Crash("Illegal vtableoffset");
}
if (pMethodDef->vTableOfs >= pTypeDef->numVirtualMethods)
{
Sys.Crash("Illegal vtableoffset");
}
pTypeDef->pVTable[pMethodDef->vTableOfs] = pMethodDef;
}
}
// Find inherited Finalizer, if this type doesn't have an explicit Finalizer, and if there is one
if (pTypeDef->pFinalizer == null)
{
tMD_TypeDef *pInheritedType = pTypeDef->pParent;
while (pInheritedType != null)
{
if (pInheritedType->pFinalizer != null)
{
pTypeDef->pFinalizer = pInheritedType->pFinalizer;
break;
}
pInheritedType = pInheritedType->pParent;
}
}
}
if (pTypeDef->fillState >= resolve)
{
return;
}
}
if (pTypeDef->fillState < Type.TYPE_FILL_MEMBERS)
{
pTypeDef->fillState = Type.TYPE_FILL_MEMBERS;
if (pParent != null)
{
if (pParent->fillState < Type.TYPE_FILL_MEMBERS)
{
MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_MEMBERS);
}
else if (pParent->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_Defer(pParent, null, null);
}
}
// This only needs to be done for non-generic Type.types, or for generic type that are not a definition
// I.e. Fully instantiated generic Type.types
if (pTypeDef->isGenericDefinition == 0)
{
// Fill all method definitions for this type
for (i = 0; i < pTypeDef->numMethods; i++)
{
pMethodDef = pTypeDef->ppMethods[i];
methodBase = H.ToObj(pMethodDef->monoMethodInfo) as MethodBase;
MonoType.Fill_MethodDef(pTypeDef, methodBase, pTypeDef->ppMethods[i], ppClassTypeArgs, ppMethodTypeArgs);
}
}
if (pTypeDef->fillState >= resolve)
{
return;
}
}
if (pTypeDef->fillState < Type.TYPE_FILL_INTERFACES)
{
pTypeDef->fillState = Type.TYPE_FILL_INTERFACES;
if (pParent != null)
{
if (pParent->fillState < Type.TYPE_FILL_INTERFACES)
{
MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_INTERFACES);
}
else if (pParent->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_Defer(pParent, null, null);
}
}
// This only needs to be done for non-generic Type.types, or for generic type that are not a definition
// I.e. Fully instantiated generic Type.types
if (pTypeDef->isGenericDefinition == 0)
{
// Map all interface method calls. This only needs to be done for Classes, not Interfaces
// And is not done for generic definitions.
if (!monoType.IsInterface)
{
System.Type[] interfaceTypes = monoType.GetInterfaces();
pTypeDef->numInterfaces = (uint)interfaceTypes.Length;
if (interfaceTypes.Length > 0 && pTypeDef->isGenericDefinition == 0)
{
if (pTypeDef->pInterfaceMaps == null)
{
pTypeDef->pInterfaceMaps = (tInterfaceMap *)Mem.mallocForever((SIZE_T)(pTypeDef->numInterfaces * sizeof(tInterfaceMap)));
}
for (i = 0; i < interfaceTypes.Length; i++)
{
// Get the interface that this type implements
tMD_TypeDef *pInterface = MonoType.GetTypeForMonoType(interfaceTypes[i], ppClassTypeArgs, ppMethodTypeArgs);
Fill_TypeDef(pInterface, ppClassTypeArgs, null, Type.TYPE_FILL_VTABLE);
InterfaceMapping interfaceMapping = monoType.GetInterfaceMap(interfaceTypes[i]);
MetaData.Fill_TypeDef(pInterface, null, null);
tInterfaceMap *pMap = &pTypeDef->pInterfaceMaps[i];
pMap->pInterface = pInterface;
pMap->pVTableLookup = (uint *)Mem.mallocForever((SIZE_T)(pInterface->numVirtualMethods * sizeof(uint)));
pMap->ppMethodVLookup = (tMD_MethodDef **)Mem.mallocForever((SIZE_T)(pInterface->numVirtualMethods * sizeof(tMD_MethodDef *)));
MethodInfo[] interfaceMethods = interfaceMapping.InterfaceMethods;
MethodInfo[] targetMethods = interfaceMapping.TargetMethods;
// Discover interface mapping for each interface method
for (j = 0; j < pInterface->numVirtualMethods; j++)
{
tMD_MethodDef *pInterfaceMethod = pInterface->pVTable[j];
tMD_MethodDef *pOverriddenMethod = FindInterfaceOverriddenMethod(pInterfaceMethod, interfaceMethods, targetMethods);
if (pOverriddenMethod == null)
{
Sys.Crash("Unable to find override method %s in type %s.%s for interface %s.%s", (PTR)(pInterfaceMethod->name),
(PTR)pTypeDef->nameSpace, (PTR)pTypeDef->name,
(PTR)pInterface->nameSpace, (PTR)pInterface->name);
}
pMap->pVTableLookup[j] = pOverriddenMethod->vTableOfs;
pMap->ppMethodVLookup[j] = pOverriddenMethod;
}
}
}
}
}
if (pTypeDef->fillState >= resolve)
{
return;
}
}
if (pTypeDef->fillState < Type.TYPE_FILL_ALL)
{
pTypeDef->fillState = Type.TYPE_FILL_ALL;
if (pParent != null && pParent->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_TypeDef(pParent, null, null, Type.TYPE_FILL_ALL);
}
if (isDeferred != 0)
{
MetaData.Fill_ResolveDeferred();
}
}
Sys.log_f(2, "Mono Type: %s.%s\n", (PTR)pTypeDef->nameSpace, (PTR)pTypeDef->name);
}
public static uint CompareNameAndSig(/*STRING*/ byte *name, /*BLOB_*/ byte *sigBlob, tMetaData *pSigMetaData,
tMD_TypeDef **ppSigClassTypeArgs, tMD_TypeDef **ppSigMethodTypeArgs, tMD_MethodDef *pMethod, tMD_TypeDef **ppMethodClassTypeArgs,
tMD_TypeDef **ppMethodMethodTypeArgs)
{
if (S.strcmp(name, pMethod->name) == 0)
{
if (pMethod->signature != null)
{
/*SIG*/ byte *sig, thisSig;
uint e, thisE, paramCount, i;
sig = MetaData.GetBlob(sigBlob, null);
thisSig = MetaData.GetBlob(pMethod->signature, null);
e = MetaData.DecodeSigEntry(&sig);
thisE = MetaData.DecodeSigEntry(&thisSig);
// Check method call type (static, etc...)
if (e != thisE)
{
return(0);
}
// If method has generic arguments, check the generic type argument count
if ((e & SIG_METHODDEF_GENERIC) != 0)
{
e = MetaData.DecodeSigEntry(&sig);
thisE = MetaData.DecodeSigEntry(&thisSig);
// Generic argument count
if (e != thisE)
{
return(0);
}
}
e = MetaData.DecodeSigEntry(&sig);
thisE = MetaData.DecodeSigEntry(&thisSig);
// check parameter count
if (e != thisE)
{
return(0);
}
paramCount = e + 1; // +1 to include the return type
// check all parameters
for (i = 0; i < paramCount; i++)
{
tMD_TypeDef *pParamType;
tMD_TypeDef *pThisParamType;
pParamType = Type.GetTypeFromSig(pSigMetaData, &sig,
ppSigClassTypeArgs, ppSigMethodTypeArgs, null);
pThisParamType = Type.GetTypeFromSig(pMethod->pMetaData, &thisSig,
ppMethodClassTypeArgs, ppMethodMethodTypeArgs, null);
if (pParamType != pThisParamType)
{
return(0);
}
}
// All parameters the same, so found the right method
return(1);
}
else if (pMethod->monoMethodInfo != null)
{
/*SIG*/
byte * sig;
uint e, paramCount, i;
MethodBase methodBase = H.ToObj(pMethod->monoMethodInfo) as MethodBase;
sig = MetaData.GetBlob(sigBlob, null);
e = MetaData.DecodeSigEntry(&sig);
// Check method call type (static, etc...)
if (methodBase.IsStatic && (e & (SIG_METHODDEF_HASTHIS | SIG_METHODDEF_EXPLICITTHIS)) != 0)
{
return(0);
}
// If method has generic arguments, check the generic type argument count
if ((e & SIG_METHODDEF_GENERIC) != 0)
{
if (!methodBase.IsGenericMethod)
{
return(0);
}
e = MetaData.DecodeSigEntry(&sig);
// Generic argument count
if (e != methodBase.GetGenericArguments().Length)
{
return(0);
}
}
paramCount = MetaData.DecodeSigEntry(&sig);
System.Reflection.ParameterInfo[] paramInfos = methodBase.GetParameters();
if (paramCount != paramInfos.Length)
{
return(0);
}
tMD_TypeDef *pReturnType = Type.GetTypeFromSig(pSigMetaData, &sig,
ppSigClassTypeArgs, ppSigMethodTypeArgs, null);
if (methodBase is MethodInfo)
{
tMD_TypeDef *pThisReturnType = MonoType.GetTypeForMonoType(((MethodInfo)methodBase).ReturnType,
ppMethodClassTypeArgs, ppMethodMethodTypeArgs);
if (pReturnType == null)
{
if (pThisReturnType != Type.types[Type.TYPE_SYSTEM_VOID])
{
return(0);
}
}
else if (pReturnType != pThisReturnType)
{
return(0);
}
}
// check all parameters
for (i = 0; i < paramCount; i++)
{
tMD_TypeDef *pParamType;
tMD_TypeDef *pThisParamType;
pParamType = Type.GetTypeFromSig(pSigMetaData, &sig,
ppSigClassTypeArgs, ppSigMethodTypeArgs, null);
pThisParamType = MonoType.GetTypeForMonoType(paramInfos[i].ParameterType,
ppMethodClassTypeArgs, ppMethodMethodTypeArgs);
if (pParamType != pThisParamType)
{
return(0);
}
}
// All parameters the same, so found the right method
return(1);
}
else
{
Sys.Crash("Method with no sig or methodInfo");
}
}
return(0);
}
/// <summary>
/// Returns the DNA methodDef for a method given a typeDef, method name, and argument types.
/// </summary>
/// <param name="typeDef">The DNA typeDef for a type</param>
/// <param name="methodName">The method name</param>
/// <param name="argTypes">The types of the method's arguments or null if no arguments</param>
/// <returns>The methodDef found or 0 if no method matches</returns>
public static ulong FindMethod(ulong typeDef, string methodName, System.Type[] argTypes = null)
{
if (!_isInitialized)
{
Init();
}
int numArgs = argTypes != null ? argTypes.Length : 0;
byte *mName = stackalloc byte[128];
S.strncpy(mName, methodName, 128);
// Find any overload of the named method; assume it's the right one.
// Specifying it exactly (type generic args, method generic args, arguments themselves, picking the
// inherited methods if needed), is complex and not required at the moment.
tMD_TypeDef * pTypeDef = (tMD_TypeDef *)(PTR)typeDef;
tMD_MethodDef *pMethodDef = null;
bool matches = false;
while (pTypeDef != null)
{
if (pTypeDef->fillState < Type.TYPE_FILL_ALL)
{
MetaData.Fill_TypeDef(pTypeDef, null, null);
}
for (int i = 0; i < pTypeDef->numMethods; i++)
{
tMD_MethodDef *pCheckMethodDef = pTypeDef->ppMethods[i];
int start = 0;
if (!MetaData.METHOD_ISSTATIC(pCheckMethodDef))
{
start = 1;
}
matches = false;
if (S.strcmp(pCheckMethodDef->name, mName) == 0 &&
(pCheckMethodDef->numberOfParameters - start == numArgs))
{
matches = true;
for (int j = start; j < pCheckMethodDef->numberOfParameters; j++)
{
tMD_TypeDef *pArgType = MonoType.GetTypeForMonoType(argTypes[j - start], null, null);
if (pArgType != pCheckMethodDef->pParams[j].pStackTypeDef)
{
matches = false;
break;
}
}
}
if (matches)
{
pMethodDef = pCheckMethodDef;
break;
}
}
if (matches)
{
break;
}
pTypeDef = pTypeDef->pParent;
}
return((ulong)pMethodDef);
}
public static uint CompareNameAndMethodInfo(/*STRING*/ byte *name, System.Reflection.MethodBase methodBase, tMetaData *pSigMetaData,
tMD_TypeDef **ppSigClassTypeArgs, tMD_TypeDef **ppSigMethodTypeArgs, tMD_MethodDef *pMethod, tMD_TypeDef **ppMethodClassTypeArgs,
tMD_TypeDef **ppMethodMethodTypeArgs)
{
if (S.strcmp(name, pMethod->name) == 0)
{
uint i;
if (METHOD_ISSTATIC(pMethod) != methodBase.IsStatic ||
METHOD_ISVIRTUAL(pMethod) != methodBase.IsVirtual)
{
return(0);
}
System.Reflection.ParameterInfo[] paramInfos = methodBase.GetParameters();
uint numberOfParameters = (uint)(paramInfos.Length + (methodBase.IsStatic ? 0 : 1));
if ((uint)pMethod->numberOfParameters != numberOfParameters)
{
return(0);
}
if (methodBase.IsGenericMethod != (pMethod->isGenericDefinition != 0))
{
return(0);
}
if (methodBase is MethodInfo)
{
if (pMethod->pReturnType == null)
{
if (((MethodInfo)methodBase).ReturnType != typeof(void))
{
return(0);
}
}
else if (pMethod->pReturnType != MonoType.GetTypeForMonoType(((MethodInfo)methodBase).ReturnType,
ppMethodClassTypeArgs, ppMethodMethodTypeArgs))
{
return(0);
}
}
uint start = 0;
if (!methodBase.IsStatic)
{
// if (pMethod->pParams[0].pStackTypeDef != MonoType.GetTypeForMonoType(methodInfo.DeclaringType))
// return 0;
start = 1;
}
for (i = start; i < numberOfParameters; i++)
{
tParameter *pParam = &pMethod->pParams[i];
System.Reflection.ParameterInfo paramInfo = paramInfos[i - start];
// NOTE: We are not checking to see if params are REF params here. Potentially a problem.
if (pParam->pStackTypeDef != MonoType.GetTypeForMonoType(paramInfo.ParameterType,
ppMethodClassTypeArgs, ppMethodMethodTypeArgs))
{
return(0);
}
}
return(1);
}
return(0);
}
