/*
* Convert a method reference type into a method block.
* Returns NULL if not a method reference type.
*/
static ILMethod *MethodRefToMethod(ILType *type)
{
if(type != 0 && ILType_IsComplex(type) &&
ILType_Kind(type) == IL_TYPE_COMPLEX_METHOD_REF)
{
return (ILMethod *)(ILType_Ref(type));
}
else
{
return 0;
}
}
/*
* Get type size information.
*/
static void GetTypeSize(ILSizeInfo *info, ILType *type)
{
unsigned long num;
unsigned long posn;
/* Only complex types have a non-zero memory size */
if(type == 0 || !ILType_IsComplex(type))
{
return;
}
/* Account for the size of the complex type header */
info->loadedMeta += sizeof(ILType);
/* Account for element information */
switch(ILType_Kind(type))
{
case IL_TYPE_COMPLEX_BYREF:
case IL_TYPE_COMPLEX_PTR:
case IL_TYPE_COMPLEX_PINNED:
{
GetTypeSize(info, ILType_Ref(type));
}
break;
case IL_TYPE_COMPLEX_ARRAY:
case IL_TYPE_COMPLEX_ARRAY_CONTINUE:
{
GetTypeSize(info, ILType_ElemType(type));
}
break;
case IL_TYPE_COMPLEX_CMOD_REQD:
case IL_TYPE_COMPLEX_CMOD_OPT:
{
GetTypeSize(info, type->un.modifier__.type__);
}
break;
case IL_TYPE_COMPLEX_LOCALS:
{
num = ILTypeNumLocals(type);
for(posn = 0; posn < num; ++posn)
{
GetTypeSize(info, ILTypeGetLocalWithPrefixes(type, posn));
}
}
break;
case IL_TYPE_COMPLEX_WITH:
{
num = ILTypeNumWithParams(type);
GetTypeSize(info, ILTypeGetWithMainWithPrefixes(type));
for(posn = 1; posn <= num; ++posn)
{
GetTypeSize(info, ILTypeGetWithParamWithPrefixes(type, posn));
}
}
break;
case IL_TYPE_COMPLEX_PROPERTY:
case IL_TYPE_COMPLEX_METHOD:
case IL_TYPE_COMPLEX_METHOD | IL_TYPE_COMPLEX_METHOD_SENTINEL:
{
num = ILTypeNumParams(type);
GetTypeSize(info, ILTypeGetReturnWithPrefixes(type));
for(posn = 1; posn <= num; ++posn)
{
GetTypeSize(info, ILTypeGetParamWithPrefixes(type, posn));
}
}
break;
}
}
/*
* Convert a type into an engine type.
*/
static ILEngineType TypeToEngineType(ILType *type)
{
type = ILTypeGetEnumType(type);
if(ILType_IsPrimitive(type))
{
switch(ILType_ToElement(type))
{
case IL_META_ELEMTYPE_BOOLEAN:
case IL_META_ELEMTYPE_I1:
case IL_META_ELEMTYPE_U1:
case IL_META_ELEMTYPE_I2:
case IL_META_ELEMTYPE_U2:
case IL_META_ELEMTYPE_CHAR:
case IL_META_ELEMTYPE_I4:
case IL_META_ELEMTYPE_U4: return ILEngineType_I4;
case IL_META_ELEMTYPE_I8:
case IL_META_ELEMTYPE_U8: return ILEngineType_I8;
case IL_META_ELEMTYPE_I:
case IL_META_ELEMTYPE_U: return ILEngineType_I;
case IL_META_ELEMTYPE_R4:
case IL_META_ELEMTYPE_R8:
case IL_META_ELEMTYPE_R: return ILEngineType_F;
case IL_META_ELEMTYPE_TYPEDBYREF: return ILEngineType_TypedRef;
}
return ILEngineType_I4;
}
else if(ILType_IsValueType(type))
{
return ILEngineType_MV;
}
else if(ILType_IsComplex(type) && type != 0)
{
switch(ILType_Kind(type))
{
case IL_TYPE_COMPLEX_PTR:
{
/* Unsafe pointers are represented as native integers */
return ILEngineType_I;
}
/* Not reached */
case IL_TYPE_COMPLEX_BYREF:
{
/* Reference values are managed pointers */
return ILEngineType_M;
}
/* Not reached */
case IL_TYPE_COMPLEX_PINNED:
{
/* Pinned types are the same as their underlying type */
return TypeToEngineType(ILType_Ref(type));
}
/* Not reached */
case IL_TYPE_COMPLEX_CMOD_REQD:
case IL_TYPE_COMPLEX_CMOD_OPT:
{
/* Strip the modifier and inspect the underlying type */
return TypeToEngineType(type->un.modifier__.type__);
}
/* Not reached */
case IL_TYPE_COMPLEX_METHOD:
case IL_TYPE_COMPLEX_METHOD | IL_TYPE_COMPLEX_METHOD_SENTINEL:
{
/* Pass method pointers around the system as "I". Higher
level code will also set the "typeInfo" field to reflect
the signature so that method pointers become verifiable */
return ILEngineType_I;
}
/* Not reached */
}
}
return ILEngineType_O;
}
ILUInt32 ILPInvokeGetMarshalType(ILPInvoke *pinvoke, ILMethod *method,
unsigned long param, char **customName,
int *customNameLen, char **customCookie,
int *customCookieLen, ILType *type)
{
ILParameter *parameter;
ILFieldMarshal *marshal;
const unsigned char *nativeType;
unsigned long nativeTypeLen;
int nativeTypeCode;
/* Find the parameter information block */
if(method)
{
if(!(method->parameters))
{
_ILMethodLoadParams(method);
}
parameter = method->parameters;
while(parameter != 0 && parameter->paramNum != param)
{
parameter = parameter->next;
}
}
else
{
parameter = 0;
}
/* See if we have native type information for the parameter */
nativeType = 0;
nativeTypeLen = 0;
nativeTypeCode = IL_META_NATIVETYPE_END;
if(parameter != 0)
{
marshal = ILFieldMarshalGetFromOwner(&(parameter->programItem));
if(marshal != 0)
{
nativeType = (const unsigned char *)
ILFieldMarshalGetType(marshal, &nativeTypeLen);
if(nativeTypeLen > 0)
{
nativeTypeCode = (int)(nativeType[0]);
}
}
}
/* Initialize the custom name return information to nothing */
*customName = 0;
*customNameLen = 0;
*customCookie = 0;
*customCookieLen = 0;
/* If the native type is "interface", then always marshal directly.
This is normally used to force strings, delegates, and arrays
to be passed as objects */
if(nativeTypeCode == IL_META_NATIVETYPE_INTF)
{
return IL_META_MARSHAL_DIRECT;
}
/* Check for custom marshalling */
if(nativeTypeCode == IL_META_NATIVETYPE_CUSTOMMARSHALER &&
ILTypeIsReference(type))
{
ILMetaDataRead reader;
reader.data = nativeType + 1;
reader.len = nativeTypeLen - 1;
reader.error = 0;
ExtractCustomString(customName, customNameLen); /* Unused GUID */
ExtractCustomString(customName, customNameLen); /* Unused native name */
ExtractCustomString(customName, customNameLen);
ExtractCustomString(customCookie, customCookieLen);
if(*customNameLen > 0)
{
return IL_META_MARSHAL_CUSTOM;
}
else
{
return IL_META_MARSHAL_DIRECT;
}
}
/* Determine what to do based on the parameter type */
if(ILTypeIsStringClass(type))
{
/* Value string type */
if(nativeTypeCode == IL_META_NATIVETYPE_LPWSTR)
{
#ifdef IL_WIN32_PLATFORM
return IL_META_MARSHAL_UTF16_STRING;
#else
return IL_META_MARSHAL_UTF8_STRING;
#endif
}
else if(nativeTypeCode == IL_META_NATIVETYPE_LPSTR)
{
return IL_META_MARSHAL_ANSI_STRING;
}
else
{
return ILPInvokeGetCharSet(pinvoke, method);
}
}
else if(ILTypeIsDelegateSubClass(type))
{
/* Delegate type */
return IL_META_MARSHAL_FNPTR;
}
else if(ILType_IsSimpleArray(type))
{
if(ILTypeIsStringClass(ILTypeGetElemType(type)))
{
/* Array of strings, passed as "char **" */
switch(ILPInvokeGetCharSet(pinvoke, method))
{
case IL_META_MARSHAL_UTF8_STRING:
{
return IL_META_MARSHAL_UTF8_ARRAY;
}
/* not reached */
case IL_META_MARSHAL_UTF16_STRING:
{
return IL_META_MARSHAL_UTF16_ARRAY;
}
/* not reached */
default:
{
return IL_META_MARSHAL_ANSI_ARRAY;
}
/* not reached */
}
}
else
{
/* Array type, passed in by pointer to the first element */
return IL_META_MARSHAL_ARRAY;
}
}
else if(type != 0 && ILType_IsComplex(type) &&
ILType_Kind(type) == IL_TYPE_COMPLEX_BYREF)
{
/* Check for "ref String[]", which is used by Gtk# when
calling the "gtk_init" function */
if(ILType_IsSimpleArray(ILType_Ref(type)) &&
ILTypeIsStringClass(ILTypeGetElemType(ILType_Ref(type))))
{
switch(ILPInvokeGetCharSet(pinvoke, method))
{
case IL_META_MARSHAL_UTF8_STRING:
{
return IL_META_MARSHAL_REF_UTF8_ARRAY;
}
/* not reached */
case IL_META_MARSHAL_UTF16_STRING:
{
return IL_META_MARSHAL_REF_UTF16_ARRAY;
}
/* not reached */
default:
{
return IL_META_MARSHAL_REF_ANSI_ARRAY;
}
/* not reached */
}
return IL_META_MARSHAL_REF_ANSI_ARRAY;
}
}
/* Marshal the parameter directly */
return IL_META_MARSHAL_DIRECT;
}
