-/*
- * icall.c:
+/**
+ * \file
*
* Authors:
* Dietmar Maurer (dietmar@ximian.com)
static void
mono_class_init_checked (MonoClass *klass, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!mono_class_init (klass))
mono_error_set_for_class_failure (error, klass);
gint64 i64 = 0;
gdouble r64 = 0;
- mono_error_init (&error);
+ error_init (&error);
if (value)
vc = value->vtable->klass;
if (mono_error_set_pending_exception (&error))
return NULL;
+ if (klass->element_class->byval_arg.type == MONO_TYPE_VOID) {
+ mono_set_pending_exception (mono_get_exception_not_supported ("Arrays of System.Void are not supported."));
+ return NULL;
+ }
+
if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0))
/* vectors are not the same as one dimensional arrays with no-zero bounds */
bounded = TRUE;
mono_gc_bzero_atomic (mono_array_addr_with_size_fast (arr, sz, idx), length * sz);
}
-ICALL_EXPORT MonoArray*
-ves_icall_System_Array_Clone (MonoArray *arr)
-{
- MonoError error;
- MonoArray *result = mono_array_clone_checked (arr, &error);
- mono_error_set_pending_exception (&error);
- return result;
-}
ICALL_EXPORT gboolean
ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArrayHandle array, MonoClassField *field_handle, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_handle_class (array);
guint32 size = mono_array_element_size (klass);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_System_Object_GetType (MonoObjectHandle obj, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (obj);
MonoClass *klass = mono_handle_class (obj);
#ifndef DISABLE_REMOTING
gboolean type_resolve = FALSE;
MonoImage *rootimage = NULL;
- mono_error_init (error);
+ error_init (error);
/*
* We must compute the calling assembly as type loading must happen under a metadata context.
MonoBoolean ignoreCase,
MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoTypeNameParse info;
gboolean parsedOk;
MonoAssembly *caller_assembly;
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_System_Type_internal_from_handle (MonoType *handle, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
return mono_type_get_object_handle (domain, handle, error);
ICALL_EXPORT guint32
ves_icall_type_GetTypeCodeInternal (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
int t = type->type;
ICALL_EXPORT guint32
ves_icall_RuntimeTypeHandle_type_is_assignable_from (MonoReflectionTypeHandle ref_type, MonoReflectionTypeHandle ref_c, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
g_assert (!MONO_HANDLE_IS_NULL (ref_type));
ICALL_EXPORT guint32
ves_icall_RuntimeTypeHandle_IsInstanceOfType (MonoReflectionTypeHandle ref_type, MonoObjectHandle obj, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
mono_class_init_checked (klass, error);
ICALL_EXPORT guint32
ves_icall_RuntimeTypeHandle_GetAttributes (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
return mono_class_get_flags (klass);
ICALL_EXPORT MonoReflectionMarshalAsAttributeHandle
ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionFieldHandle field_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (field_h);
MonoClassField *field = MONO_HANDLE_GETVAL (field_h, field);
MonoClass *klass = field->parent;
g_assert (handle);
- mono_error_init (error);
+ error_init (error);
if (!type) {
klass = handle->parent;
g_assert (handle);
- mono_error_init (error);
+ error_init (error);
if (!type) {
klass = handle->parent;
ICALL_EXPORT MonoReflectionPropertyHandle
ves_icall_System_Reflection_PropertyInfo_internal_from_handle_type (MonoProperty *handle, MonoType *type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass;
g_assert (handle);
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionFieldHandle field_h, MonoBoolean optional, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClassField *field = MONO_HANDLE_GETVAL (field_h, field);
MonoType *type = mono_field_get_type_checked (field, error);
}
ICALL_EXPORT void
-ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
+ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info, MonoError *error)
{
- MonoError error;
- MonoReflectionType *rt;
MonoDomain *domain = mono_domain_get ();
- MonoMethodSignature* sig;
- sig = mono_method_signature_checked (method, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return;
- }
+ MonoMethodSignature* sig = mono_method_signature_checked (method, error);
+ return_if_nok (error);
- rt = mono_type_get_object_checked (domain, &method->klass->byval_arg, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return;
- }
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &method->klass->byval_arg, error);
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, parent, rt);
+ MONO_STRUCT_SETREF (info, parent, MONO_HANDLE_RAW (rt));
- rt = mono_type_get_object_checked (domain, sig->ret, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return;
- }
+ MONO_HANDLE_ASSIGN (rt, mono_type_get_object_handle (domain, sig->ret, error));
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, ret, rt);
+ MONO_STRUCT_SETREF (info, ret, MONO_HANDLE_RAW (rt));
info->attrs = method->flags;
info->implattrs = method->iflags;
+ guint32 callconv;
if (sig->call_convention == MONO_CALL_DEFAULT)
- info->callconv = sig->sentinelpos >= 0 ? 2 : 1;
+ callconv = sig->sentinelpos >= 0 ? 2 : 1;
else {
if (sig->call_convention == MONO_CALL_VARARG || sig->sentinelpos >= 0)
- info->callconv = 2;
+ callconv = 2;
else
- info->callconv = 1;
+ callconv = 1;
}
- info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
+ callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
+ info->callconv = callconv;
}
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_MonoMethodInfo_get_parameter_info (MonoMethod *method, MonoReflectionMethodHandle member, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoReflectionTypeHandle reftype = MONO_HANDLE_NEW (MonoReflectionType, NULL);
ICALL_EXPORT MonoReflectionMarshalAsAttributeHandle
ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoReflectionMarshalAsAttributeHandle res = MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, NULL);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_MonoField_GetParentType (MonoReflectionFieldHandle field, MonoBoolean declaring, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (field);
MonoClass *parent;
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_MonoField_ResolveType (MonoReflectionFieldHandle ref_field, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_field);
MonoClassField *field = MONO_HANDLE_GETVAL (ref_field, field);
MonoType *type = mono_field_get_type_checked (field, error);
} PInfo;
ICALL_EXPORT void
-ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
+ves_icall_MonoPropertyInfo_get_property_info (MonoReflectionPropertyHandle property, MonoPropertyInfo *info, PInfo req_info, MonoError *error)
{
- MonoError error;
- MonoReflectionType *rt;
- MonoReflectionMethod *rm;
- MonoDomain *domain = mono_object_domain (property);
- const MonoProperty *pproperty = property->property;
+ error_init (error);
+ MonoDomain *domain = MONO_HANDLE_DOMAIN (property);
+ const MonoProperty *pproperty = MONO_HANDLE_GETVAL (property, property);
if ((req_info & PInfo_ReflectedType) != 0) {
- rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ MonoClass *klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &klass->byval_arg, error);
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, parent, rt);
+ MONO_STRUCT_SETREF (info, parent, MONO_HANDLE_RAW (rt));
}
if ((req_info & PInfo_DeclaringType) != 0) {
- rt = mono_type_get_object_checked (domain, &pproperty->parent->byval_arg, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &pproperty->parent->byval_arg, error);
+ return_if_nok (error);
- MONO_STRUCT_SETREF (info, declaring_type, rt);
+ MONO_STRUCT_SETREF (info, declaring_type, MONO_HANDLE_RAW (rt));
}
- if ((req_info & PInfo_Name) != 0)
- MONO_STRUCT_SETREF (info, name, mono_string_new (domain, pproperty->name));
+ if ((req_info & PInfo_Name) != 0) {
+ MonoStringHandle name = mono_string_new_handle (domain, pproperty->name, error);
+ return_if_nok (error);
+
+ MONO_STRUCT_SETREF (info, name, MONO_HANDLE_RAW (name));
+ }
if ((req_info & PInfo_Attributes) != 0)
info->attrs = pproperty->attrs;
if ((req_info & PInfo_GetMethod) != 0) {
+ MonoClass *property_klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoReflectionMethodHandle rm;
if (pproperty->get &&
(((pproperty->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
- pproperty->get->klass == property->klass)) {
- rm = mono_method_get_object_checked (domain, pproperty->get, property->klass, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ pproperty->get->klass == property_klass)) {
+ rm = mono_method_get_object_handle (domain, pproperty->get, property_klass, error);
+ return_if_nok (error);
} else {
- rm = NULL;
+ rm = MONO_HANDLE_NEW (MonoReflectionMethod, NULL);
}
- MONO_STRUCT_SETREF (info, get, rm);
+ MONO_STRUCT_SETREF (info, get, MONO_HANDLE_RAW (rm));
}
if ((req_info & PInfo_SetMethod) != 0) {
+ MonoClass *property_klass = MONO_HANDLE_GETVAL (property, klass);
+ MonoReflectionMethodHandle rm;
if (pproperty->set &&
(((pproperty->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
- pproperty->set->klass == property->klass)) {
- rm = mono_method_get_object_checked (domain, pproperty->set, property->klass, &error);
- if (mono_error_set_pending_exception (&error))
- return;
+ pproperty->set->klass == property_klass)) {
+ rm = mono_method_get_object_handle (domain, pproperty->set, property_klass, error);
+ return_if_nok (error);
} else {
- rm = NULL;
+ rm = MONO_HANDLE_NEW (MonoReflectionMethod, NULL);
}
- MONO_STRUCT_SETREF (info, set, rm);
+ MONO_STRUCT_SETREF (info, set, MONO_HANDLE_RAW (rm));
}
/*
* There may be other methods defined for properties, though, it seems they are not exposed
ICALL_EXPORT MonoArrayHandle
ves_icall_RuntimeType_GetInterfaces (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
set_interface_map_data_method_object (MonoDomain *domain, MonoMethod *method, MonoClass *iclass, int ioffset, MonoClass *klass, MonoArrayHandle targets, MonoArrayHandle methods, int i, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoReflectionMethodHandle member = mono_method_get_object_handle (domain, method, iclass, error);
if (!is_ok (error))
goto leave;
ICALL_EXPORT void
ves_icall_RuntimeType_GetInterfaceMapData (MonoReflectionTypeHandle ref_type, MonoReflectionTypeHandle ref_iface, MonoArrayHandleOut targets, MonoArrayHandleOut methods, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
MonoType *iface = MONO_HANDLE_GETVAL (ref_iface, type);
ICALL_EXPORT void
ves_icall_RuntimeType_GetPacking (MonoReflectionTypeHandle ref_type, guint32 *packing, guint32 *size, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsPointer (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return type->type == MONO_TYPE_PTR;
}
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsPrimitive (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return (!type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U)));
}
+ICALL_EXPORT MonoBoolean
+ves_icall_RuntimeTypeHandle_HasReferences (MonoReflectionTypeHandle ref_type, MonoError *error)
+{
+ error_init (error);
+ MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
+ MonoClass *klass;
+
+ klass = mono_class_from_mono_type (type);
+ mono_class_init (klass);
+ return klass->has_references;
+}
+
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsByRef (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return type->byref;
}
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
mono_class_init_checked (klass, error);
ICALL_EXPORT guint32
ves_icall_reflection_get_token (MonoObjectHandle obj, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return mono_reflection_get_token_checked (obj, error);
}
ICALL_EXPORT MonoReflectionModuleHandle
ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionTypeHandle type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (type);
MonoType *t = MONO_HANDLE_GETVAL (type, type);
MonoClass *klass = mono_class_from_mono_type (t);
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionTypeHandle type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoType *t = MONO_HANDLE_GETVAL (type, type);
MonoClass *klass = mono_class_from_mono_type (t);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_get_DeclaringType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get ();
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass;
ICALL_EXPORT gint32
ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->type != MONO_TYPE_ARRAY && type->type != MONO_TYPE_SZARRAY) {
set_type_object_in_array (MonoDomain *domain, MonoType *type, MonoArrayHandle dest, int i, MonoError *error)
{
HANDLE_FUNCTION_ENTER();
- mono_error_init (error);
+ error_init (error);
MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, type, error);
if (!is_ok (error))
goto leave;
ICALL_EXPORT MonoArrayHandle
ves_icall_RuntimeType_GetGenericArguments (MonoReflectionTypeHandle ref_type, MonoBoolean runtimeTypeArray, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT gboolean
ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!IS_MONOTYPE (MONO_HANDLE_RAW(ref_type)))
return FALSE;
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoReflectionTypeHandle ret = MONO_HANDLE_NEW (MonoReflectionType, NULL);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_MakeGenericType (MonoReflectionTypeHandle reftype, MonoArrayHandle type_array, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (reftype);
g_assert (IS_MONOTYPE_HANDLE (reftype));
ICALL_EXPORT gboolean
ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass;
if (!IS_MONOTYPE (MONO_HANDLE_RAW (ref_type)))
ICALL_EXPORT gint32
ves_icall_RuntimeType_GetGenericParameterPosition (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
if (!IS_MONOTYPE_HANDLE (ref_type))
return -1;
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT MonoGenericParamInfo *
ves_icall_RuntimeTypeHandle_GetGenericParameterInfo (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
return mono_generic_param_info (type->data.generic_param);
}
MonoReflectionMethodHandle generic,
MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_RuntimeType_get_DeclaringMethod (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoReflectionMethodHandle ret = MONO_HANDLE_NEW (MonoReflectionMethod, NULL);
ICALL_EXPORT MonoBoolean
ves_icall_System_RuntimeType_IsTypeExportedToWindowsRuntime (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
mono_error_set_not_implemented (error, "%s", "");
return FALSE;
}
ICALL_EXPORT MonoBoolean
ves_icall_System_RuntimeType_IsWindowsRuntimeObjectType (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
mono_error_set_not_implemented (error, "%s", "");
return FALSE;
}
const char *import = NULL;
const char *scope = NULL;
- mono_error_init (error);
+ error_init (error);
if (image_is_dynamic (image)) {
MonoReflectionMethodAux *method_aux =
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethodHandle ref_method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
if (method->is_generic)
set_array_generic_argument_handle_inflated (MonoDomain *domain, MonoGenericInst *inst, int i, MonoArrayHandle arr, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, inst->type_argv [i], error);
if (!is_ok (error))
goto leave;
set_array_generic_argument_handle_gparam (MonoDomain *domain, MonoGenericContainer *container, int i, MonoArrayHandle arr, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoGenericParam *param = mono_generic_container_get_param (container, i);
MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &pklass->byval_arg, error);
ICALL_EXPORT MonoArrayHandle
ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethodHandle ref_method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_method);
MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
static void
get_enum_field (MonoDomain *domain, MonoArrayHandle names, MonoArrayHandle values, int base_type, MonoClassField *field, guint* j, guint64 *previous_value, gboolean *sorted, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
HANDLE_FUNCTION_ENTER();
guint64 field_value;
const char *p;
guint64 previous_value = 0;
gboolean sorted = TRUE;
- mono_error_init (error);
+ error_init (error);
mono_class_init_checked (enumc, error);
return_val_if_nok (error, FALSE);
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetFields_native (MonoReflectionTypeHandle ref_type, char *utf8_name, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
array = g_ptr_array_new ();
startklass = klass;
- mono_error_init (error);
+ error_init (error);
if (name != NULL)
compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetMethodsByName_native (MonoReflectionTypeHandle ref_type, const char *mname, guint32 bflags, MonoBoolean ignore_case, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetConstructors_native (MonoReflectionTypeHandle ref_type, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
return g_ptr_array_new ();
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetPropertiesByName_native (MonoReflectionTypeHandle ref_type, gchar *propname, guint32 bflags, MonoBoolean ignore_case, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
ICALL_EXPORT GPtrArray*
ves_icall_RuntimeType_GetEvents_native (MonoReflectionTypeHandle ref_type, char *utf8_name, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
ICALL_EXPORT GPtrArray *
ves_icall_RuntimeType_GetNestedTypes_native (MonoReflectionTypeHandle ref_type, char *str, guint32 bflags, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
if (type->byref) {
get_type_from_module_builder_module (MonoArrayHandle modules, int i, MonoTypeNameParse *info, MonoBoolean ignoreCase, gboolean *type_resolve, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *type = NULL;
MonoReflectionModuleBuilderHandle mb = MONO_HANDLE_NEW (MonoReflectionModuleBuilder, NULL);
MONO_HANDLE_ARRAY_GETREF (mb, modules, i);
get_type_from_module_builder_loaded_modules (MonoArrayHandle loaded_modules, int i, MonoTypeNameParse *info, MonoBoolean ignoreCase, gboolean *type_resolve, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *type = NULL;
MonoReflectionModuleHandle mod = MONO_HANDLE_NEW (MonoReflectionModule, NULL);
MONO_HANDLE_ARRAY_GETREF (mod, loaded_modules, i);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssemblyHandle assembly_h, MonoReflectionModuleHandle module, MonoStringHandle name, MonoBoolean throwOnError, MonoBoolean ignoreCase, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoTypeNameParse info;
gboolean type_resolve;
ICALL_EXPORT MonoStringHandle
ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssemblyHandle assembly, MonoBoolean escaped, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *mass = MONO_HANDLE_GETVAL (assembly, assembly);
gchar *absolute;
ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssembly *mass = MONO_HANDLE_GETVAL (assembly,assembly);
return mass->in_gac;
ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
return assembly->ref_only;
}
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoMethod *method;
ICALL_EXPORT MonoReflectionModuleHandle
ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *a = MONO_HANDLE_GETVAL (assembly, assembly);
return mono_module_get_object_handle (domain, a->image, error);
add_manifest_resource_name_to_array (MonoDomain *domain, MonoImage *image, MonoTableInfo *table, int i, MonoArrayHandle dest, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
const char *val = mono_metadata_string_heap (image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
MonoStringHandle str = mono_string_new_handle (domain, val, error);
if (!is_ok (error))
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
static MonoAssemblyName*
create_referenced_assembly_name (MonoDomain *domain, MonoImage *image, MonoTableInfo *t, int i, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssemblyName *aname = g_new0 (MonoAssemblyName, 1);
mono_assembly_get_assemblyref (image, i, aname);
ICALL_EXPORT GPtrArray*
ves_icall_System_Reflection_Assembly_InternalGetReferencedAssemblies (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *ass = MONO_HANDLE_GETVAL(assembly, assembly);
MonoImage *image = ass->image;
ICALL_EXPORT void *
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, gint32 *size, MonoReflectionModuleHandleOut ref_module, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
ICALL_EXPORT gboolean
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, MonoManifestResourceInfoHandle info_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return get_manifest_resource_info_internal (assembly_h, name, info_h, error);
}
add_filename_to_files_array (MonoDomain *domain, MonoAssembly * assembly, MonoTableInfo *table, int i, MonoArrayHandle dest, int dest_idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER();
- mono_error_init (error);
+ error_init (error);
const char *val = mono_metadata_string_heap (assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
char *n = g_concat_dir_and_file (assembly->basedir, val);
MonoStringHandle str = mono_string_new_handle (domain, n, error);
ICALL_EXPORT MonoObjectHandle
ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssemblyHandle assembly_h, MonoStringHandle name, MonoBoolean resource_modules, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly_h);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoTableInfo *table = &assembly->image->tables [MONO_TABLE_FILE];
add_module_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int *dest_idx, MonoImage* module, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
if (module) {
MonoReflectionModuleHandle rm = mono_module_get_object_handle (domain, module, error);
if (!is_ok (error))
add_file_to_modules_array (MonoDomain *domain, MonoArrayHandle dest, int dest_idx, MonoImage *image, MonoTableInfo *table, int table_idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
guint32 cols [MONO_FILE_SIZE];
mono_metadata_decode_row (table, table_idx, cols, MONO_FILE_SIZE);
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssemblyHandle assembly_h, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = mono_domain_get();
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoClass *klass;
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_GetCurrentMethod (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *m = mono_method_get_last_managed ();
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native (MonoMethod *method, MonoType *type, MonoBoolean generic_check, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoClass *klass;
if (type && generic_check) {
klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionMethodBodyHandle
ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
return mono_method_body_get_object_handle (mono_domain_get (), method, error);
}
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_GetEntryAssembly (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain* domain = mono_domain_get ();
ICALL_EXPORT MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_GetCallingAssembly (MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *m;
MonoMethod *dest;
ICALL_EXPORT int
vell_icall_RuntimeType_get_core_clr_security_level (MonoReflectionTypeHandle rfield, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (rfield, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT int
ves_icall_MonoMethod_get_core_clr_security_level (MonoReflectionMethodHandle rfield, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *method = MONO_HANDLE_GETVAL (rfield, method);
return mono_security_core_clr_method_level (method, TRUE);
}
ICALL_EXPORT MonoStringHandle
ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssemblyHandle assembly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (assembly);
MonoAssembly *mass = MONO_HANDLE_GETVAL (assembly, assembly);
gchar *name;
MonoImage *image;
char *dirname;
- mono_error_init (error);
+ error_init (error);
filename = mono_string_handle_to_utf8 (fname, error);
return_if_nok (error);
ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssemblyHandle assembly_h,
char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoAssembly *assembly = MONO_HANDLE_GETVAL (assembly_h, assembly);
MonoBoolean result = FALSE;
MonoDeclSecurityEntry entry;
static void
image_get_type (MonoDomain *domain, MonoImage *image, MonoTableInfo *tdef, int table_idx, int count, MonoArrayHandle res, MonoArrayHandle exceptions, MonoBoolean exportedOnly, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
HANDLE_FUNCTION_ENTER ();
MonoError klass_error;
MonoClass *klass = mono_class_get_checked (image, table_idx | MONO_TOKEN_TYPE_DEF, &klass_error);
MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
int i, count;
- mono_error_init (error);
+ error_init (error);
/* we start the count from 1 because we skip the special type <Module> */
if (exportedOnly) {
append_module_types (MonoDomain *domain, MonoArrayHandleOut res, MonoArrayHandleOut exceptions, MonoImage *image, MonoBoolean exportedOnly, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoArrayHandle ex2 = MONO_HANDLE_NEW (MonoArray, NULL);
MonoArrayHandle res2 = mono_module_get_types (domain, image, ex2, exportedOnly, error);
if (!is_ok (error))
{
HANDLE_FUNCTION_ENTER ();
MonoError unboxed_error;
- mono_error_init (&unboxed_error);
+ error_init (&unboxed_error);
mono_error_set_for_class_failure (&unboxed_error, klass);
MonoExceptionHandle exc = MONO_HANDLE_NEW (MonoException, mono_error_convert_to_exception (&unboxed_error));
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModuleHandle module, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoImage *image = MONO_HANDLE_GETVAL (module, image);
MonoDomain *domain = MONO_HANDLE_DOMAIN (module);
module_resolve_type_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoType *result = NULL;
MonoClass *klass;
int table = mono_metadata_token_table (token);
module_resolve_method_token (MonoImage *image, guint32 token, MonoArrayHandle type_args, MonoArrayHandle method_args, MonoResolveTokenError *resolve_error, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoMethod *method = NULL;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
MonoGenericContext context;
MonoClassField *field = NULL;
- mono_error_init (error);
+ error_init (error);
*resolve_error = ResolveTokenError_Other;
/* Validate token */
{
int table = mono_metadata_token_table (token);
- mono_error_init (merror);
+ error_init (merror);
*error = ResolveTokenError_Other;
switch (table) {
ICALL_EXPORT MonoArrayHandle
ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
int table = mono_metadata_token_table (token);
int idx = mono_metadata_token_index (token);
MonoTableInfo *tables = image->tables;
ICALL_EXPORT MonoBoolean
ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoBoolean res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY);
{
char *name;
- mono_error_init (error);
+ error_init (error);
if (klass->byval_arg.type != MONO_TYPE_TYPEDBYREF)
return;
name = mono_type_get_full_name (klass);
mono_error_set_type_load_name (error, name, g_strdup (""), "");
}
+
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_make_array_type (MonoReflectionTypeHandle ref_type, int rank, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
else
aklass = mono_bounded_array_class_get (klass, rank, TRUE);
+ if (mono_class_has_failure (aklass)) {
+ mono_error_set_for_class_failure (error, aklass);
+ return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE);
+ }
+
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
return mono_type_get_object_handle (domain, &aklass->byval_arg, error);
}
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_make_byref_type (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionTypeHandle
ves_icall_RuntimeType_MakePointerType (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
{
MonoReflectionMethod *ret = NULL;
MonoError error;
- ret = mono_method_get_object_checked (mono_domain_get (), mono_object_get_virtual_method (delegate->target, delegate->method), mono_object_class (delegate->target), &error);
+ MonoMethod *m;
+
+ m = mono_object_get_virtual_method (delegate->target, delegate->method);
+ ret = mono_method_get_object_checked (mono_domain_get (), m, m->klass, &error);
mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT MonoObjectHandle
ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObjectHandle this_obj, MonoStringHandle class_name, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (this_obj);
MonoRealProxyHandle rp = MONO_HANDLE_CAST (MonoRealProxy, this_obj);
ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
{
MonoError error;
+ g_assert (tp != NULL && mono_object_class (tp) == mono_defaults.transparent_proxy_class);
+ g_assert (tp->remote_class != NULL && tp->remote_class->proxy_class != NULL);
MonoReflectionType *ret = mono_type_get_object_checked (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg, &error);
mono_error_set_pending_exception (&error);
ICALL_EXPORT MonoStringHandle
ves_icall_System_Environment_GetEnvironmentVariable_native (const gchar *utf8_name, MonoError *error)
{
- const gchar *value;
+ gchar *value;
if (utf8_name == NULL)
return NULL_HANDLE_STRING;
if (value == 0)
return NULL_HANDLE_STRING;
- return mono_string_new_handle (mono_domain_get (), value, error);
+ MonoStringHandle res = mono_string_new_handle (mono_domain_get (), value, error);
+ g_free (value);
+ return res;
}
/*
#endif
ICALL_EXPORT MonoArray *
-ves_icall_System_Environment_GetCoomandLineArgs (void)
+ves_icall_System_Environment_GetCommandLineArgs (void)
{
MonoError error;
MonoArray *result = mono_runtime_get_main_args_checked (&error);
/* Suspend all managed threads since the runtime is going away */
mono_thread_suspend_all_other_threads ();
- //FIXME shutdown is, weirdly enough, abortible in gc.c so we add this hack for now, see https://bugzilla.xamarin.com/show_bug.cgi?id=51653
- mono_threads_begin_abort_protected_block ();
- mono_thread_info_clear_self_interrupt ();
-
mono_runtime_quit ();
#endif
ICALL_EXPORT gboolean
ves_icall_get_resources_ptr (MonoReflectionAssemblyHandle assembly, gpointer *result, gint32 *size, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoPEResourceDataEntry *entry;
MonoImage *image;
ICALL_EXPORT MonoObjectHandle
ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionTypeHandle ref_type, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type);
MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
MonoClass *klass = mono_class_from_mono_type (type);
ICALL_EXPORT MonoReflectionMethodHandle
ves_icall_MonoMethod_get_base_method (MonoReflectionMethodHandle m, gboolean definition, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *method = MONO_HANDLE_GETVAL (m, method);
MonoMethod *base = mono_method_get_base_method (method, definition, error);
return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE));
- if (base == method)
- return m;
- else
- return mono_method_get_object_handle (mono_domain_get (), base, NULL, error);
+ if (base == method) {
+ /* we want to short-circuit and return 'm' here. But we should
+ return the same method object that
+ mono_method_get_object_handle, below would return. Since
+ that call takes NULL for the reftype argument, it will take
+ base->klass as the reflected type for the MonoMethod. So we
+ need to check that m also has base->klass as the reflected
+ type. */
+ MonoReflectionTypeHandle orig_reftype = MONO_HANDLE_NEW_GET (MonoReflectionType, m, reftype);
+ MonoClass *orig_klass = mono_class_from_mono_type (MONO_HANDLE_GETVAL (orig_reftype, type));
+ if (base->klass == orig_klass)
+ return m;
+ }
+ return mono_method_get_object_handle (mono_domain_get (), base, NULL, error);
}
ICALL_EXPORT MonoStringHandle
ves_icall_MonoMethod_get_name (MonoReflectionMethodHandle m, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoMethod *method = MONO_HANDLE_GETVAL (m, method);
MonoStringHandle s = mono_string_new_handle (MONO_HANDLE_DOMAIN (m), method->name, error);
{
const char *exc_class, *exc_arg;
- mono_error_init (error);
+ error_init (error);
if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
return;
mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
add_modifier_to_array (MonoDomain *domain, MonoImage *image, MonoCustomMod *modifier, MonoArrayHandle dest, int dest_idx, MonoError *error)
{
HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
+ error_init (error);
MonoClass *klass = mono_class_get_checked (image, modifier->token, error);
if (!is_ok (error))
goto leave;
int i, count = 0;
MonoDomain *domain = mono_domain_get ();
- mono_error_init (error);
+ error_init (error);
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required))
count++;
ICALL_EXPORT MonoArrayHandle
ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameterHandle param, MonoBoolean optional, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoReflectionTypeHandle rt = MONO_HANDLE_NEW (MonoReflectionType, NULL);
MONO_HANDLE_GET (rt, param, ClassImpl);
MonoType *type = MONO_HANDLE_GETVAL (rt, type);
ICALL_EXPORT MonoArrayHandle
ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionPropertyHandle property, MonoBoolean optional, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
MonoProperty *prop = MONO_HANDLE_GETVAL (property, property);
MonoClass *klass = MONO_HANDLE_GETVAL (property, klass);
MonoType *type = get_property_type (prop);
char *info;
MonoStringHandle display_name;
- mono_error_init (error);
+ error_init (error);
info = mono_get_runtime_callbacks ()->get_runtime_build_info ();
display_name = mono_string_new_handle (mono_domain_get (), info, error);
g_free (info);
/**
* mono_add_internal_call:
- * @name: method specification to surface to the managed world
- * @method: pointer to a C method to invoke when the method is called
+ * \param name method specification to surface to the managed world
+ * \param method pointer to a C method to invoke when the method is called
*
- * This method surfaces the C function pointed by @method as a method
+ * This method surfaces the C function pointed by \p method as a method
* that has been surfaced in managed code with the method specified in
- * @name as an internal call.
+ * \p name as an internal call.
*
* Internal calls are surfaced to all app domains loaded and they are
* accessibly by a type with the specified name.
*
* For example, the following are all valid declarations:
*
- * "MyApp.Services.ScriptService:Accelerate"
- * "MyApp.Services.ScriptService:Slowdown(int,bool)"
+ * \c MyApp.Services.ScriptService:Accelerate
+ *
+ * \c MyApp.Services.ScriptService:Slowdown(int,bool)
*
* You use method parameters in cases where there might be more than
* one surface method to managed code. That way you can register different
* internal calls for different method overloads.
*
* The internal calls are invoked with no marshalling. This means that .NET
- * types like System.String are exposed as `MonoString *` parameters. This is
+ * types like \c System.String are exposed as \c MonoString* parameters. This is
* different than the way that strings are surfaced in P/Invoke.
*
* For more information on how the parameters are marshalled, see the
/**
* mono_lookup_internal_call_full:
- * @method: the method to look up
- * @uses_handles: out argument if method needs handles around managed objects.
- *
- * Returns a pointer to the icall code for the given method. If
- * uses_handles is not NULL, it will be set to TRUE if the method
+ * \param method the method to look up
+ * \param uses_handles out argument if method needs handles around managed objects.
+ * \returns a pointer to the icall code for the given method. If
+ * \p uses_handles is not NULL, it will be set to TRUE if the method
* needs managed objects wrapped using the infrastructure in handle.h
*
* If the method is not found, warns and returns NULL.
#endif
}
+/**
+ * mono_lookup_internal_call:
+ */
gpointer
mono_lookup_internal_call (MonoMethod *method)
{
res = mono_metadata_signature_alloc (corlib, len - 1);
res->pinvoke = 1;
-#ifdef HOST_WIN32
+#ifdef TARGET_WIN32
/*
* Under windows, the default pinvoke calling convention is STDCALL but
* we need CDECL.