/*
* Determine if a stack item is assignment-compatible with
* a particular memory slot (argument, local, field, etc).
*/
static int AssignCompatible(ILMethod *method, ILEngineStackItem *item,
ILType *type, int unsafeAllowed)
{
ILImage *image;
ILClass *classInfo;
ILClass *classInfo2;
ILMethod *methodRef;
ILType *objType;
/* Check for safe and unsafe pointer assignments */
if(item->engineType == ILEngineType_I)
{
methodRef = MethodRefToMethod(item->typeInfo);
if(methodRef)
{
/* Assigning a method reference, obtained via "ldftn"
or "ldvirtftn", to a method pointer destination */
if(ILTypeIdentical(ILMethod_Signature(methodRef), type))
{
return 1;
}
}
else if(item->typeInfo != 0 && ILType_IsComplex(item->typeInfo))
{
/* May be trying to assign a method pointer to a method type */
if(ILType_IsMethod(item->typeInfo))
{
if(ILTypeIdentical(item->typeInfo, type))
{
return 1;
}
}
}
if(unsafeAllowed)
{
if(type != 0 && ILType_IsComplex(type))
{
if((ILType_Kind(type) & IL_TYPE_COMPLEX_METHOD) != 0 ||
ILType_Kind(type) == IL_TYPE_COMPLEX_PTR)
{
return 1;
}
}
}
}
/* Check for regular assignments */
if(item->engineType == ILEngineType_I4 ||
item->engineType == ILEngineType_I)
{
type = ILTypeGetEnumType(type);
switch((unsigned long)type)
{
case (unsigned long)ILType_Boolean:
case (unsigned long)ILType_Int8:
case (unsigned long)ILType_UInt8:
case (unsigned long)ILType_Int16:
case (unsigned long)ILType_UInt16:
case (unsigned long)ILType_Char:
case (unsigned long)ILType_Int32:
case (unsigned long)ILType_UInt32:
case (unsigned long)ILType_Int:
case (unsigned long)ILType_UInt: return 1;
default: break;
}
if(!unsafeAllowed)
{
return 0;
}
/* Allow a native int to be assigned to a complex type */
if(type != 0 && ILType_IsComplex(type) &&
item->engineType == ILEngineType_I)
{
if(ILType_Kind(type) == IL_TYPE_COMPLEX_PTR ||
ILType_Kind(type) == IL_TYPE_COMPLEX_BYREF)
{
return 1;
}
}
return 0;
}
else if(item->engineType == ILEngineType_I8)
{
type = ILTypeGetEnumType(type);
return (type == ILType_Int64 || type == ILType_UInt64);
}
else if(item->engineType == ILEngineType_F)
{
return (type == ILType_Float32 ||
type == ILType_Float64 ||
type == ILType_Float);
}
else if(item->engineType == ILEngineType_O)
{
if(!(item->typeInfo))
{
/* A "null" constant was pushed, which is
compatible with any object reference type */
return IsObjectRef(type);
}
if(!IsObjectRef(type) || !IsObjectRef(item->typeInfo))
{
/* Both types must be object references */
return 0;
}
/* make a copy to avoid unecessary complications */
objType=item->typeInfo;
if(ILType_IsArray(type) && ILType_IsArray(objType) &&
(ILTypeGetRank(type) == ILTypeGetRank(objType)))
{
objType=ILTypeGetElemType(objType);
type=ILTypeGetElemType(type);
}
image = ILProgramItem_Image(method);
classInfo = ILClassResolve(ILClassFromType(image, 0, type, 0));
classInfo2 = ILClassResolve
(ILClassFromType(image, 0, objType, 0));
if(classInfo && classInfo2)
{
/* Is the type a regular class or an interface? */
if(!ILClass_IsInterface(classInfo))
{
/* Regular class: the value must inherit from the type */
if(ILClassInheritsFrom(classInfo2, classInfo))
{
return 1;
}
/* If "classInfo2" is an interface, then the conversion
is OK if "type" is "System.Object", because all
interfaces inherit from "System.Object", even though
the metadata doesn't explicitly say so */
if(ILClass_IsInterface(classInfo2))
{
return ILTypeIsObjectClass(type);
}
/* The conversion is not OK */
return 0;
}
else
{
/* Interface which the value must implement or inherit from */
return ILClassImplements(classInfo2, classInfo) ||
ILClassInheritsFrom(classInfo2, classInfo);
}
}
else
{
return 0;
}
}
else if(item->engineType == ILEngineType_MV)
{
/* Can only assign managed values to an exact type destination */
return ILTypeIdentical(item->typeInfo, type);
}
else if(item->engineType == ILEngineType_TypedRef)
{
/* The type must be "typedref" */
return (type == ILType_TypedRef);
}
else if(item->engineType == ILEngineType_M ||
item->engineType == ILEngineType_T)
{
/* Cannot assign managed pointers to variables or fields,
unless we are in "unsafe" mode */
if(!unsafeAllowed)
{
return 0;
}
/* Allow an assignment to any pointer, reference, or native
destination, regardless of type. This allows C/C++ code
to arbitrarily cast pointers via assignment */
if(type != 0 && ILType_IsComplex(type))
{
if(ILType_Kind(type) == IL_TYPE_COMPLEX_PTR ||
ILType_Kind(type) == IL_TYPE_COMPLEX_BYREF ||
(ILType_Kind(type) & IL_TYPE_COMPLEX_METHOD) != 0)
{
return 1;
}
}
else if(type == ILType_Int || type == ILType_UInt)
{
return 1;
}
return 0;
}
else
{
/* Invalid type: never assignment-compatible with anything */
return 0;
}
}
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;
}
