MonoMethod *CScriptClass::GetMonoMethod(const char *methodName, int numParams)
{
MonoMethodSignature *pSignature = nullptr;
void *pIterator = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
MonoType *pClassType = mono_class_get_type(pClass);
MonoMethod *pCurMethod = nullptr;
while (pClass != nullptr)
{
pCurMethod = mono_class_get_methods(pClass, &pIterator);
if(pCurMethod == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
pSignature = mono_method_signature(pCurMethod);
int signatureParamCount = mono_signature_get_param_count(pSignature);
bool bCorrectName = !strcmp(mono_method_get_name(pCurMethod), methodName);
if(bCorrectName && signatureParamCount == numParams)
return pCurMethod;
}
return nullptr;
}
bool CScriptClass::ImplementsInterface(const char *interfaceName, const char *nameSpace, bool bSearchDerivedClasses)
{
void *pIterator = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
while (pClass != nullptr)
{
MonoClass *pCurInterface = mono_class_get_interfaces(pClass, &pIterator);
if(pCurInterface == nullptr)
{
if(!bSearchDerivedClasses)
return false;
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
if(!strcmp(mono_class_get_name(pCurInterface), interfaceName)
&& (nameSpace == nullptr || !strcmp(mono_class_get_namespace(pCurInterface), nameSpace)))
return true;
}
return false;
}
MonoClassField *CScriptClass::GetMonoField(const char *name)
{
MonoClass *pClass = (MonoClass *)m_pObject;
MonoClassField *pCurField = nullptr;
void *pIterator = 0;
while (pClass != nullptr)
{
pCurField = mono_class_get_fields(pClass, &pIterator);
if(pCurField == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
if(!strcmp(mono_field_get_name(pCurField), name))
return pCurField;
}
return nullptr;
}
void CPipeServer::GetParentClass(void)
{
void *klass = (void *)ReadQword();
UINT_PTR parent = (UINT_PTR)mono_class_get_parent(klass);
WriteQword(parent);
}
IMonoClass *CScriptClass::GetParent()
{
MonoClass *pMonoClassParent = mono_class_get_parent((MonoClass *)m_pObject);
if(pMonoClassParent == nullptr)
return nullptr;
return m_pDeclaringAssembly->TryGetClass(pMonoClassParent);
}
MonoObject* ml_get_info_prop(MonoObject *obj)
{
MonoClass *klass;
MonoProperty *prop;
klass = mono_class_get_parent(mono_object_get_class(obj));
prop = mono_class_get_property_from_name(klass, "Info");
return mono_property_get_value(prop, obj, NULL, NULL);
}
GDMonoClass *GDMonoClass::get_parent_class() {
if (assembly) {
MonoClass *parent_mono_class = mono_class_get_parent(mono_class);
if (parent_mono_class) {
return GDMono::get_singleton()->get_class(parent_mono_class);
}
}
return NULL;
}
IMonoMethod *CScriptClass::GetMethod(const char *name, int numParams, bool throwOnFail)
{
MonoMethodSignature *pSignature = nullptr;
void *pIterator = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
MonoType *pClassType = mono_class_get_type(pClass);
MonoMethod *pCurMethod = nullptr;
while (pClass != nullptr)
{
pCurMethod = mono_class_get_methods(pClass, &pIterator);
if(pCurMethod == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
pSignature = mono_method_signature(pCurMethod);
int signatureParamCount = mono_signature_get_param_count(pSignature);
bool bCorrectName = !strcmp(mono_method_get_name(pCurMethod), name);
if(bCorrectName && signatureParamCount == numParams)
return new CScriptMethod(pCurMethod);
}
if(throwOnFail)
{
if(!GetMonoScriptSystem()->IsInitialized())
{
CryLogAlways("Failed to locate method %s in class %s", name, GetName());
}
else if(IMonoAssembly *pCorlibAssembly = GetMonoScriptSystem()->GetCorlibAssembly())
{
if(IMonoException *pException = GetMonoScriptSystem()->GetCorlibAssembly()->GetException("System", "MissingMethodException", "Failed to locate method %s in class %s", name, GetName()))
pException->Throw();
}
}
return nullptr;
}
bool CScriptClass::ImplementsClass(const char *className, const char *nameSpace)
{
MonoClass *pClass = (MonoClass *)m_pObject;
while (pClass != nullptr)
{
if(!strcmp(mono_class_get_name(pClass), className)
&& (nameSpace == nullptr || !strcmp(mono_class_get_namespace(pClass), nameSpace)))
return true;
else
CryLogAlways("%s did not match pattern %s", mono_class_get_name(pClass), className);
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
}
return false;
}
MonoClass* ml_find_plugin_class(MonoImage *image)
{
MonoClass *klass, *pklass = NULL;
int i, total;
total = mono_image_get_table_rows (image, MONO_TABLE_TYPEDEF);
for (i = 1; i <= total; ++i) {
klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | i);
pklass = mono_class_get_parent(klass);
if (pklass) {
if (strcmp("Plugin", mono_class_get_name(pklass)) == 0)
return klass;
}
}
return NULL;
}
int CScriptClass::GetMethods(const char *name, int numParams, IMonoMethod ***pMethodsOut, int maxMethods, bool throwOnFail)
{
MonoMethodSignature *pSignature = nullptr;
void *pIterator = 0;
int i = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
MonoType *pClassType = mono_class_get_type(pClass);
MonoMethod *pCurMethod = nullptr;
while (pClass != nullptr)
{
pCurMethod = mono_class_get_methods(pClass, &pIterator);
if(pCurMethod == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
pSignature = mono_method_signature(pCurMethod);
int signatureParamCount = mono_signature_get_param_count(pSignature);
bool bCorrectName = !strcmp(mono_method_get_name(pCurMethod), name);
if(bCorrectName && signatureParamCount == numParams)
{
*pMethodsOut[i] = new CScriptMethod(pCurMethod);
i++;
if(i == maxMethods)
return i + 1;
}
}
return i + 1;
}
void
virt_mono_throw_unhandled_exception (MonoObject *exc)
{
caddr_t err;
char *message = (char *) "";
const char *name = (const char *) "";
MonoString *str;
MonoMethod *method;
MonoClass *klass;
gboolean free_message = FALSE;
gint i;
if (mono_object_isinst (exc, mono_get_exception_class ()))
{
klass = mono_object_get_class (exc);
method = NULL;
while (klass && method == NULL)
{
gpointer m_iter = NULL;
for (method = mono_class_get_methods (klass, &m_iter); method != NULL;
method = mono_class_get_methods (klass, &m_iter))
{
MonoMethodSignature *sig = mono_method_signature (method);
guint32 flags = 0;
const char *name = mono_method_get_name (method);
mono_method_get_flags (method, &flags);
if (!strcmp ("ToString", name) &&
sig->param_count == 0
#ifdef OLD_KIT_1_1_5
&& (flags & METHOD_ATTRIBUTE_VIRTUAL)
&& (flags & METHOD_ATTRIBUTE_PUBLIC)
#endif
)
{
break;
}
method = NULL;
}
if (method == NULL)
klass = mono_class_get_parent (klass);
}
g_assert (method);
str = (MonoString *) mono_runtime_invoke (method, exc, NULL, NULL);
if (str) {
message = mono_string_to_utf8 (str);
free_message = TRUE;
name = mono_class_get_name (klass);
}
}
/*
* g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,
* exc->vtable->klass->name, message);
*/
g_printerr ("\nUnhandled Exception: %s\n", message);
err = srv_make_new_error ("42000", "MN001", "Unhandled Mono Exception [%.200s]: %.200s",
name, message);
if (free_message)
g_free (message);
sqlr_resignal (err);
}
IMonoMethod *CScriptClass::GetMethod(const char *name, IMonoArray *pArgs, bool throwOnFail)
{
MonoMethodSignature *pSignature = nullptr;
void *pIterator = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
MonoType *pClassType = mono_class_get_type(pClass);
MonoMethod *pCurMethod = nullptr;
int suppliedArgsCount = pArgs ? pArgs->GetSize() : 0;
while (pClass != nullptr)
{
pCurMethod = mono_class_get_methods(pClass, &pIterator);
if(pCurMethod == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
pSignature = mono_method_signature(pCurMethod);
int signatureParamCount = mono_signature_get_param_count(pSignature);
bool bCorrectName = !strcmp(mono_method_get_name(pCurMethod), name);
if(bCorrectName && signatureParamCount == 0 && suppliedArgsCount == 0)
return new CScriptMethod(pCurMethod);
else if(bCorrectName && signatureParamCount >= suppliedArgsCount && suppliedArgsCount != 0)
{
//if(bStatic != (mono_method_get_flags(pCurMethod, nullptr) & METHOD_ATTRIBUTE_STATIC) > 0)
//continue;
void *pIter = nullptr;
MonoType *pType = nullptr;
for(int i = 0; i < signatureParamCount; i++)
{
pType = mono_signature_get_params(pSignature, &pIter);
if(mono::object item = pArgs->GetItem(i))
{
MonoClass *pItemClass = mono_object_get_class((MonoObject *)item);
MonoType *pItemType = mono_class_get_type(pItemClass);
MonoTypeEnum itemMonoType = (MonoTypeEnum)mono_type_get_type(pItemType);
MonoTypeEnum monoType = (MonoTypeEnum)mono_type_get_type(pType);
if(itemMonoType != monoType)
{
// exceptions:
// Anything can be treated as object.
if(monoType == MONO_TYPE_OBJECT) {}
// The runtime confuses things with value types a lot, so ignore parameters that appear with that type.
else if(itemMonoType == MONO_TYPE_VALUETYPE || monoType == MONO_TYPE_VALUETYPE) {}
else
{
if(MonoClass *pMethodParameterClass = mono_type_get_class(pType))
{
MonoWarning("Parameter mismatch when searching for method %s in class %s.%s, on parameter %i: Provided type %s.%s does not match expected parameter type %s.%s.",
name, mono_class_get_namespace(pClass), mono_class_get_name(pClass), i + 1, mono_class_get_namespace(pItemClass), mono_class_get_name(pItemClass), mono_class_get_namespace(pMethodParameterClass), mono_class_get_name(pMethodParameterClass));
}
else
{
MonoWarning("Parameter mismatch when searching for method %s in class %s.%s, on parameter %i: Provided type %s.%s does not match parameter type.",
name, mono_class_get_namespace(pClass), mono_class_get_name(pClass), i + 1, mono_class_get_namespace(pItemClass), mono_class_get_name(pItemClass));
}
break;
}
}
}
if(i + 1 == suppliedArgsCount)
return new CScriptMethod(pCurMethod);
}
}
}
if(throwOnFail)
{
if(IMonoException *pException = GetMonoScriptSystem()->GetCorlibAssembly()->GetException("System", "MissingMethodException", "Failed to locate method %s in class %s", name, GetName()))
pException->Throw();
}
return nullptr;
}
mioClass mioClass::getParent() const
{
return mono_class_get_parent(mclass);
}
MonoProperty *CScriptClass::GetMonoProperty(const char *name, bool requireSetter, bool requireGetter)
{
MonoClass *pClass = (MonoClass *)m_pObject;
MonoProperty *pCurProperty = nullptr;
void *pIterator = 0;
while (pClass != nullptr)
{
pCurProperty = mono_class_get_properties(pClass, &pIterator);
if(pCurProperty == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
if(!strcmp(mono_property_get_name(pCurProperty), name))
{
if(requireSetter && mono_property_get_set_method(pCurProperty) == nullptr)
continue;
if(requireGetter && mono_property_get_get_method(pCurProperty) == nullptr)
continue;
return pCurProperty;
}
}
return nullptr;
}
