ICALL_EXPORT MonoArray *
ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
+ MonoError error;
MonoClass *aklass, *klass;
MonoArray *array;
uintptr_t *sizes, i;
sizes [i + aklass->rank] = 0;
}
- array = mono_array_new_full (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank);
+ array = mono_array_new_full_checked (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank, &error);
+ mono_error_set_pending_exception (&error);
return array;
}
ICALL_EXPORT MonoArray *
ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
+ MonoError error;
MonoClass *aklass, *klass;
MonoArray *array;
uintptr_t *sizes, i;
sizes [i + aklass->rank] = 0;
}
- array = mono_array_new_full (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank);
+ array = mono_array_new_full_checked (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank, &error);
+ mono_error_set_pending_exception (&error);
return array;
}
}
#if G_BYTE_ORDER != G_LITTLE_ENDIAN
-#define SWAP(n) {\
- guint ## n *data = (guint ## n *) mono_array_addr (array, char, 0); \
- guint ## n *src = (guint ## n *) field_data; \
- guint ## n *end = (guint ## n *)((char*)src + size); \
-\
- for (; src < end; data++, src++) { \
- *data = read ## n (src); \
- } \
+#define SWAP(n) { \
+ guint ## n *data = (guint ## n *) mono_array_addr (array, char, 0); \
+ guint ## n *src = (guint ## n *) field_data; \
+ int i, \
+ nEnt = (size / sizeof(guint ## n)); \
+ \
+ for (i = 0; i < nEnt; i++) { \
+ data[i] = read ## n (&src[i]); \
+ } \
}
/* printf ("Initialize array with elements of %s type\n", klass->element_class->name); */
{
if ((obj == NULL) || (! (obj->vtable->klass->valuetype)))
return obj;
- else
- return mono_object_clone (obj);
+ else {
+ MonoError error;
+ MonoObject *ret = mono_object_clone_checked (obj, &error);
+ mono_error_set_pending_exception (&error);
+
+ return ret;
+ }
}
ICALL_EXPORT void
mono_image_check_for_module_cctor (image);
if (image->has_module_cctor) {
MonoClass *module_klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF | 1, &error);
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
/*It's fine to raise the exception here*/
mono_runtime_class_init (mono_class_vtable_full (mono_domain_get (), module_klass, TRUE));
}
ICALL_EXPORT MonoObject *
ves_icall_System_Object_MemberwiseClone (MonoObject *this_obj)
{
- return mono_object_clone (this_obj);
+ MonoError error;
+ MonoObject *ret = mono_object_clone_checked (this_obj, &error);
+ mono_error_set_pending_exception (&error);
+
+ return ret;
}
ICALL_EXPORT gint32
ICALL_EXPORT MonoReflectionType *
ves_icall_System_Object_GetType (MonoObject *obj)
{
+ MonoError error;
+ MonoReflectionType *ret;
#ifndef DISABLE_REMOTING
if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
- return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg, &error);
else
#endif
- return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (obj), &obj->vtable->klass->byval_arg, &error);
+
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT void
{
MONO_CHECK_ARG_NULL (obj, 0);
- return mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE);
+ MonoError error;
+ gint32 result = mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE, &error);
+ mono_error_raise_exception (&error);
+ return result;
}
ICALL_EXPORT gint32
{
MONO_CHECK_ARG_NULL (method, 0);
- return mono_image_create_method_token (
- mb->dynamic_image, (MonoObject *) method, opt_param_types);
+ MonoError error;
+ gint32 result = mono_image_create_method_token (
+ mb->dynamic_image, (MonoObject *) method, opt_param_types, &error);
+ mono_error_raise_exception (&error);
+ return result;
}
ICALL_EXPORT void
ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
{
- mono_image_create_pefile (mb, file);
+ MonoError error;
+ mono_image_create_pefile (mb, file, &error);
+ mono_error_raise_exception (&error);
}
ICALL_EXPORT void
ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
{
- mono_image_build_metadata (mb);
+ MonoError error;
+ if (!mono_image_build_metadata (mb, &error))
+ mono_error_raise_exception (&error);
}
ICALL_EXPORT void
}
static MonoReflectionType *
-type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase)
+type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoError *error)
{
MonoMethod *m, *dest;
MonoAssembly *assembly = NULL;
gboolean type_resolve = FALSE;
+ mono_error_init (error);
+
/*
* We must compute the calling assembly as type loading must happen under a metadata context.
* For example. The main assembly is a.exe and Type.GetType is called from dir/b.dll. Without
if (!type)
return NULL;
- return mono_type_get_object (mono_domain_get (), type);
-}
-
-#ifdef UNUSED
-MonoReflectionType *
-mono_type_get (const char *str)
-{
- char *copy = g_strdup (str);
- MonoTypeNameParse info;
- MonoReflectionType *type;
- gboolean parsedOk;
-
- parsedOk = mono_reflection_parse_type(copy, &info);
- if (!parsedOk) {
- mono_reflection_free_type_info (&info);
- g_free(copy);
- return NULL;
- }
-
- type = type_from_parsed_name (&info, FALSE);
-
- mono_reflection_free_type_info (&info);
- g_free(copy);
-
- return type;
+ return mono_type_get_object_checked (mono_domain_get (), type, error);
}
-#endif
ICALL_EXPORT MonoReflectionType*
ves_icall_type_from_name (MonoString *name,
MonoBoolean throwOnError,
MonoBoolean ignoreCase)
{
+ MonoError error;
char *str = mono_string_to_utf8 (name);
MonoTypeNameParse info;
MonoReflectionType *type;
mono_reflection_free_type_info (&info);
g_free (str);
if (throwOnError) {
- mono_set_pending_exception(mono_get_exception_argument("typeName", "failed parse"));
+ mono_set_pending_exception (mono_get_exception_argument("typeName", "failed parse"));
}
return NULL;
}
- type = type_from_parsed_name (&info, ignoreCase);
+ type = type_from_parsed_name (&info, ignoreCase, &error);
mono_reflection_free_type_info (&info);
g_free (str);
+ if (!mono_error_ok (&error)) {
+ if (throwOnError)
+ mono_error_set_pending_exception (&error);
+ else
+ mono_error_cleanup (&error);
+ return NULL;
+ }
+
if (type == NULL){
MonoException *e = NULL;
ICALL_EXPORT MonoReflectionType*
ves_icall_type_from_handle (MonoType *handle)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoDomain *domain = mono_domain_get ();
- return mono_type_get_object (domain, handle);
+ ret = mono_type_get_object_checked (domain, handle, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
/* System.TypeCode */
ICALL_EXPORT MonoReflectionMarshalAsAttribute*
ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionField *field)
{
+ MonoError error;
MonoClass *klass = field->field->parent;
MonoMarshalType *info;
MonoType *ftype;
if (info->fields [i].field == field->field) {
if (!info->fields [i].mspec)
return NULL;
- else
- return mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
+ else {
+ MonoReflectionMarshalAsAttribute* obj;
+ obj = mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec, &error);
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
+ return obj;
+ }
}
}
ICALL_EXPORT MonoReflectionField*
ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type)
{
+ MonoError error;
gboolean found = FALSE;
MonoClass *klass;
MonoClass *k;
return NULL;
}
- return mono_field_get_object (mono_domain_get (), klass, handle);
+ MonoReflectionField *result = mono_field_get_object_checked (mono_domain_get (), klass, handle, &error);
+ mono_error_raise_exception (&error);
+ return result;
}
ICALL_EXPORT MonoArray*
{
MonoError error;
MonoType *type = mono_field_get_type_checked (field->field, &error);
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
return type_array_from_modifiers (field->field->parent->image, type, optional);
}
ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
{
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_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
+
+ rt = mono_type_get_object_checked (domain, &method->klass->byval_arg, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
+
+ MONO_STRUCT_SETREF (info, parent, rt);
+
+ rt = mono_type_get_object_checked (domain, sig->ret, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
+ MONO_STRUCT_SETREF (info, ret, rt);
- MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &method->klass->byval_arg));
- MONO_STRUCT_SETREF (info, ret, mono_type_get_object (domain, sig->ret));
info->attrs = method->flags;
info->implattrs = method->iflags;
if (sig->call_convention == MONO_CALL_DEFAULT)
ICALL_EXPORT MonoReflectionMarshalAsAttribute*
ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
{
+ MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoReflectionMarshalAsAttribute* res = NULL;
MonoMarshalSpec **mspecs;
mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
mono_method_get_marshal_info (method, mspecs);
- if (mspecs [0])
- res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0]);
+ if (mspecs [0]) {
+ res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0], &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ }
for (i = mono_method_signature (method)->param_count; i >= 0; i--)
if (mspecs [i])
ICALL_EXPORT MonoReflectionType*
ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *parent;
parent = declaring? field->field->parent: field->klass;
- return mono_type_get_object (mono_object_domain (field), &parent->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (field), &parent->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
+
}
ICALL_EXPORT MonoObject *
mono_security_core_clr_ensure_reflection_access_field (cf);
type = mono_field_get_type_checked (cf, &error);
- if (!mono_error_ok (&error))
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
v = (gchar *) value;
if (!type->byref) {
* This is complicated by the fact that Nullables have
* a variable structure.
*/
- nullable = mono_object_new (mono_domain_get (), nklass);
+ nullable = mono_object_new_checked (mono_domain_get (), nklass, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
mono_nullable_init ((guint8 *)mono_object_unbox (nullable), value, nklass);
mono_class_init (field->parent);
t = mono_field_get_type_checked (field, &error);
- if (!mono_error_ok (&error))
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (!(t->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)) {
mono_set_pending_exception (mono_get_exception_invalid_operation (NULL));
t->type = def_type;
klass = mono_class_from_mono_type (t);
g_free (t);
- o = mono_object_new (domain, klass);
+ o = mono_object_new_checked (domain, klass, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
v = ((gchar *) o) + sizeof (MonoObject);
mono_get_constant_value_from_blob (domain, def_type, def_value, v);
break;
ves_icall_MonoField_ResolveType (MonoReflectionField *ref_field)
{
MonoError error;
- MonoClassField *field = ref_field->field;
- MonoType *type = mono_field_get_type_checked (field, &error);
- if (!mono_error_ok (&error))
- mono_error_raise_exception (&error);
- return mono_type_get_object (mono_object_domain (ref_field), type);
+ MonoReflectionType *ret;
+ MonoType *type;
+
+ type = mono_field_get_type_checked (ref_field->field, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+
+ ret = mono_type_get_object_checked (mono_object_domain (ref_field), type, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+
+ return ret;
}
/* From MonoProperty.cs */
ICALL_EXPORT void
ves_icall_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
{
+ MonoError error;
+ MonoReflectionType *rt;
+ MonoReflectionMethod *rm;
MonoDomain *domain = mono_object_domain (property);
const MonoProperty *pproperty = property->property;
- if ((req_info & PInfo_ReflectedType) != 0)
- MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg));
- if ((req_info & PInfo_DeclaringType) != 0)
- MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &pproperty->parent->byval_arg));
+ if ((req_info & PInfo_ReflectedType) != 0) {
+ rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ MONO_STRUCT_SETREF (info, parent, rt);
+ }
+ if ((req_info & PInfo_DeclaringType) != 0) {
+ rt = mono_type_get_object_checked (domain, &pproperty->parent->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ MONO_STRUCT_SETREF (info, declaring_type, rt);
+ }
if ((req_info & PInfo_Name) != 0)
MONO_STRUCT_SETREF (info, name, mono_string_new (domain, pproperty->name));
if ((req_info & PInfo_Attributes) != 0)
info->attrs = pproperty->attrs;
- if ((req_info & PInfo_GetMethod) != 0)
- MONO_STRUCT_SETREF (info, get, pproperty->get &&
- (((pproperty->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) || pproperty->get->klass == property->klass) ?
- mono_method_get_object (domain, pproperty->get, property->klass): NULL);
- if ((req_info & PInfo_SetMethod) != 0)
- MONO_STRUCT_SETREF (info, set, pproperty->set &&
- (((pproperty->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) || pproperty->set->klass == property->klass) ?
- mono_method_get_object (domain, pproperty->set, property->klass): NULL);
+ if ((req_info & PInfo_GetMethod) != 0) {
+ 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);
+ mono_error_raise_exception (&error);
+ } else {
+ rm = NULL;
+ }
+
+ MONO_STRUCT_SETREF (info, get, rm);
+ }
+ if ((req_info & PInfo_SetMethod) != 0) {
+ 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);
+ mono_error_raise_exception (&error);
+ } else {
+ rm = NULL;
+ }
+
+ MONO_STRUCT_SETREF (info, set, rm);
+ }
/*
* There may be other methods defined for properties, though, it seems they are not exposed
* in the reflection API
ICALL_EXPORT void
ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
{
+ MonoError error;
+ MonoReflectionType *rt;
+ MonoReflectionMethod *rm;
MonoDomain *domain = mono_object_domain (event);
- MONO_STRUCT_SETREF (info, reflected_type, mono_type_get_object (domain, &event->klass->byval_arg));
- MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &event->event->parent->byval_arg));
+ rt = mono_type_get_object_checked (domain, &event->klass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ MONO_STRUCT_SETREF (info, reflected_type, rt);
+
+ rt = mono_type_get_object_checked (domain, &event->event->parent->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ MONO_STRUCT_SETREF (info, declaring_type, rt);
MONO_STRUCT_SETREF (info, name, mono_string_new (domain, event->event->name));
info->attrs = event->event->attrs;
- MONO_STRUCT_SETREF (info, add_method, event->event->add ? mono_method_get_object (domain, event->event->add, NULL): NULL);
- MONO_STRUCT_SETREF (info, remove_method, event->event->remove ? mono_method_get_object (domain, event->event->remove, NULL): NULL);
- MONO_STRUCT_SETREF (info, raise_method, event->event->raise ? mono_method_get_object (domain, event->event->raise, NULL): NULL);
+
+ if (event->event->add) {
+ rm = mono_method_get_object_checked (domain, event->event->add, NULL, &error);
+ mono_error_raise_exception (&error);
+ } else {
+ rm = NULL;
+ }
+
+ MONO_STRUCT_SETREF (info, add_method, rm);
+
+ if (event->event->remove) {
+ rm = mono_method_get_object_checked (domain, event->event->remove, NULL, &error);
+ mono_error_raise_exception (&error);
+ } else {
+ rm = NULL;
+ }
+
+ MONO_STRUCT_SETREF (info, remove_method, rm);
+
+ if (event->event->raise) {
+ rm = mono_method_get_object_checked (domain, event->event->raise, NULL, &error);
+ mono_error_raise_exception (&error);
+ } else {
+ rm = NULL;
+ }
+
+ MONO_STRUCT_SETREF (info, raise_method, rm);
#ifndef MONO_SMALL_CONFIG
if (event->event->other) {
n++;
MONO_STRUCT_SETREF (info, other_methods, mono_array_new (domain, mono_defaults.method_info_class, n));
- for (i = 0; i < n; i++)
- mono_array_setref (info->other_methods, i, mono_method_get_object (domain, event->event->other [i], NULL));
+ for (i = 0; i < n; i++) {
+ rm = mono_method_get_object_checked (domain, event->event->other [i], NULL, &error);
+ mono_error_raise_exception (&error);
+ mono_array_setref (info->other_methods, i, rm);
+ }
}
#endif
}
static void
fill_iface_array (gpointer key, gpointer value, gpointer user_data)
{
+ MonoReflectionType *rt;
FillIfaceArrayData *data = (FillIfaceArrayData *)user_data;
MonoClass *ic = (MonoClass *)key;
MonoType *ret = &ic->byval_arg, *inflated = NULL;
return;
}
- mono_array_setref (data->iface_array, data->next_idx++, mono_type_get_object (data->domain, ret));
+ rt = mono_type_get_object_checked (data->domain, ret, data->error);
+ if (!mono_error_ok (data->error))
+ return;
+
+ mono_array_setref (data->iface_array, data->next_idx++, rt);
if (inflated)
mono_metadata_free_type (inflated);
fail:
g_hash_table_destroy (iface_hash);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return NULL;
}
gpointer iter;
int i = 0, len, ioffset;
MonoDomain *domain;
+ MonoError error;
mono_class_init_or_throw (klass);
mono_class_init_or_throw (iclass);
mono_gc_wbarrier_generic_store (methods, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
iter = NULL;
while ((method = mono_class_get_methods (iclass, &iter))) {
- member = mono_method_get_object (domain, method, iclass);
+ member = mono_method_get_object_checked (domain, method, iclass, &error);
+ mono_error_raise_exception (&error);
mono_array_setref (*methods, i, member);
- member = mono_method_get_object (domain, klass->vtable [i + ioffset], klass);
+ member = mono_method_get_object_checked (domain, klass->vtable [i + ioffset], klass, &error);
+ mono_error_raise_exception (&error);
mono_array_setref (*targets, i, member);
i ++;
ICALL_EXPORT MonoReflectionType*
ves_icall_MonoType_GetElementType (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass;
- if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY)
- return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg);
+ if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY) {
+ ret = mono_type_get_object_checked (mono_object_domain (type), &type->type->data.klass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
+ }
klass = mono_class_from_mono_type (type->type);
mono_class_init_or_throw (klass);
// GetElementType should only return a type for:
// Array Pointer PassedByRef
if (type->type->byref)
- return mono_type_get_object (mono_object_domain (type), &klass->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (type), &klass->byval_arg, &error);
else if (klass->element_class && MONO_CLASS_IS_ARRAY (klass))
- return mono_type_get_object (mono_object_domain (type), &klass->element_class->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error);
else if (klass->element_class && type->type->type == MONO_TYPE_PTR)
- return mono_type_get_object (mono_object_domain (type), &klass->element_class->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error);
else
return NULL;
+
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoReflectionType*
ves_icall_get_type_parent (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
+
if (type->type->byref)
return NULL;
MonoClass *klass = mono_class_from_mono_type (type->type);
- return klass->parent ? mono_type_get_object (mono_object_domain (type), &klass->parent->byval_arg): NULL;
+ if (!klass->parent)
+ return NULL;
+
+ ret = mono_type_get_object_checked (mono_object_domain (type), &klass->parent->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoBoolean
ICALL_EXPORT MonoReflectionModule*
ves_icall_MonoType_get_Module (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionModule *result = NULL;
MonoClass *klass = mono_class_from_mono_type (type->type);
- return mono_module_get_object (mono_object_domain (type), klass->image);
+ result = mono_module_get_object_checked (mono_object_domain (type), klass->image, &error);
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionAssembly*
ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
{
+ MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (type->type);
- return mono_assembly_get_object (domain, klass->image->assembly);
+ MonoReflectionAssembly *result = mono_assembly_get_object_checked (domain, klass->image->assembly, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionType*
ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoDomain *domain = mono_domain_get ();
MonoClass *klass;
klass = mono_class_from_mono_type (type->type)->nested_in;
}
- return klass ? mono_type_get_object (domain, &klass->byval_arg) : NULL;
+ if (!klass)
+ return NULL;
+
+ ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoString*
ICALL_EXPORT MonoArray*
ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
{
+ MonoError error;
+ MonoReflectionType *rt;
MonoArray *res;
MonoClass *klass, *pklass;
MonoDomain *domain = mono_object_domain (type);
res = create_type_array (domain, runtimeTypeArray, container->type_argc);
for (i = 0; i < container->type_argc; ++i) {
pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i));
- mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg));
+
+ rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ mono_array_setref (res, i, rt);
}
} else if (klass->generic_class) {
MonoGenericInst *inst = klass->generic_class->context.class_inst;
res = create_type_array (domain, runtimeTypeArray, inst->type_argc);
- for (i = 0; i < inst->type_argc; ++i)
- mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
+ for (i = 0; i < inst->type_argc; ++i) {
+ rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
+ mono_error_raise_exception (&error);
+
+ mono_array_setref (res, i, rt);
+ }
} else {
res = NULL;
}
ICALL_EXPORT MonoReflectionType*
ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass;
if (type->type->byref)
if (generic_class->wastypebuilder && tb)
return (MonoReflectionType *)tb;
- else
- return mono_type_get_object (mono_object_domain (type), &generic_class->byval_arg);
+ else {
+ ret = mono_type_get_object_checked (mono_object_domain (type), &generic_class->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
+ }
}
return NULL;
}
ICALL_EXPORT MonoReflectionType*
ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass;
MonoType *geninst, **types;
int i, count;
return NULL;
}
- return mono_type_get_object (mono_object_domain (type), geninst);
+ ret = mono_type_get_object_checked (mono_object_domain (type), geninst, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT gboolean
ICALL_EXPORT MonoArray *
ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *rt;
MonoGenericParamInfo *param_info;
MonoDomain *domain;
MonoClass **ptr;
;
res = mono_array_new (domain, mono_defaults.monotype_class, count);
- for (i = 0; i < count; i++)
- mono_array_setref (res, i, mono_type_get_object (domain, ¶m_info->constraints [i]->byval_arg));
+ for (i = 0; i < count; i++) {
+ rt = mono_type_get_object_checked (domain, ¶m_info->constraints [i]->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ mono_array_setref (res, i, rt);
+ }
return res;
MonoClass *klass;
MonoMethod *method;
gpointer iter;
+ MonoError error;
+ MonoReflectionMethod *ret = NULL;
domain = ((MonoObject *)type)->vtable->domain;
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
- if (method->token == generic->method->token)
- return mono_method_get_object (domain, method, klass);
+ if (method->token == generic->method->token) {
+ ret = mono_method_get_object_checked (domain, method, klass, &error);
+ mono_error_raise_exception (&error);
+ }
}
- return NULL;
+ return ret;
}
ICALL_EXPORT MonoReflectionMethod *
{
MonoMethod *method;
MonoType *type = ref_type->type;
+ MonoError error;
+ MonoReflectionMethod *ret = NULL;
if (type->byref || (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR)) {
mono_set_pending_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments"));
method = mono_type_get_generic_param_owner (type)->owner.method;
g_assert (method);
- return mono_method_get_object (mono_object_domain (ref_type), method, method->klass);
+
+ ret = mono_method_get_object_checked (mono_object_domain (ref_type), method, method->klass, &error);
+ if (!mono_error_ok (&error))
+ mono_set_pending_exception (mono_error_convert_to_exception (&error));
+ return ret;
}
ICALL_EXPORT MonoBoolean
{
MonoMethodInflated *imethod;
MonoMethod *result;
+ MonoReflectionMethod *ret = NULL;
+ MonoError error;
if (method->method->is_generic)
return method;
MonoClass *klass = ((MonoMethod *) imethod)->klass;
/*Generic methods gets the context of the GTD.*/
if (mono_class_get_context (klass)) {
- MonoError error;
result = mono_class_inflate_generic_method_full_checked (result, klass, mono_class_get_context (klass), &error);
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error))
+ goto leave;
}
}
- return mono_method_get_object (mono_object_domain (method), result, NULL);
+ ret = mono_method_get_object_checked (mono_object_domain (method), result, NULL, &error);
+leave:
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
+ return ret;
}
ICALL_EXPORT gboolean
ICALL_EXPORT MonoArray*
ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
{
+ MonoError error;
+ MonoReflectionType *rt;
MonoArray *res;
MonoDomain *domain;
int count, i;
count = inst->type_argc;
res = mono_array_new (domain, mono_defaults.systemtype_class, count);
- for (i = 0; i < count; i++)
- mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
+ for (i = 0; i < count; i++) {
+ rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
+ mono_error_raise_exception (&error);
+
+ mono_array_setref (res, i, rt);
+ }
return res;
}
MonoGenericContainer *container = mono_method_get_generic_container (method->method);
MonoGenericParam *param = mono_generic_container_get_param (container, i);
MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
- mono_array_setref (res, i,
- mono_type_get_object (domain, &pklass->byval_arg));
+
+ rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ mono_array_setref (res, i, rt);
}
return res;
ICALL_EXPORT MonoObject *
ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this_arg, MonoArray *params, MonoException **exc)
{
+ MonoError error;
/*
* Invoke from reflection is supposed to always be a virtual call (the API
* is stupid), mono_runtime_invoke_*() calls the provided method, allowing
}
if (m->klass->rank && !strcmp (m->name, ".ctor")) {
+ MonoArray *arr;
int i;
uintptr_t *lengths;
intptr_t *lower_bounds;
if (m->klass->rank == 1 && sig->param_count == 2 && m->klass->element_class->rank) {
/* This is a ctor for jagged arrays. MS creates an array of arrays. */
- MonoArray *arr = mono_array_new_full (mono_object_domain (params), m->klass, lengths, NULL);
+ arr = mono_array_new_full_checked (mono_object_domain (params), m->klass, lengths, NULL, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
for (i = 0; i < mono_array_length (arr); ++i) {
- MonoArray *subarray = mono_array_new_full (mono_object_domain (params), m->klass->element_class, &lengths [1], NULL);
-
+ MonoArray *subarray = mono_array_new_full_checked (mono_object_domain (params), m->klass->element_class, &lengths [1], NULL, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
mono_array_setref_fast (arr, i, subarray);
}
return (MonoObject*)arr;
if (m->klass->rank == pcount) {
/* Only lengths provided. */
- return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, NULL);
+ arr = mono_array_new_full_checked (mono_object_domain (params), m->klass, lengths, NULL, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+
+ return (MonoObject*)arr;
} else {
g_assert (pcount == (m->klass->rank * 2));
/* The arguments are lower-bound-length pairs */
lengths [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, (i * 2) + 1) + sizeof (MonoObject));
}
- return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, lower_bounds);
+ arr = mono_array_new_full_checked (mono_object_domain (params), m->klass, lengths, lower_bounds, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+
+ return (MonoObject*)arr;
}
}
return mono_runtime_invoke_array (m, obj, params, NULL);
ICALL_EXPORT MonoObject *
ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, guint64 value)
{
+ MonoError error;
MonoDomain *domain;
MonoClass *enumc;
MonoObject *res;
etype = mono_class_enum_basetype (enumc);
- res = mono_object_new (domain, enumc);
+ res = mono_object_new_checked (domain, enumc, &error);
+ mono_error_raise_exception (&error);
write_enum_value ((char *)res + sizeof (MonoObject), etype->type, value);
return res;
ICALL_EXPORT MonoObject *
ves_icall_System_Enum_get_value (MonoObject *eobj)
{
+ MonoError error;
MonoObject *res;
MonoClass *enumc;
gpointer dst;
g_assert (eobj->vtable->klass->enumtype);
enumc = mono_class_from_mono_type (mono_class_enum_basetype (eobj->vtable->klass));
- res = mono_object_new (mono_object_domain (eobj), enumc);
+ res = mono_object_new_checked (mono_object_domain (eobj), enumc, &error);
+ mono_error_raise_exception (&error);
dst = (char *)res + sizeof (MonoObject);
src = (char *)eobj + sizeof (MonoObject);
size = mono_class_value_size (enumc, NULL);
ICALL_EXPORT MonoReflectionType *
ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoType *etype;
MonoClass *klass;
return NULL;
}
- return mono_type_get_object (mono_object_domain (type), etype);
+ ret = mono_type_get_object_checked (mono_object_domain (type), etype, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT int
ICALL_EXPORT MonoArray*
ves_icall_Type_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
{
+ MonoError error;
MonoDomain *domain;
MonoClass *startklass, *klass, *refklass;
MonoArray *res;
continue;
}
- member = (MonoObject*)mono_field_get_object (domain, refklass, field);
+ member = (MonoObject*)mono_field_get_object_checked (domain, refklass, field, &error);
+ if (!mono_error_ok (&error))
+ goto fail;
mono_ptr_array_append (tmp_array, member);
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
g_free (utf8_name);
return res;
+fail:
+ mono_ptr_array_destroy (tmp_array);
+ mono_error_raise_exception (&error);
+ g_assert_not_reached ();
}
static gboolean
ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
static MonoClass *MethodInfo_array;
+ MonoError error;
MonoDomain *domain;
MonoArray *res;
MonoVTable *array_vtable;
MonoClass *klass, *refklass;
int i;
+ mono_error_init (&error);
+
if (!MethodInfo_array) {
MonoClass *klass = mono_array_class_get (mono_defaults.method_info_class, 1);
mono_memory_barrier ();
refklass = mono_class_from_mono_type (reftype->type);
domain = ((MonoObject *)type)->vtable->domain;
array_vtable = mono_class_vtable_full (domain, MethodInfo_array, TRUE);
- if (type->type->byref)
- return mono_array_new_specific (array_vtable, 0);
+ if (type->type->byref) {
+ res = mono_array_new_specific_checked (array_vtable, 0, &error);
+ mono_error_set_pending_exception (&error);
+
+ return res;
+ }
if (name)
mname = mono_string_to_utf8 (name);
return NULL;
}
- res = mono_array_new_specific (array_vtable, method_array->len);
+ res = mono_array_new_specific_checked (array_vtable, method_array->len, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
for (i = 0; i < method_array->len; ++i) {
MonoMethod *method = (MonoMethod *)g_ptr_array_index (method_array, i);
- mono_array_setref (res, i, mono_method_get_object (domain, method, refklass));
+ MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, refklass, &error);
+ if (!mono_error_ok (&error))
+ goto failure;
+ mono_array_setref (res, i, rm);
}
+failure:
g_ptr_array_free (method_array, TRUE);
+ if (!mono_error_ok (&error))
+ mono_set_pending_exception (mono_error_convert_to_exception (&error));
return res;
}
int i, match;
gpointer iter = NULL;
MonoPtrArray tmp_array;
+ MonoError error;
mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection constructors list"); /*FIXME, guestimating*/
if (!match)
continue;
- member = (MonoObject*)mono_method_get_object (domain, method, refklass);
+ member = (MonoObject*)mono_method_get_object_checked (domain, method, refklass, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
mono_ptr_array_append (tmp_array, member);
}
ICALL_EXPORT MonoArray*
ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
- MonoException *ex;
+ MonoError error;
MonoDomain *domain;
static MonoClass *System_Reflection_PropertyInfo;
MonoClass *startklass, *klass;
GHashTable *properties = NULL;
MonoPtrArray tmp_array;
+ mono_error_init (&error);
+
mono_ptr_array_init (tmp_array, 8, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection properties list"); /*This the average for ASP.NET types*/
if (!System_Reflection_PropertyInfo)
if (g_hash_table_lookup (properties, prop))
continue;
- mono_ptr_array_append (tmp_array, mono_property_get_object (domain, startklass, prop));
+ MonoReflectionProperty *pr = mono_property_get_object_checked (domain, startklass, prop, &error);
+ if (!pr)
+ goto failure;
+ mono_ptr_array_append (tmp_array, pr);
g_hash_table_insert (properties, prop, prop);
}
return res;
+
+
loader_error:
+ if (klass->exception_type != MONO_EXCEPTION_NONE) {
+ mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
+ } else {
+ mono_error_set_from_loader_error (&error);
+ mono_loader_clear_error ();
+ }
+
+failure:
if (properties)
g_hash_table_destroy (properties);
if (name)
g_free (propname);
mono_ptr_array_destroy (tmp_array);
- if (klass->exception_type != MONO_EXCEPTION_NONE) {
- ex = mono_class_get_exception_for_failure (klass);
- } else {
- ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
- mono_loader_clear_error ();
- }
- mono_set_pending_exception (ex);
+ mono_error_set_pending_exception (&error);
+
return NULL;
}
ICALL_EXPORT MonoArray*
ves_icall_Type_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
{
- MonoException *ex;
+ MonoError error;
MonoDomain *domain;
static MonoClass *System_Reflection_EventInfo;
MonoClass *startklass, *klass;
GHashTable *events = NULL;
MonoPtrArray tmp_array;
+ mono_error_init (&error);
+
mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection events list");
if (!System_Reflection_EventInfo)
if (g_hash_table_lookup (events, event))
continue;
- mono_ptr_array_append (tmp_array, mono_event_get_object (domain, startklass, event));
+ MonoReflectionEvent *ev_obj;
+ ev_obj = mono_event_get_object_checked (domain, startklass, event, &error);
+ if (!ev_obj)
+ goto failure;
+ mono_ptr_array_append (tmp_array, ev_obj);
g_hash_table_insert (events, event, event);
}
return res;
loader_error:
- mono_ptr_array_destroy (tmp_array);
if (klass->exception_type != MONO_EXCEPTION_NONE) {
- ex = mono_class_get_exception_for_failure (klass);
+ mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
} else {
- ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
+ mono_error_set_from_loader_error (&error);
mono_loader_clear_error ();
}
- mono_set_pending_exception (ex);
+
+failure:
+
+ if (events != NULL)
+ g_hash_table_destroy (events);
+ if (utf8_name != NULL)
+ g_free (utf8_name);
+
+ mono_ptr_array_destroy (tmp_array);
+
+ mono_error_set_pending_exception (&error);
return NULL;
}
ICALL_EXPORT MonoArray*
ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
+ MonoError error;
+ MonoReflectionType *rt;
MonoDomain *domain;
MonoClass *klass;
MonoArray *res;
- MonoObject *member;
int i, match;
MonoClass *nested;
gpointer iter;
continue;
}
- member = (MonoObject*)mono_type_get_object (domain, &nested->byval_arg);
- mono_ptr_array_append (tmp_array, member);
+ rt = mono_type_get_object_checked (domain, &nested->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ mono_ptr_array_append (tmp_array, (MonoObject*) rt);
}
res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array));
ICALL_EXPORT MonoReflectionType*
ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
+ MonoError error;
+ MonoReflectionType *ret;
gchar *str;
MonoType *type = NULL;
MonoTypeNameParse info;
}
/* g_print ("got it\n"); */
- return mono_type_get_object (mono_object_domain (assembly), type);
+ ret = mono_type_get_object_checked (mono_object_domain (assembly), type, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
static gboolean
ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
{
+ MonoError error;
gchar *name;
MonoAssembly *res;
MonoImageOpenStatus status;
+ MonoReflectionAssembly* result = NULL;
name = mono_string_to_utf8 (mname);
res = mono_assembly_load_with_partial_name (name, &status);
if (res == NULL)
return NULL;
- return mono_assembly_get_object (mono_domain_get (), res);
+ result = mono_assembly_get_object_checked (mono_domain_get (), res, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoString *
ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
{
MonoError error;
+ MonoReflectionMethod *res = NULL;
MonoMethod *method;
+
guint32 token = mono_image_get_entry_point (assembly->assembly->image);
if (!token)
return NULL;
method = mono_get_method_checked (assembly->assembly->image, token, NULL, NULL, &error);
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error))
+ goto leave;
- return mono_method_get_object (mono_object_domain (assembly), method, NULL);
+ res = mono_method_get_object_checked (mono_object_domain (assembly), method, NULL, &error);
+
+leave:
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
+ return res;
}
ICALL_EXPORT MonoReflectionModule*
ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly)
{
- return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image);
+ MonoError error;
+ MonoReflectionModule *result = NULL;
+ result = mono_module_get_object_checked (mono_object_domain (assembly), assembly->assembly->image, &error);
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoArray*
}
static MonoObject*
-create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
+create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision, MonoError *error)
{
static MonoClass *System_Version = NULL;
static MonoMethod *create_version = NULL;
MonoObject *result;
gpointer args [4];
+
+ mono_error_init (error);
if (!System_Version) {
System_Version = mono_class_from_name (mono_defaults.corlib, "System", "Version");
args [1] = &minor;
args [2] = &build;
args [3] = &revision;
- result = mono_object_new (domain, System_Version);
- mono_runtime_invoke (create_version, result, args, NULL);
+ result = mono_object_new_checked (domain, System_Version, error);
+ return_val_if_nok (error, NULL);
+
+ mono_runtime_invoke_checked (create_version, result, args, error);
+ return_val_if_nok (error, NULL);
return result;
}
ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
{
static MonoClass *System_Reflection_AssemblyName;
+ MonoError error;
MonoArray *result;
MonoDomain *domain = mono_object_domain (assembly);
int i, count = 0;
static MonoMethod *create_culture = NULL;
MonoImage *image = assembly->assembly->image;
MonoTableInfo *t;
+ MonoObject *o;
if (!System_Reflection_AssemblyName)
System_Reflection_AssemblyName = mono_class_from_name (
}
for (i = 0; i < count; i++) {
+ MonoObject *version;
MonoReflectionAssemblyName *aname;
guint32 cols [MONO_ASSEMBLYREF_SIZE];
mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
- aname = (MonoReflectionAssemblyName *) mono_object_new (
- domain, System_Reflection_AssemblyName);
+ aname = (MonoReflectionAssemblyName *) mono_object_new_checked (
+ domain, System_Reflection_AssemblyName, &error);
+ mono_error_raise_exception (&error);
MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
aname->versioncompat = 1; /* SameMachine (default) */
aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
- MONO_OBJECT_SETREF (aname, version, create_version (domain, aname->major, aname->minor, aname->build, aname->revision));
+
+ version = create_version (domain, aname->major, aname->minor, aname->build, aname->revision, &error);
+ mono_error_raise_exception (&error);
+
+ MONO_OBJECT_SETREF (aname, version, version);
if (create_culture) {
gpointer args [2];
MonoBoolean assembly_ref = 1;
args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]));
args [1] = &assembly_ref;
- MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
+
+ o = mono_runtime_invoke_checked (create_culture, NULL, args, &error);
+ mono_error_raise_exception (&error);
+
+ MONO_OBJECT_SETREF (aname, cultureInfo, o);
}
if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
ICALL_EXPORT void *
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
{
+ MonoError error;
char *n = mono_string_to_utf8 (name);
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
guint32 i;
else
module = assembly->assembly->image;
- mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) mono_module_get_object (mono_domain_get (), module));
+
+ MonoReflectionModule *rm = mono_module_get_object_checked (mono_domain_get (), module, &error);
+ mono_error_raise_exception (&error);
+ mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) rm);
return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
}
ICALL_EXPORT gboolean
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info)
{
+ MonoError error;
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
int i;
guint32 cols [MONO_MANIFEST_SIZE];
mono_set_pending_exception (ex);
return FALSE;
}
- MONO_OBJECT_SETREF (info, assembly, mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]));
+ MonoReflectionAssembly *assm_obj;
+ assm_obj = mono_assembly_get_object_checked (mono_domain_get (), assembly->assembly->image->references [i - 1], &error);
+ if (!assm_obj) {
+ mono_error_set_pending_exception (&error);
+ return FALSE;
+ }
+ MONO_OBJECT_SETREF (info, assembly, assm_obj);
/* Obtain info recursively */
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info);
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly)
{
+ MonoError error;
MonoDomain *domain = mono_domain_get();
MonoArray *res;
MonoClass *klass;
klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
- mono_array_setref (res, 0, mono_module_get_object (domain, image));
+ MonoReflectionModule *image_obj = mono_module_get_object_checked (domain, image, &error);
+ mono_error_raise_exception (&error);
+ mono_array_setref (res, 0, image_obj);
j = 1;
for (i = 0; i < module_count; ++i)
if (modules [i]) {
- mono_array_setref (res, j, mono_module_get_object (domain, modules[i]));
+ MonoReflectionModule *rm = mono_module_get_object_checked (domain, modules[i], &error);
+ mono_error_raise_exception (&error);
+ mono_array_setref (res, j, rm);
++j;
}
for (i = 0; i < file_count; ++i, ++j) {
mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE);
- if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
- mono_array_setref (res, j, mono_module_file_get_object (domain, image, i));
+ if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA) {
+ MonoReflectionModule *rm = mono_module_file_get_object_checked (domain, image, i, &error);
+ mono_error_raise_exception (&error);
+ mono_array_setref (res, j, rm);
+ }
else {
MonoImage *m = mono_image_load_file_for_image (image, i + 1);
if (!m) {
mono_set_pending_exception (mono_get_exception_file_not_found2 (NULL, fname));
return NULL;
}
- mono_array_setref (res, j, mono_module_get_object (domain, m));
+ MonoReflectionModule *rm = mono_module_get_object_checked (domain, m, &error);
+ mono_error_raise_exception (&error);
+ mono_array_setref (res, j, rm);
}
}
ICALL_EXPORT MonoReflectionMethod*
ves_icall_GetCurrentMethod (void)
{
+ MonoReflectionMethod *res = NULL;
+ MonoError error;
+
MonoMethod *m = mono_method_get_last_managed ();
- if (!m)
- mono_raise_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
+ if (!m) {
+ mono_set_pending_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
+ return NULL;
+ }
while (m->is_inflated)
m = ((MonoMethodInflated*)m)->declaring;
- return mono_method_get_object (mono_domain_get (), m, NULL);
+ res = mono_method_get_object_checked (mono_domain_get (), m, NULL, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
{
+ MonoReflectionMethod *res = NULL;
+ MonoError error;
MonoClass *klass;
if (type) {
klass = mono_class_from_mono_type (type);
}
} else
klass = method->klass;
- return mono_method_get_object (mono_domain_get (), method, klass);
+ res = mono_method_get_object_checked (mono_domain_get (), method, klass, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
ICALL_EXPORT MonoReflectionMethodBody*
ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
{
+ MonoError error;
+ MonoReflectionAssembly *result;
MonoMethod *dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
g_assert (dest);
- return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
+ result = mono_assembly_get_object_checked (mono_domain_get (), dest->klass->image->assembly, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
{
+ MonoError error;
+ MonoReflectionAssembly *result;
MonoDomain* domain = mono_domain_get ();
if (!domain->entry_assembly)
return NULL;
- return mono_assembly_get_object (domain, domain->entry_assembly);
+ result = mono_assembly_get_object_checked (domain, domain->entry_assembly, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
{
+ MonoError error;
MonoMethod *m;
MonoMethod *dest;
+ MonoReflectionAssembly *result;
dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
mono_stack_walk_no_il (get_caller_no_reflection, &dest);
if (!dest)
dest = m;
- if (!m)
- mono_raise_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
- return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
+ if (!m) {
+ mono_set_pending_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
+ return NULL;
+ }
+ result = mono_assembly_get_object_checked (mono_domain_get (), dest->klass->image->assembly, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoString *
}
static void
-fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
+fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token, MonoError *error)
{
static MonoMethod *create_culture = NULL;
+ MonoObject *obj;
gpointer args [2];
guint32 pkey_len;
const char *pkey_ptr;
gchar *codebase;
MonoBoolean assembly_ref = 0;
+ mono_error_init (error);
+
MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
aname->major = name->major;
aname->minor = name->minor;
aname->versioncompat = 1; /* SameMachine (default) */
aname->processor_architecture = name->arch;
- if (by_default_version)
- MONO_OBJECT_SETREF (aname, version, create_version (domain, name->major, name->minor, name->build, name->revision));
+ if (by_default_version) {
+ MonoObject *version;
+
+ version = create_version (domain, name->major, name->minor, name->build, name->revision, error);
+ return_if_nok (error);
+
+ MONO_OBJECT_SETREF (aname, version, version);
+ }
codebase = NULL;
if (absolute != NULL && *absolute != '\0') {
if (name->culture) {
args [0] = mono_string_new (domain, name->culture);
args [1] = &assembly_ref;
- MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
+
+ obj = mono_runtime_invoke_checked (create_culture, NULL, args, error);
+ return_if_nok (error);
+
+ MONO_OBJECT_SETREF (aname, cultureInfo, obj);
}
if (name->public_key) {
ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
{
+ MonoError error;
gchar *absolute;
MonoAssembly *mass = assembly->assembly;
if (g_path_is_absolute (mass->image->name)) {
- fill_reflection_assembly_name (mono_object_domain (assembly),
- aname, &mass->aname, mass->image->name, TRUE,
- TRUE, TRUE);
+ fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, mass->image->name, TRUE, TRUE, TRUE, &error);
+ mono_error_set_pending_exception (&error);
return;
}
absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
- fill_reflection_assembly_name (mono_object_domain (assembly),
- aname, &mass->aname, absolute, TRUE, TRUE,
- TRUE);
+ fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, absolute, TRUE, TRUE, TRUE, &error);
+ mono_error_set_pending_exception (&error);
g_free (absolute);
}
ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
{
+ MonoError error;
char *filename;
MonoImageOpenStatus status = MONO_IMAGE_OK;
gboolean res;
return;
}
- fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename,
- TRUE, FALSE, TRUE);
+ fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, TRUE, FALSE, TRUE, &error);
+ mono_error_set_pending_exception (&error);
- g_free (filename);
mono_image_close (image);
+ g_free (filename);
}
ICALL_EXPORT MonoBoolean
}
static MonoArray*
-mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly)
+mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly, MonoError *error)
{
+ MonoReflectionType *rt;
MonoArray *res;
MonoClass *klass;
MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
int i, count;
+ mono_error_init (error);
+
/* we start the count from 1 because we skip the special type <Module> */
if (exportedOnly) {
count = 0;
count = 0;
for (i = 1; i < tdef->rows; ++i) {
if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) {
- MonoError error;
- klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, &error);
+ klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, error);
mono_loader_assert_no_error (); /* Plug any leaks */
+ mono_error_assert_ok (error);
if (klass) {
- mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg));
+ rt = mono_type_get_object_checked (domain, &klass->byval_arg, error);
+ return_val_if_nok (error, NULL);
+
+ mono_array_setref (res, count, rt);
} else {
- MonoException *ex = mono_error_convert_to_exception (&error);
+ MonoException *ex = mono_error_convert_to_exception (error);
mono_array_setref (*exceptions, count, ex);
}
count++;
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
{
+ MonoError error;
MonoArray *res = NULL;
MonoArray *exceptions = NULL;
MonoImage *image = NULL;
g_assert (!assembly_is_dynamic (assembly->assembly));
image = assembly->assembly->image;
table = &image->tables [MONO_TABLE_FILE];
- res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
+ res = mono_module_get_types (domain, image, &exceptions, exportedOnly, &error);
+ mono_error_raise_exception (&error);
/* Append data from all modules in the assembly */
for (i = 0; i < table->rows; ++i) {
MonoImage *loaded_image = mono_assembly_load_module (image->assembly, i + 1);
if (loaded_image) {
MonoArray *ex2;
- MonoArray *res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
+ MonoArray *res2;
+
+ res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly, &error);
+ mono_error_raise_exception (&error);
+
/* Append the new types to the end of the array */
if (mono_array_length (res2) > 0) {
guint32 len1, len2;
ICALL_EXPORT gboolean
ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
{
+ MonoError error;
MonoAssemblyName aname;
MonoDomain *domain = mono_object_domain (name);
char *val;
return FALSE;
}
- fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined,
- FALSE, is_token_defined);
+ fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined, FALSE, is_token_defined, &error);
+ mono_error_set_pending_exception (&error);
mono_assembly_name_free (&aname);
g_free ((guint8*) aname.public_key);
ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
{
MonoError error;
+ MonoReflectionType *ret;
MonoDomain *domain = mono_object_domain (module);
MonoClass *klass;
return NULL;
klass = mono_class_get_checked (module->image, 1 | MONO_TOKEN_TYPE_DEF, &error);
- mono_error_raise_exception (&error);
- return mono_type_get_object (domain, &klass->byval_arg);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+
+ ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+
+ return ret;
}
ICALL_EXPORT void
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
+ MonoError error;
MonoArray *exceptions;
int i;
if (!module->image)
return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0);
else {
- MonoArray *res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE);
+ MonoArray *res;
+
+ res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE, &error);
+ mono_error_raise_exception (&error);
+
for (i = 0; i < mono_array_length (exceptions); ++i) {
MonoException *ex = mono_array_get (exceptions, MonoException *, i);
if (ex) {
klass = mono_class_get_checked (image, token, &error);
if (klass)
klass = mono_class_inflate_generic_class_checked (klass, &context, &error);
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (klass)
return &klass->byval_arg;
init_generic_context_from_args (&context, type_args, method_args);
method = mono_get_method_checked (image, token, NULL, &context, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return method;
}
init_generic_context_from_args (&context, type_args, method_args);
field = mono_field_from_token_checked (image, token, &klass, &context, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return field;
}
ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
+ MonoError merror;
+ MonoObject *ret;
int table = mono_metadata_token_table (token);
*error = ResolveTokenError_Other;
case MONO_TABLE_TYPEREF:
case MONO_TABLE_TYPESPEC: {
MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
- if (t)
- return (MonoObject*)mono_type_get_object (mono_domain_get (), t);
+ if (t) {
+ ret = (MonoObject*) mono_type_get_object_checked (mono_domain_get (), t, &merror);
+ mono_error_raise_exception (&merror);
+
+ return ret;
+ }
else
return NULL;
}
case MONO_TABLE_METHOD:
case MONO_TABLE_METHODSPEC: {
MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
- if (m)
- return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
- else
+ if (m) {
+ ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
+ mono_error_raise_exception (&merror);
+
+ return ret;
+ } else
return NULL;
}
case MONO_TABLE_FIELD: {
MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
- if (f)
- return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
+ if (f) {
+ ret =(MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
+ mono_error_raise_exception (&merror);
+ return ret;
+ }
else
return NULL;
}
case MONO_TABLE_MEMBERREF:
if (mono_memberref_is_method (image, token)) {
MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
- if (m)
- return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
- else
+ if (m) {
+ ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
+ mono_error_raise_exception (&merror);
+
+ return ret;
+ } else
return NULL;
}
else {
MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
- if (f)
- return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
+ if (f) {
+ ret = (MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
+ mono_error_raise_exception (&merror);
+ return ret;
+ }
else
return NULL;
}
ICALL_EXPORT MonoReflectionType*
ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass;
int isbyref = 0, rank;
char *str = mono_string_to_utf8 (smodifiers);
}
isbyref = 1;
p++;
+
g_free (str);
- return mono_type_get_object (mono_object_domain (tb), &klass->this_arg);
- break;
+
+ ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->this_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
case '*':
klass = mono_ptr_class_get (&klass->byval_arg);
mono_class_init (klass);
break;
}
}
+
g_free (str);
- return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
+
+ ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoBoolean
ICALL_EXPORT MonoReflectionType *
ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass, *aklass;
klass = mono_class_from_mono_type (type->type);
else
aklass = mono_bounded_array_class_get (klass, rank, TRUE);
- return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (type), &aklass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoReflectionType *
ves_icall_Type_make_byref_type (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass;
klass = mono_class_from_mono_type (type->type);
mono_class_init_or_throw (klass);
check_for_invalid_type (klass);
- return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (type), &klass->this_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoReflectionType *
ves_icall_Type_MakePointerType (MonoReflectionType *type)
{
+ MonoError error;
+ MonoReflectionType *ret;
MonoClass *klass, *pklass;
klass = mono_class_from_mono_type (type->type);
pklass = mono_ptr_class_get (type->type);
- return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
+ ret = mono_type_get_object_checked (mono_object_domain (type), &pklass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
ICALL_EXPORT MonoObject *
ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
{
+ MonoError error;
MonoClass *delegate_class = mono_class_from_mono_type (type->type);
MonoObject *delegate;
gpointer func;
return NULL;
}
- delegate = mono_object_new (mono_object_domain (type), delegate_class);
+ delegate = mono_object_new_checked (mono_object_domain (type), delegate_class, &error);
+ mono_error_raise_exception (&error);
if (method_is_dynamic (method)) {
/* Creating a trampoline would leak memory */
ICALL_EXPORT MonoMulticastDelegate *
ves_icall_System_Delegate_AllocDelegateLike_internal (MonoDelegate *delegate)
{
+ MonoError error;
MonoMulticastDelegate *ret;
g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class));
- ret = (MonoMulticastDelegate*) mono_object_new (mono_object_domain (delegate), mono_object_class (delegate));
+ ret = (MonoMulticastDelegate*) mono_object_new_checked (mono_object_domain (delegate), mono_object_class (delegate), &error);
+ mono_error_raise_exception (&error);
ret->delegate.invoke_impl = mono_runtime_create_delegate_trampoline (mono_object_class (delegate));
return ret;
ICALL_EXPORT MonoReflectionMethod*
ves_icall_System_Delegate_GetVirtualMethod_internal (MonoDelegate *delegate)
{
- return mono_method_get_object (mono_domain_get (), mono_object_get_virtual_method (delegate->target, delegate->method), mono_object_class (delegate->target));
+ 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);
+ mono_error_raise_exception (&error);
+ return ret;
}
/* System.Buffer */
ICALL_EXPORT MonoObject *
ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoString *class_name)
{
+ MonoError error;
MonoDomain *domain = mono_object_domain (this_obj);
MonoObject *res;
MonoRealProxy *rp = ((MonoRealProxy *)this_obj);
MonoType *type;
MonoClass *klass;
- res = mono_object_new (domain, mono_defaults.transparent_proxy_class);
+ res = mono_object_new_checked (domain, mono_defaults.transparent_proxy_class, &error);
+ mono_error_raise_exception (&error);
tp = (MonoTransparentProxy*) res;
MONO_OBJECT_SETREF (tp, rp, rp);
// mono_remote_class_vtable cannot handle errors well, so force any loading error to occur early
mono_class_setup_vtable (klass);
- if (klass->exception_type)
- mono_raise_exception (mono_class_get_exception_for_failure (klass));
+ if (klass->exception_type) {
+ mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
+ return NULL;
+ }
tp->custom_type_info = (mono_object_isinst (this_obj, mono_defaults.iremotingtypeinfo_class) != NULL);
tp->remote_class = mono_remote_class (domain, class_name, klass);
ICALL_EXPORT MonoReflectionType *
ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
{
- return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg);
+ MonoError error;
+ MonoReflectionType *ret = mono_type_get_object_checked (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ return ret;
}
#endif
buf = g_new (gunichar2, len);
result = NULL;
- if (GetComputerName (buf, (PDWORD) &len))
- result = mono_string_new_utf16 (mono_domain_get (), buf, len);
+ if (GetComputerName (buf, (PDWORD) &len)) {
+ MonoError error;
+ result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error);
+ mono_error_raise_exception (&error);
+ }
g_free (buf);
return result;
if (*env_string != '=') {
equal_str = wcschr(env_string, '=');
g_assert(equal_str);
- str = mono_string_new_utf16 (domain, env_string, equal_str-env_string);
+ MonoError error;
+ str = mono_string_new_utf16_checked (domain, env_string, equal_str-env_string, &error);
+ mono_error_raise_exception (&error);
mono_array_setref (names, n, str);
n++;
}
utf8_value = mono_string_to_utf8_checked (value, &error);
if (!mono_error_ok (&error)) {
g_free (utf8_name);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
+ return;
}
g_setenv (utf8_name, utf8_value, TRUE);
int len = 0;
while (path [len])
++ len;
- return mono_string_new_utf16 (mono_domain_get (), path, len);
+ MonoError error;
+ MonoString *res = mono_string_new_utf16_checked (mono_domain_get (), path, len, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
#else
g_warning ("ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetLogicalDrives (void)
{
+ MonoError error;
gunichar2 buf [256], *ptr, *dname;
gunichar2 *u16;
guint initial_size = 127, size = 128;
len = 0;
u16 = dname;
while (*u16) { u16++; len ++; }
- drivestr = mono_string_new_utf16 (domain, dname, len);
+ drivestr = mono_string_new_utf16_checked (domain, dname, len, &error);
+ mono_error_raise_exception (&error);
mono_array_setref (result, ndrives++, drivestr);
while (*dname++);
} while (*dname);
ves_icall_Remoting_RemotingServices_GetVirtualMethod (
MonoReflectionType *rtype, MonoReflectionMethod *rmethod)
{
+ MonoReflectionMethod *ret = NULL;
+ MonoError error;
+
MonoClass *klass;
MonoMethod *method;
MonoMethod **vtable;
if (!res)
return NULL;
- return mono_method_get_object (mono_domain_get (), res, NULL);
+ ret = mono_method_get_object_checked (mono_domain_get (), res, NULL, &error);
+ mono_error_raise_exception (&error);
+ return ret;
}
ICALL_EXPORT void
ICALL_EXPORT MonoObject *
ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType *type)
{
+ MonoError error;
MonoClass *klass;
MonoDomain *domain;
+ MonoObject *ret;
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
return (MonoObject *) mono_array_new (domain, klass->element_class, 0);
} else {
/* Bypass remoting object creation check */
- return mono_object_new_alloc_specific (mono_class_vtable_full (domain, klass, TRUE));
+ ret = mono_object_new_alloc_specific_checked (mono_class_vtable_full (domain, klass, TRUE), &error);
+ mono_error_set_pending_exception (&error);
+
+ return ret;
}
}
ICALL_EXPORT MonoObject *
ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
{
+ MonoError error;
+ MonoObject *result;
MonoClass *klass;
MonoDomain *domain;
/* No arguments -> null */
return NULL;
- return mono_object_new (domain, klass);
+ result = mono_object_new_checked (domain, klass, &error);
+ mono_error_raise_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionMethod *
ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definition)
{
+ MonoReflectionMethod *ret = NULL;
+ MonoError error;
+
MonoClass *klass, *parent;
MonoGenericContext *generic_inst = NULL;
MonoMethod *method = m->method;
if (mono_class_is_open_constructed_type (mono_class_get_type (parent))) {
MonoError error;
parent = mono_class_inflate_generic_class_checked (parent, generic_inst, &error);
- mono_error_raise_exception(&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
}
if (parent->generic_class) {
parent_inst = mono_class_get_context (parent);
if (!klass)
return m;
if (mono_class_is_open_constructed_type (mono_class_get_type (klass))) {
- MonoError error;
klass = mono_class_inflate_generic_class_checked (klass, generic_inst, &error);
- mono_error_raise_exception(&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
generic_inst = NULL;
}
}
if (generic_inst) {
- MonoError error;
klass = mono_class_inflate_generic_class_checked (klass, generic_inst, &error);
- mono_error_raise_exception(&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
}
if (klass == method->klass)
if (result == NULL)
return m;
- return mono_method_get_object (mono_domain_get (), result, NULL);
+ ret = mono_method_get_object_checked (mono_domain_get (), result, NULL, &error);
+ mono_error_raise_exception (&error);
+ return ret;
}
ICALL_EXPORT MonoString*
static MonoArray*
type_array_from_modifiers (MonoImage *image, MonoType *type, int optional)
{
+ MonoError error;
+ MonoReflectionType *rt;
MonoArray *res;
int i, count = 0;
for (i = 0; i < type->num_mods; ++i) {
count = 0;
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
- MonoError error;
MonoClass *klass = mono_class_get_checked (image, type->modifiers [i].token, &error);
mono_error_raise_exception (&error); /* this is safe, no cleanup needed on callers */
- mono_array_setref (res, count, mono_type_get_object (mono_domain_get (), &klass->byval_arg));
+
+ rt = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, &error);
+ mono_error_raise_exception (&error);
+
+ mono_array_setref (res, count, rt);
count++;
}
}
mono_class_init_or_throw (attr_class);
res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
- mono_error_raise_exception (&error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (mono_loader_get_last_error ()) {
mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
}
}
+ICALL_EXPORT MonoArray*
+ves_icall_MonoCustomAttrs_GetCustomAttributesDataInternal (MonoObject *obj)
+{
+ MonoError error;
+ MonoArray *result;
+ result = mono_reflection_get_custom_attrs_data_checked (obj, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
+
ICALL_EXPORT MonoString*
ves_icall_Mono_Runtime_GetDisplayName (void)
{
ICALL_EXPORT MonoString*
ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
+ MonoError error;
MonoString *message;
guint32 ret;
gunichar2 buf[256];
if (ret == 0) {
message = mono_string_new (mono_domain_get (), "Error looking up error string");
} else {
- message = mono_string_new_utf16 (mono_domain_get (), buf, ret);
+ message = mono_string_new_utf16_checked (mono_domain_get (), buf, ret, &error);
+ mono_error_raise_exception (&error);
}
return message;
mono_os_mutex_destroy (&icall_mutex);
}
+/**
+ * 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
+ *
+ * This method surfaces the C function pointed by @method as a method
+ * that has been surfaced in managed code with the method specified in
+ * @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.
+ *
+ * You must provide a fully qualified type name, that is namespaces
+ * and type name, followed by a colon and the method name, with an
+ * optional signature to bind.
+ *
+ * For example, the following are all valid declarations:
+ *
+ * "MyApp.Services.ScriptService:Accelerate"
+ * "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
+ * different than the way that strings are surfaced in P/Invoke.
+ *
+ * For more information on how the parameters are marshalled, see the
+ * <a href="http://www.mono-project.com/docs/advanced/embedding/">Mono Embedding</a>
+ * page.
+ *
+ * See the <a href="mono-api-methods.html#method-desc">Method Description</a>
+ * reference for more information on the format of method descriptions.
+ */
void
mono_add_internal_call (const char *name, gconstpointer method)
{
projects / mono.git / blobdiff