public static tAsyncCall *Equals(tJITCallNative *pCallNative, byte *pThis_, byte *pParams, byte *pReturnValue)
{
tSystemString *a, b;
uint ret;
char * pAChars, pBChars;
a = (*((tSystemString **)(pParams + 0)));
b = (*((tSystemString **)(pParams + Sys.S_PTR)));
if (a == b)
{
ret = 1;
}
else if (a == null || b == null || a->length != b->length)
{
ret = 0;
}
else
{
pAChars = tSystemString.GetChars(a);
pBChars = tSystemString.GetChars(b);
ret = (uint)((Mem.memcmp(pAChars, pBChars, (SIZE_T)(a->length << 1)) == 0)?1:0);
}
Sys.INTERNALCALL_RESULT_U32(pReturnValue, ret);
return(null);
}
public static tMD_MethodDef *GetMethodDefFromCoreMethod(tMD_MethodDef *pCoreMethod,
tMD_TypeDef *pParentType, uint numTypeArgs, tMD_TypeDef **ppTypeArgs,
HashSet <PTR> resolveTypes = null)
{
tGenericMethodInstance *pInst;
tMD_MethodDef * pMethod;
int i;
Mem.heapcheck();
// See if we already have an instance with the given type args
pInst = pCoreMethod->pGenericMethodInstances;
while (pInst != null)
{
if (pInst->numTypeArgs == numTypeArgs &&
Mem.memcmp(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *))) == 0)
{
return(pInst->pInstanceMethodDef);
}
pInst = pInst->pNext;
}
// We don't have an instance so create one now.
pInst = (tGenericMethodInstance *)Mem.mallocForever((SIZE_T)(sizeof(tGenericMethodInstance)));
pInst->pNext = pCoreMethod->pGenericMethodInstances;
pCoreMethod->pGenericMethodInstances = pInst;
pInst->numTypeArgs = numTypeArgs;
pInst->ppTypeArgs = (tMD_TypeDef **)Mem.malloc((SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *)));
Mem.memcpy(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *)));
pInst->pInstanceMethodDef = pMethod = ((tMD_MethodDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_MethodDef)));
Mem.memset(pMethod, 0, (SIZE_T)sizeof(tMD_MethodDef));
pMethod->pMethodDef = pMethod;
pMethod->pMetaData = pCoreMethod->pMetaData;
pMethod->pCIL = pCoreMethod->pCIL;
pMethod->implFlags = pCoreMethod->implFlags;
pMethod->flags = pCoreMethod->flags;
pMethod->name = pCoreMethod->name;
pMethod->signature = pCoreMethod->signature;
pMethod->vTableOfs = pCoreMethod->vTableOfs;
pMethod->ppMethodTypeArgs = pInst->ppTypeArgs;
MetaData.Fill_MethodDef(pParentType, pMethod, pParentType->ppClassTypeArgs, pInst->ppTypeArgs);
Mem.heapcheck();
return(pMethod);
}
public static tMD_TypeDef *GetGenericTypeFromCoreType(tMD_TypeDef *pCoreType, uint numTypeArgs,
tMD_TypeDef **ppTypeArgs)
{
tGenericInstance *pInst;
tMD_TypeDef * pTypeDef;
uint i;
byte * name = stackalloc byte[NAME_BUF_SIZE];
byte * namePos, nameEnd;
tMetaData *pMetaData;
Mem.heapcheck();
pMetaData = pCoreType->pMetaData;
MetaData.Fill_TypeDef(pCoreType, null, null, Type.TYPE_FILL_PARENTS);
// See if we have already built an instantiation of this type with the given type args.
pInst = pCoreType->pGenericInstances;
while (pInst != null)
{
if (pInst->numTypeArgs == numTypeArgs &&
Mem.memcmp(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *))) == 0)
{
return(pInst->pInstanceTypeDef);
}
pInst = pInst->pNext;
}
// This has not already been instantiated, so instantiate it now.
pInst = (tGenericInstance *)Mem.mallocForever((SIZE_T)sizeof(tGenericInstance));
// Insert this into the chain of instantiations.
pInst->pNext = pCoreType->pGenericInstances;
pCoreType->pGenericInstances = pInst;
// Copy the type args into the instantiation.
pInst->numTypeArgs = numTypeArgs;
pInst->ppTypeArgs = (tMD_TypeDef **)Mem.malloc((SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *)));
Mem.memcpy(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *)));
Mem.heapcheck();
// Create the new instantiated type
pInst->pInstanceTypeDef = pTypeDef = ((tMD_TypeDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_TypeDef)));
Mem.memset(pTypeDef, 0, (SIZE_T)sizeof(tMD_TypeDef));
// Make the name of the instantiation.
namePos = name;
nameEnd = namePos + NAME_BUF_SIZE - 1;
namePos = S.scatprintf(namePos, nameEnd, "%s", (PTR)pCoreType->name);
namePos = S.scatprintf(namePos, nameEnd, "[");
for (i = 0; i < numTypeArgs; i++)
{
if (i > 0)
{
namePos = S.scatprintf(namePos, nameEnd, ",");
}
if (ppTypeArgs[i] != null)
{
namePos = S.scatprintf(namePos, nameEnd, "%s.%s", (PTR)ppTypeArgs[i]->nameSpace, (PTR)ppTypeArgs[i]->name);
}
else
{
tMD_GenericParam *pGenericParam = FindGenericParam(pCoreType, i);
if (pGenericParam != null)
{
namePos = S.scatprintf(namePos, nameEnd, "%s", (PTR)pGenericParam->name);
}
else
{
namePos = S.scatprintf(namePos, nameEnd, "???");
}
}
}
namePos = S.scatprintf(namePos, nameEnd, "]");
// Fill in the basic bits of the new type def.
pTypeDef->pTypeDef = pTypeDef;
pTypeDef->pMetaData = pMetaData;
pTypeDef->flags = pCoreType->flags;
pTypeDef->pGenericDefinition = pCoreType;
for (i = 0; i < numTypeArgs; i++)
{
if (ppTypeArgs[i] == null)
{
pTypeDef->isGenericDefinition = 1;
break;
}
}
pTypeDef->nameSpace = pCoreType->nameSpace;
int nameLen = S.strlen(name) + 1;
pTypeDef->name = (/*STRING*/ byte *)Mem.mallocForever((SIZE_T)nameLen);
S.strncpy(pTypeDef->name, name, nameLen);
pTypeDef->ppClassTypeArgs = pInst->ppTypeArgs;
pTypeDef->extends = pCoreType->extends;
pTypeDef->tableIndex = pCoreType->tableIndex;
pTypeDef->fieldList = pCoreType->fieldList;
pTypeDef->methodList = pCoreType->methodList;
pTypeDef->numFields = pCoreType->numFields;
pTypeDef->numMethods = pCoreType->numMethods;
pTypeDef->numVirtualMethods = pCoreType->numVirtualMethods;
pTypeDef->pNestedIn = pCoreType->pNestedIn;
pTypeDef->isPrimed = 1;
MetaData.Fill_TypeDef(pTypeDef, pInst->ppTypeArgs, null, Type.TYPE_FILL_PARENTS);
Mem.heapcheck();
return(pTypeDef);
}
public static tMD_MethodDef *GetMethodDefFromCoreMethod(tMD_MethodDef *pCoreMethod,
tMD_TypeDef *pParentType, uint numTypeArgs, tMD_TypeDef **ppTypeArgs,
HashSet <PTR> resolveTypes = null)
{
tGenericMethodInstance *pInst;
tMD_MethodDef * pMethod;
Mem.heapcheck();
// See if we already have an instance with the given type args
pInst = pCoreMethod->pGenericMethodInstances;
while (pInst != null)
{
if (pInst->numTypeArgs == numTypeArgs &&
Mem.memcmp(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *))) == 0)
{
return(pInst->pInstanceMethodDef);
}
pInst = pInst->pNext;
}
// We don't have an instance so create one now.
pInst = (tGenericMethodInstance *)Mem.mallocForever((SIZE_T)(sizeof(tGenericMethodInstance)));
pInst->pNext = pCoreMethod->pGenericMethodInstances;
pCoreMethod->pGenericMethodInstances = pInst;
pInst->numTypeArgs = numTypeArgs;
pInst->ppTypeArgs = (tMD_TypeDef **)Mem.malloc((SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *)));
Mem.memcpy(pInst->ppTypeArgs, ppTypeArgs, (SIZE_T)(numTypeArgs * sizeof(tMD_TypeDef *)));
pInst->pInstanceMethodDef = pMethod = ((tMD_MethodDef *)Mem.mallocForever((SIZE_T)sizeof(tMD_MethodDef)));
Mem.memset(pMethod, 0, (SIZE_T)sizeof(tMD_MethodDef));
pMethod->pMethodDef = pMethod;
pMethod->pMetaData = pCoreMethod->pMetaData;
pMethod->pCIL = pCoreMethod->pCIL;
pMethod->implFlags = pCoreMethod->implFlags;
pMethod->flags = pCoreMethod->flags;
pMethod->name = pCoreMethod->name;
pMethod->signature = pCoreMethod->signature;
pMethod->vTableOfs = pCoreMethod->vTableOfs;
pMethod->ppMethodTypeArgs = pInst->ppTypeArgs;
if (pCoreMethod->monoMethodInfo != null)
{
System.Reflection.MethodInfo methodInfo = H.ToObj(pCoreMethod->monoMethodInfo) as System.Reflection.MethodInfo;
System.Type[] typeArgs = new System.Type[(int)numTypeArgs];
for (uint i = 0; i < numTypeArgs; i++)
{
typeArgs[i] = MonoType.GetMonoTypeForType(ppTypeArgs[i]);
if (typeArgs[i] == null)
{
Sys.Crash("Unable to find mono type for type arg %s.%s in for generic method %s",
(PTR)ppTypeArgs[i]->nameSpace, (PTR)ppTypeArgs[i]->name, (PTR)pCoreMethod->name);
}
}
System.Reflection.MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(typeArgs);
MonoType.Fill_MethodDef(pParentType, genericMethodInfo, pMethod, pParentType->ppClassTypeArgs, pInst->ppTypeArgs);
}
else
{
MetaData.Fill_MethodDef(pParentType, pMethod, pParentType->ppClassTypeArgs, pInst->ppTypeArgs);
}
Mem.heapcheck();
return(pMethod);
}
