X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Ficall.c;h=5f9cabfc9e8d4a39ef68a917a57c7a06a64c5b23;hb=07b2a10491496316c18a442effd4484c2dadc85d;hp=9e5304375ff2c14219c47cdbd9bad64280a503f2;hpb=c85824fde3ae1e82fdbde6f7eae5dd71f3957942;p=mono.git diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index 9e5304375ff..5f9cabfc9e8 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -565,7 +565,8 @@ ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray * klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + 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 */ @@ -616,7 +617,8 @@ ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint64, 0) != 0)) /* vectors are not the same as one dimensional arrays with no-zero bounds */ @@ -711,6 +713,15 @@ ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length) 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) { @@ -1049,7 +1060,10 @@ ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this_obj, MonoArray if (values) { int i; - mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count)); + MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error); + if (mono_error_set_pending_exception (&error)) + return 0; + mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr); for (i = 0; i < count; ++i) mono_array_setref (*fields, i, values [i]); } else { @@ -1168,7 +1182,10 @@ ves_icall_System_ValueType_Equals (MonoObject *this_obj, MonoObject *that, MonoA if (values) { int i; - mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count)); + MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error); + if (mono_error_set_pending_exception (&error)) + return FALSE; + mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr); for (i = 0; i < count; ++i) mono_array_setref_fast (*fields, i, values [i]); return FALSE; @@ -1189,18 +1206,10 @@ ves_icall_System_Object_GetType (MonoObject *obj) #endif ret = mono_type_get_object_checked (mono_object_domain (obj), &obj->vtable->klass->byval_arg, &error); - mono_error_raise_exception (&error); - + mono_error_set_pending_exception (&error); return ret; } -ICALL_EXPORT void -ves_icall_MonoType_type_from_obj (MonoReflectionType *mtype, MonoObject *obj) -{ - mtype->type = &obj->vtable->klass->byval_arg; - g_assert (mtype->type->type); -} - ICALL_EXPORT gint32 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance) { @@ -1208,7 +1217,7 @@ ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *o MonoError error; gint32 result = mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return result; } @@ -1222,7 +1231,7 @@ ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb, MonoError error; gint32 result = mono_image_create_method_token ( mb->dynamic_image, (MonoObject *) method, opt_param_types, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return result; } @@ -1231,15 +1240,15 @@ ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE fil { MonoError error; mono_image_create_pefile (mb, file, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); } ICALL_EXPORT void ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb) { MonoError error; - if (!mono_image_build_metadata (mb, &error)) - mono_error_raise_exception (&error); + mono_image_build_metadata (mb, &error); + mono_error_set_pending_exception (&error); } ICALL_EXPORT void @@ -1269,6 +1278,22 @@ ves_icall_System_Reflection_Emit_AssemblyBuilder_InternalAddModule (MonoReflecti return result; } +/** + * ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class: + * @tb: a TypeBuilder object + * + * (icall) + * Creates the generic class after all generic parameters have been added. + */ +ICALL_EXPORT void +ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class (MonoReflectionTypeBuilder *tb) +{ + MonoError error; + (void) mono_reflection_create_generic_class (tb, &error); + mono_error_set_pending_exception (&error); +} + +#ifndef DISABLE_REFLECTION_EMIT ICALL_EXPORT MonoArray* ves_icall_System_Reflection_Emit_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues) { @@ -1277,9 +1302,10 @@ ves_icall_System_Reflection_Emit_CustomAttributeBuilder_GetBlob (MonoReflectionA mono_error_set_pending_exception (&error); return result; } +#endif static gboolean -get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) +get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { MonoMethod **dest = (MonoMethod **)data; @@ -1287,11 +1313,9 @@ get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer dat if (!managed) return FALSE; - if (m == *dest) { - *dest = NULL; - return FALSE; - } if (!(*dest)) { + if (!strcmp (m->klass->name_space, "System.Reflection")) + return FALSE; *dest = m; return TRUE; } @@ -1299,7 +1323,7 @@ get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer dat } static gboolean -get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) +get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { MonoMethod **dest = (MonoMethod **)data; @@ -1307,9 +1331,18 @@ get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer if (!managed) return FALSE; + if (m->wrapper_type != MONO_WRAPPER_NONE) + return FALSE; + + if (m == *dest) { + *dest = NULL; + return FALSE; + } + + if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection")) + return FALSE; + if (!(*dest)) { - if (!strcmp (m->klass->name_space, "System.Reflection")) - return FALSE; *dest = m; return TRUE; } @@ -1317,7 +1350,7 @@ get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer } static gboolean -get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) +get_caller_no_system_or_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { MonoMethod **dest = (MonoMethod **)data; @@ -1328,13 +1361,15 @@ get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed if (m->wrapper_type != MONO_WRAPPER_NONE) return FALSE; - if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection")) - return FALSE; - if (m == *dest) { *dest = NULL; return FALSE; } + + if (m->klass->image == mono_defaults.corlib && ((!strcmp (m->klass->name_space, "System.Reflection")) + || (!strcmp (m->klass->name_space, "System")))) + return FALSE; + if (!(*dest)) { *dest = m; return TRUE; @@ -1350,6 +1385,7 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoErro MonoType *type = NULL; MonoAssembly *assembly = NULL; gboolean type_resolve = FALSE; + MonoImage *rootimage = NULL; mono_error_init (error); @@ -1360,10 +1396,23 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoErro */ m = mono_method_get_last_managed (); dest = m; - - mono_stack_walk_no_il (get_caller_no_reflection, &dest); - if (!dest) - dest = m; + if (m && m->klass->image != mono_defaults.corlib) { + /* Happens with inlining */ + } else { + /* Ugly hack: type_from_parsed_name is called from + * System.Type.internal_from_name, which is called most + * directly from System.Type.GetType(string,bool,bool) but + * also indirectly from places such as + * System.Type.GetType(string,func,func) (via + * System.TypeNameParser.GetType and System.TypeSpec.Resolve) + * so we need to skip over all of those to find the true caller. + * + * It would be nice if we had stack marks. + */ + mono_stack_walk_no_il (get_caller_no_system_or_reflection, &dest); + if (!dest) + dest = m; + } /* * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus @@ -1376,6 +1425,7 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoErro if (dest) { assembly = dest->klass->image->assembly; type_resolve = TRUE; + rootimage = assembly->image; } else { g_warning (G_STRLOC); } @@ -1383,21 +1433,28 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoErro if (info->assembly.name) assembly = mono_assembly_load (&info->assembly, assembly ? assembly->basedir : NULL, NULL); - if (assembly) { /* When loading from the current assembly, AppDomain.TypeResolve will not be called yet */ - type = mono_reflection_get_type_checked (assembly->image, info, ignoreCase, &type_resolve, error); + type = mono_reflection_get_type_checked (rootimage, assembly->image, info, ignoreCase, &type_resolve, error); return_val_if_nok (error, NULL); } + // XXXX - aleksey - + // Say we're looking for System.Generic.Dict + // we FAIL the get type above, because S.G.Dict isn't in assembly->image. So we drop down here. + // but then we FAIL AGAIN because now we pass null as the image and the rootimage and everything + // is messed up when we go to construct the Local as the type arg... + // + // By contrast, if we started with Mine> we'd go in with assembly->image + // as the root and then even the detour into generics would still not screw us when we went to load Local. if (!info->assembly.name && !type) { /* try mscorlib */ - type = mono_reflection_get_type_checked (NULL, info, ignoreCase, &type_resolve, error); + type = mono_reflection_get_type_checked (rootimage, NULL, info, ignoreCase, &type_resolve, error); return_val_if_nok (error, NULL); } if (assembly && !type && type_resolve) { type_resolve = FALSE; /* This will invoke TypeResolve if not done in the first 'if' */ - type = mono_reflection_get_type_checked (assembly->image, info, ignoreCase, &type_resolve, error); + type = mono_reflection_get_type_checked (rootimage, assembly->image, info, ignoreCase, &type_resolve, error); return_val_if_nok (error, NULL); } @@ -1413,29 +1470,41 @@ ves_icall_System_Type_internal_from_name (MonoString *name, MonoBoolean ignoreCase) { MonoError error; - char *str = mono_string_to_utf8 (name); MonoTypeNameParse info; - MonoReflectionType *type; + MonoReflectionType *type = NULL; gboolean parsedOk; + char *str = mono_string_to_utf8_checked (name, &error); + if (!is_ok (&error)) + goto leave; + parsedOk = mono_reflection_parse_type (str, &info); /* mono_reflection_parse_type() mangles the string */ if (!parsedOk) { mono_reflection_free_type_info (&info); - g_free (str); - if (throwOnError) { - mono_set_pending_exception (mono_get_exception_argument("typeName", "failed parse")); - } - return NULL; + if (throwOnError) + mono_error_set_argument (&error, "typeName", "failed parse: %s", str); + goto leave; } type = type_from_parsed_name (&info, ignoreCase, &error); mono_reflection_free_type_info (&info); - g_free (str); - if (!mono_error_ok (&error)) { + if (!is_ok (&error)) + goto leave; + + if (type == NULL){ + if (throwOnError) { + mono_error_set_type_load_name (&error, g_strdup (str), NULL, ""); + goto leave; + } + } + +leave: + g_free (str); + if (!is_ok (&error)) { if (throwOnError) mono_error_set_pending_exception (&error); else @@ -1443,19 +1512,6 @@ ves_icall_System_Type_internal_from_name (MonoString *name, return NULL; } - if (type == NULL){ - MonoException *e = NULL; - - if (throwOnError) - e = mono_get_exception_type_load (name, NULL); - - mono_loader_clear_error (); - if (e) { - mono_set_pending_exception (e); - return NULL; - } - } - return type; } @@ -1468,7 +1524,7 @@ ves_icall_System_Type_internal_from_handle (MonoType *handle) MonoDomain *domain = mono_domain_get (); ret = mono_type_get_object_checked (domain, handle, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -1720,7 +1776,7 @@ ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField } MonoReflectionField *result = mono_field_get_object_checked (mono_domain_get (), klass, handle, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return result; } @@ -1737,7 +1793,7 @@ ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *fie } res = type_array_from_modifiers (field->field->parent->image, type, optional, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return res; } @@ -1850,7 +1906,7 @@ ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean decla parent = declaring? field->field->parent: field->klass; ret = mono_type_get_object_checked (mono_object_domain (field), &parent->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; @@ -2087,12 +2143,16 @@ ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *rfield) return NULL; } v = ((gchar *) o) + sizeof (MonoObject); - mono_get_constant_value_from_blob (domain, def_type, def_value, v); + mono_get_constant_value_from_blob (domain, def_type, def_value, v, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; break; } case MONO_TYPE_STRING: case MONO_TYPE_CLASS: - mono_get_constant_value_from_blob (domain, def_type, def_value, &o); + mono_get_constant_value_from_blob (domain, def_type, def_value, &o, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; break; default: g_assert_not_reached (); @@ -2144,13 +2204,15 @@ ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *prop if ((req_info & PInfo_ReflectedType) != 0) { rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; 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); + if (mono_error_set_pending_exception (&error)) + return; MONO_STRUCT_SETREF (info, declaring_type, rt); } @@ -2166,7 +2228,8 @@ ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *prop (((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); + if (mono_error_set_pending_exception (&error)) + return; } else { rm = NULL; } @@ -2178,7 +2241,8 @@ ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *prop (((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); + if (mono_error_set_pending_exception (&error)) + return; } else { rm = NULL; } @@ -2200,12 +2264,14 @@ ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEven MonoDomain *domain = mono_object_domain (event); rt = mono_type_get_object_checked (domain, &event->klass->byval_arg, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; 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); + if (mono_error_set_pending_exception (&error)) + return; MONO_STRUCT_SETREF (info, declaring_type, rt); @@ -2214,7 +2280,8 @@ ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEven if (event->event->add) { rm = mono_method_get_object_checked (domain, event->event->add, NULL, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; } else { rm = NULL; } @@ -2223,7 +2290,8 @@ ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEven if (event->event->remove) { rm = mono_method_get_object_checked (domain, event->event->remove, NULL, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; } else { rm = NULL; } @@ -2232,7 +2300,8 @@ ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEven if (event->event->raise) { rm = mono_method_get_object_checked (domain, event->event->raise, NULL, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; } else { rm = NULL; } @@ -2244,11 +2313,15 @@ ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEven int i, n = 0; while (event->event->other [n]) n++; - MONO_STRUCT_SETREF (info, other_methods, mono_array_new (domain, mono_defaults.method_info_class, n)); + MonoArray *info_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, n, &error); + if (mono_error_set_pending_exception (&error)) + return; + MONO_STRUCT_SETREF (info, other_methods, info_arr); for (i = 0; i < n; i++) { rm = mono_method_get_object_checked (domain, event->event->other [i], NULL, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; mono_array_setref (info->other_methods, i, rm); } } @@ -2319,7 +2392,7 @@ get_interfaces_hash (gconstpointer v1) } ICALL_EXPORT MonoArray* -ves_icall_Type_GetInterfaces (MonoReflectionType* type) +ves_icall_RuntimeType_GetInterfaces (MonoReflectionType* type) { MonoError error; MonoClass *klass = mono_class_from_mono_type (type->type); @@ -2349,12 +2422,17 @@ ves_icall_Type_GetInterfaces (MonoReflectionType* type) len = g_hash_table_size (iface_hash); if (len == 0) { g_hash_table_destroy (iface_hash); - if (!data.domain->empty_types) - data.domain->empty_types = mono_array_new_cached (data.domain, mono_defaults.monotype_class, 0); + if (!data.domain->empty_types) { + data.domain->empty_types = mono_array_new_cached (data.domain, mono_defaults.runtimetype_class, 0, &error); + if (!is_ok (&error)) + goto fail; + } return data.domain->empty_types; } - data.iface_array = mono_array_new_cached (data.domain, mono_defaults.monotype_class, len); + data.iface_array = mono_array_new_cached (data.domain, mono_defaults.runtimetype_class, len, &error); + if (!is_ok (&error)) + goto fail; g_hash_table_foreach (iface_hash, fill_iface_array, &data); if (!mono_error_ok (&error)) goto fail; @@ -2369,7 +2447,7 @@ fail: } ICALL_EXPORT void -ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods) +ves_icall_RuntimeType_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods) { gboolean variance_used; MonoClass *klass = mono_class_from_mono_type (type->type); @@ -2382,9 +2460,11 @@ ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType MonoError error; mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; mono_class_init_checked (iclass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; mono_class_setup_vtable (klass); @@ -2394,15 +2474,23 @@ ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType len = mono_class_num_methods (iclass); domain = mono_object_domain (type); - mono_gc_wbarrier_generic_store (targets, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len)); - mono_gc_wbarrier_generic_store (methods, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len)); + MonoArray *targets_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error); + if (mono_error_set_pending_exception (&error)) + return; + mono_gc_wbarrier_generic_store (targets, (MonoObject*) targets_arr); + MonoArray *methods_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error); + if (mono_error_set_pending_exception (&error)) + return; + mono_gc_wbarrier_generic_store (methods, (MonoObject*) methods_arr); iter = NULL; while ((method = mono_class_get_methods (iclass, &iter))) { member = mono_method_get_object_checked (domain, method, iclass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; mono_array_setref (*methods, i, member); member = mono_method_get_object_checked (domain, klass->vtable [i + ioffset], klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; mono_array_setref (*targets, i, member); i ++; @@ -2410,13 +2498,14 @@ ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType } ICALL_EXPORT void -ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size) +ves_icall_RuntimeType_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size) { MonoError error; MonoClass *klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; if (image_is_dynamic (klass->image)) { MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)type; @@ -2436,14 +2525,15 @@ ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionType *type) 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); - + mono_error_set_pending_exception (&error); return ret; } klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + // GetElementType should only return a type for: // Array Pointer PassedByRef @@ -2456,7 +2546,7 @@ ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionType *type) else return NULL; - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -2475,7 +2565,7 @@ ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionType *type) return NULL; ret = mono_type_get_object_checked (mono_object_domain (type), &klass->parent->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -2504,7 +2594,8 @@ ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionType *type) MonoError error; MonoClass *klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return FALSE; return mono_class_is_com_object (klass); } @@ -2525,8 +2616,7 @@ ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionType *type) MonoReflectionModule *result = NULL; MonoClass *klass = mono_class_from_mono_type (type->type); result = mono_module_get_object_checked (mono_object_domain (type), klass->image, &error); - if (!mono_error_ok (&error)) - mono_error_set_pending_exception (&error); + mono_error_set_pending_exception (&error); return result; } @@ -2537,13 +2627,12 @@ ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionType *type) MonoDomain *domain = mono_domain_get (); MonoClass *klass = mono_class_from_mono_type (type->type); MonoReflectionAssembly *result = mono_assembly_get_object_checked (domain, klass->image->assembly, &error); - if (!result) - mono_error_set_pending_exception (&error); + mono_error_set_pending_exception (&error); return result; } ICALL_EXPORT MonoReflectionType* -ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type) +ves_icall_RuntimeType_get_DeclaringType (MonoReflectionType *type) { MonoError error; MonoReflectionType *ret; @@ -2566,13 +2655,13 @@ ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type) return NULL; ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } ICALL_EXPORT MonoString* -ves_icall_MonoType_get_Name (MonoReflectionType *type) +ves_icall_RuntimeType_get_Name (MonoReflectionType *type) { MonoDomain *domain = mono_domain_get (); MonoClass *klass = mono_class_from_mono_type (type->type); @@ -2590,7 +2679,7 @@ ves_icall_MonoType_get_Name (MonoReflectionType *type) } ICALL_EXPORT MonoString* -ves_icall_MonoType_get_Namespace (MonoReflectionType *type) +ves_icall_RuntimeType_get_Namespace (MonoReflectionType *type) { MonoDomain *domain = mono_domain_get (); MonoClass *klass = mono_class_from_mono_type (type->type); @@ -2620,15 +2709,13 @@ ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionType *type) } static MonoArray* -create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count) +create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count, MonoError *error) { - MonoArray *res; - res = mono_array_new (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count); - return res; + return mono_array_new_checked (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count, error); } ICALL_EXPORT MonoArray* -ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray) +ves_icall_RuntimeType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray) { MonoError error; MonoReflectionType *rt; @@ -2641,21 +2728,27 @@ ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean ru if (klass->generic_container) { MonoGenericContainer *container = klass->generic_container; - res = create_type_array (domain, runtimeTypeArray, container->type_argc); + res = create_type_array (domain, runtimeTypeArray, container->type_argc, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; for (i = 0; i < container->type_argc; ++i) { pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i)); rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; 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); + res = create_type_array (domain, runtimeTypeArray, inst->type_argc, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; 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); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, i, rt); } @@ -2705,7 +2798,7 @@ ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionType *t return (MonoReflectionType *)tb; else { ret = mono_type_get_object_checked (mono_object_domain (type), &generic_class->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -2714,7 +2807,7 @@ ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionType *t } ICALL_EXPORT MonoReflectionType* -ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array) +ves_icall_RuntimeType_MakeGenericType (MonoReflectionType *type, MonoArray *type_array) { MonoError error; MonoReflectionType *ret; @@ -2724,7 +2817,8 @@ ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array) g_assert (IS_MONOTYPE (type)); mono_class_init_checked (mono_class_from_mono_type (type->type), &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; count = mono_array_length (type_array); types = g_new0 (MonoType *, count); @@ -2750,7 +2844,7 @@ ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array) } ret = mono_type_get_object_checked (mono_object_domain (type), geninst, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -2771,7 +2865,7 @@ ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionType *type) } ICALL_EXPORT gint32 -ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type) +ves_icall_RuntimeType_GetGenericParameterPosition (MonoReflectionType *type) { if (!IS_MONOTYPE (type)) return -1; @@ -2782,7 +2876,7 @@ ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type) } ICALL_EXPORT GenericParameterAttributes -ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type) +ves_icall_RuntimeType_GetGenericParameterAttributes (MonoReflectionType *type) { g_assert (IS_MONOTYPE (type)); g_assert (is_generic_parameter (type->type)); @@ -2790,7 +2884,7 @@ ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type) } ICALL_EXPORT MonoArray * -ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type) +ves_icall_RuntimeType_GetGenericParameterConstraints (MonoReflectionType *type) { MonoError error; MonoReflectionType *rt; @@ -2807,10 +2901,13 @@ ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type) for (count = 0, ptr = param_info->constraints; ptr && *ptr; ptr++, count++) ; - res = mono_array_new (domain, mono_defaults.monotype_class, count); + res = mono_array_new_checked (domain, mono_defaults.runtimetype_class, count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; 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); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, i, rt); } @@ -2839,7 +2936,7 @@ ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype, } ICALL_EXPORT MonoReflectionMethod* -ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type, +ves_icall_RuntimeType_GetCorrespondingInflatedMethod (MonoReflectionType *type, MonoReflectionMethod* generic) { MonoDomain *domain; @@ -2853,13 +2950,15 @@ ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type, klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (method->token == generic->method->token) { ret = mono_method_get_object_checked (domain, method, klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; } } @@ -2867,7 +2966,7 @@ ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type, } ICALL_EXPORT MonoReflectionMethod * -ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type) +ves_icall_RuntimeType_get_DeclaringMethod (MonoReflectionType *ref_type) { MonoMethod *method; MonoType *type = ref_type->type; @@ -3029,11 +3128,14 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method) if (inst) { count = inst->type_argc; - res = mono_array_new (domain, mono_defaults.systemtype_class, count); + res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; for (i = 0; i < count; i++) { rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, i, rt); } @@ -3043,7 +3145,9 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method) } count = mono_method_signature (method->method)->generic_param_count; - res = mono_array_new (domain, mono_defaults.systemtype_class, count); + res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; for (i = 0; i < count; i++) { MonoGenericContainer *container = mono_method_get_generic_container (method->method); @@ -3051,7 +3155,8 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method) MonoClass *pklass = mono_class_from_generic_parameter_internal (param); rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, i, rt); } @@ -3199,7 +3304,9 @@ ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this_arg, Mo return (MonoObject*)arr; } } - return mono_runtime_invoke_array (m, obj, params, NULL); + MonoObject *result = mono_runtime_invoke_array_checked (m, obj, params, &error); + mono_error_set_pending_exception (&error); + return result; } #ifndef DISABLE_REMOTING @@ -3229,23 +3336,27 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, M } name = mono_array_get (params, MonoString *, 1); - str = mono_string_to_utf8 (name); + str = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; do { MonoClassField* field = mono_class_get_field_from_name (k, str); if (field) { + g_free (str); MonoClass *field_klass = mono_class_from_mono_type (field->type); if (field_klass->valuetype) { result = mono_value_box_checked (domain, field_klass, (char *)this_arg + field->offset, &error); - mono_error_set_pending_exception (&error); - /* fallthru to cleanup */ + if (mono_error_set_pending_exception (&error)) + return NULL; } else result = (MonoObject *)*((gpointer *)((char *)this_arg + field->offset)); - out_args = mono_array_new (domain, mono_defaults.object_class, 1); + out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args); mono_array_setref (out_args, 0, result); - g_free (str); return NULL; } k = k->parent; @@ -3270,11 +3381,14 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, M } name = mono_array_get (params, MonoString *, 1); - str = mono_string_to_utf8 (name); + str = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; do { MonoClassField* field = mono_class_get_field_from_name (k, str); if (field) { + g_free (str); MonoClass *field_klass = mono_class_from_mono_type (field->type); MonoObject *val = (MonoObject *)mono_array_get (params, gpointer, 2); @@ -3286,10 +3400,11 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, M mono_gc_wbarrier_set_field (this_arg, (char*)this_arg + field->offset, val); } - out_args = mono_array_new (domain, mono_defaults.object_class, 0); + out_args = mono_array_new_checked (domain, mono_defaults.object_class, 0, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args); - g_free (str); return NULL; } @@ -3307,15 +3422,19 @@ ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, M outarg_count++; } - out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count); - + out_args = mono_array_new_checked (domain, mono_defaults.object_class, outarg_count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + /* handle constructors only for objects already allocated */ if (!strcmp (method->method->name, ".ctor")) g_assert (this_arg); /* This can be called only on MBR objects, so no need to unbox for valuetypes. */ g_assert (!method->method->klass->valuetype); - result = mono_runtime_invoke_array (method->method, this_arg, params, NULL); + result = mono_runtime_invoke_array_checked (method->method, this_arg, params, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; for (i = 0, j = 0; i < mono_array_length (params); i++) { if (sig->params [i]->byref) { @@ -3370,7 +3489,8 @@ write_enum_value (char *mem, int type, guint64 value) break; } case MONO_TYPE_U2: - case MONO_TYPE_I2: { + case MONO_TYPE_I2: + case MONO_TYPE_CHAR: { guint16 *p = (guint16 *)mem; *p = value; break; @@ -3406,12 +3526,14 @@ ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, guint64 value) enumc = mono_class_from_mono_type (enumType->type); mono_class_init_checked (enumc, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; etype = mono_class_enum_basetype (enumc); res = mono_object_new_checked (domain, enumc, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; write_enum_value ((char *)res + sizeof (MonoObject), etype->type, value); return res; @@ -3446,7 +3568,8 @@ ves_icall_System_Enum_get_value (MonoObject *eobj) enumc = mono_class_from_mono_type (mono_class_enum_basetype (eobj->vtable->klass)); res = mono_object_new_checked (mono_object_domain (eobj), enumc, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; dst = (char *)res + sizeof (MonoObject); src = (char *)eobj + sizeof (MonoObject); size = mono_class_value_size (enumc, NULL); @@ -3466,7 +3589,8 @@ ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type) klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; etype = mono_class_enum_basetype (klass); if (!etype) { @@ -3475,7 +3599,7 @@ ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type) } ret = mono_type_get_object_checked (mono_object_domain (type), etype, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -3579,7 +3703,9 @@ ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionType *type, MonoArray gboolean sorted = TRUE; mono_class_init_checked (enumc, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return FALSE; + if (!enumc->enumtype) { mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum.")); @@ -3589,8 +3715,12 @@ ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionType *type, MonoArray base_type = mono_class_enum_basetype (enumc)->type; nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0; - *names = mono_array_new (domain, mono_defaults.string_class, nvalues); - *values = mono_array_new (domain, mono_defaults.uint64_class, nvalues); + *names = mono_array_new_checked (domain, mono_defaults.string_class, nvalues, &error); + if (mono_error_set_pending_exception (&error)) + return FALSE; + *values = mono_array_new_checked (domain, mono_defaults.uint64_class, nvalues, &error); + if (mono_error_set_pending_exception (&error)) + return FALSE; iter = NULL; while ((field = mono_class_get_fields (enumc, &iter))) { @@ -3641,7 +3771,7 @@ enum { }; ICALL_EXPORT MonoArray* -ves_icall_Type_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype) +ves_icall_RuntimeType_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype) { MonoError error; MonoDomain *domain; @@ -3656,8 +3786,11 @@ ves_icall_Type_GetFields_internal (MonoReflectionType *type, MonoString *name, g MonoPtrArray tmp_array; domain = ((MonoObject *)type)->vtable->domain; - if (type->type->byref) - return mono_array_new (domain, mono_defaults.field_info_class, 0); + if (type->type->byref) { + MonoArray *result = mono_array_new_checked (domain, mono_defaults.field_info_class, 0, &error); + mono_error_set_pending_exception (&error); + return result; + } klass = startklass = mono_class_from_mono_type (type->type); refklass = mono_class_from_mono_type (reftype->type); @@ -3702,7 +3835,9 @@ handle_parent: if (name != NULL) { if (utf8_name == NULL) { - utf8_name = mono_string_to_utf8 (name); + utf8_name = mono_string_to_utf8_checked (name, &error); + if (!is_ok (&error)) + goto fail; compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; } @@ -3718,7 +3853,9 @@ handle_parent: if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; - res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array)); + res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array), &error); + if (!is_ok (&error)) + goto fail; for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); @@ -3731,8 +3868,8 @@ handle_parent: return res; fail: mono_ptr_array_destroy (tmp_array); - mono_error_raise_exception (&error); - g_assert_not_reached (); + mono_error_set_pending_exception (&error); + return NULL; } static gboolean @@ -3773,8 +3910,7 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla /* An optimization for calls made from Delegate:CreateDelegate () */ if (klass->delegate && name && !strcmp (name, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) { method = mono_get_delegate_invoke (klass); - if (mono_loader_get_last_error ()) - goto loader_error; + g_assert (method); g_ptr_array_add (array, method); return array; @@ -3782,7 +3918,7 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla mono_class_setup_methods (klass); mono_class_setup_vtable (klass); - if (mono_class_has_failure (klass) || mono_loader_get_last_error ()) + if (mono_class_has_failure (klass)) goto loader_error; if (is_generic_parameter (&klass->byval_arg)) @@ -3798,7 +3934,7 @@ mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bfla handle_parent: mono_class_setup_methods (klass); mono_class_setup_vtable (klass); - if (mono_class_has_failure (klass) || mono_loader_get_last_error ()) + if (mono_class_has_failure (klass)) goto loader_error; iter = NULL; @@ -3858,14 +3994,13 @@ loader_error: if (mono_class_has_failure (klass)) { *ex = mono_class_get_exception_for_failure (klass); } else { - *ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ()); - mono_loader_clear_error (); + *ex = mono_get_exception_execution_engine ("Unknown error"); } return NULL; } ICALL_EXPORT MonoArray* -ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype) +ves_icall_RuntimeType_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype) { static MonoClass *MethodInfo_array; MonoError error; @@ -3901,8 +4036,11 @@ ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, gui return res; } - if (name) - mname = mono_string_to_utf8 (name); + if (name) { + mname = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + } method_array = mono_class_get_methods_by_name (klass, mname, bflags, ignore_case, FALSE, &ex); g_free ((char*)mname); @@ -3933,11 +4071,11 @@ failure: } ICALL_EXPORT MonoArray* -ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype) +ves_icall_RuntimeType_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype) { MonoDomain *domain; MonoClass *startklass, *klass, *refklass; - MonoArray *res; + MonoArray *res = NULL; MonoMethod *method; MonoObject *member; int i, match; @@ -3945,18 +4083,23 @@ ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflag MonoPtrArray tmp_array; MonoError error; + domain = ((MonoObject *)type)->vtable->domain; + if (type->type->byref) { + res = mono_array_new_cached (domain, mono_defaults.method_info_class, 0, &error); + mono_error_set_pending_exception (&error); + return res; + } + mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection constructors list"); /*FIXME, guestimating*/ - domain = ((MonoObject *)type)->vtable->domain; - if (type->type->byref) - return mono_array_new_cached (domain, mono_defaults.method_info_class, 0); + klass = startklass = mono_class_from_mono_type (type->type); refklass = mono_class_from_mono_type (reftype->type); mono_class_setup_methods (klass); if (mono_class_has_failure (klass)) { mono_set_pending_exception (mono_class_get_exception_for_failure (klass)); - return NULL; + goto leave; } iter = NULL; @@ -3986,19 +4129,20 @@ ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflag if (!match) continue; member = (MonoObject*)mono_method_get_object_checked (domain, method, refklass, &error); - if (!mono_error_ok (&error)) { - mono_error_set_pending_exception (&error); - return NULL; - } + if (mono_error_set_pending_exception (&error)) + goto leave; mono_ptr_array_append (tmp_array, member); } - res = mono_array_new_cached (domain, mono_class_get_constructor_info_class (), mono_ptr_array_size (tmp_array)); + res = mono_array_new_cached (domain, mono_class_get_constructor_info_class (), mono_ptr_array_size (tmp_array), &error); + if (mono_error_set_pending_exception (&error)) + goto leave; for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); +leave: mono_ptr_array_destroy (tmp_array); return res; @@ -4063,7 +4207,7 @@ property_accessor_nonpublic (MonoMethod* accessor, gboolean start_klass) } ICALL_EXPORT MonoArray* -ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype) +ves_icall_RuntimeType_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype) { MonoError error; MonoDomain *domain; @@ -4081,15 +4225,21 @@ ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, mono_error_init (&error); + domain = ((MonoObject *)type)->vtable->domain; + if (type->type->byref) { + res = mono_array_new_cached (domain, mono_class_get_property_info_class (), 0, &error); + mono_error_set_pending_exception (&error); + return res; + } + mono_ptr_array_init (tmp_array, 8, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection properties list"); /*This the average for ASP.NET types*/ - domain = ((MonoObject *)type)->vtable->domain; - if (type->type->byref) - return mono_array_new_cached (domain, mono_class_get_property_info_class (), 0); klass = startklass = mono_class_from_mono_type (type->type); if (name != NULL) { - propname = mono_string_to_utf8 (name); + propname = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp; } @@ -4097,7 +4247,7 @@ ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, handle_parent: mono_class_setup_methods (klass); mono_class_setup_vtable (klass); - if (mono_class_has_failure (klass) || mono_loader_get_last_error ()) + if (mono_class_has_failure (klass)) goto loader_error; iter = NULL; @@ -4157,7 +4307,9 @@ handle_parent: g_hash_table_destroy (properties); g_free (propname); - res = mono_array_new_cached (domain, mono_class_get_property_info_class (), mono_ptr_array_size (tmp_array)); + res = mono_array_new_cached (domain, mono_class_get_property_info_class (), mono_ptr_array_size (tmp_array), &error); + if (!is_ok (&error)) + goto failure; for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); @@ -4170,8 +4322,6 @@ handle_parent: loader_error: if (mono_class_has_failure (klass)) { mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass)); - } else { - mono_loader_assert_no_error (); } failure: @@ -4202,7 +4352,7 @@ event_equal (MonoEvent *event1, MonoEvent *event2) } ICALL_EXPORT MonoArray* -ves_icall_Type_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype) +ves_icall_RuntimeType_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype) { MonoError error; MonoDomain *domain; @@ -4219,18 +4369,22 @@ ves_icall_Type_GetEvents_internal (MonoReflectionType *type, MonoString *name, g mono_error_init (&error); + domain = mono_object_domain (type); + if (type->type->byref) { + res = mono_array_new_cached (domain, mono_class_get_event_info_class (), 0, &error); + mono_error_set_pending_exception (&error); + return res; + } + mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection events list"); - domain = mono_object_domain (type); - if (type->type->byref) - return mono_array_new_cached (domain, mono_class_get_event_info_class (), 0); klass = startklass = mono_class_from_mono_type (type->type); events = g_hash_table_new (event_hash, (GEqualFunc)event_equal); handle_parent: mono_class_setup_methods (klass); mono_class_setup_vtable (klass); - if (mono_class_has_failure (klass) || mono_loader_get_last_error ()) + if (mono_class_has_failure (klass)) goto loader_error; iter = NULL; @@ -4274,7 +4428,9 @@ handle_parent: if (name != NULL) { if (utf8_name == NULL) { - utf8_name = mono_string_to_utf8 (name); + utf8_name = mono_string_to_utf8_checked (name, &error); + if (!is_ok (&error)) + goto failure; compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; } @@ -4298,7 +4454,9 @@ handle_parent: g_hash_table_destroy (events); - res = mono_array_new_cached (domain, mono_class_get_event_info_class (), mono_ptr_array_size (tmp_array)); + res = mono_array_new_cached (domain, mono_class_get_event_info_class (), mono_ptr_array_size (tmp_array), &error); + if (!is_ok (&error)) + goto failure; for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); @@ -4313,8 +4471,6 @@ handle_parent: loader_error: if (mono_class_has_failure (klass)) { mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass)); - } else { - mono_loader_assert_no_error (); } failure: @@ -4331,22 +4487,27 @@ failure: } ICALL_EXPORT MonoArray* -ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags) +ves_icall_RuntimeType_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags) { MonoError error; MonoReflectionType *rt; MonoDomain *domain; MonoClass *klass; - MonoArray *res; + MonoArray *res = NULL; int i, match; MonoClass *nested; gpointer iter; char *str = NULL; MonoPtrArray tmp_array; + mono_error_init (&error); + domain = ((MonoObject *)type)->vtable->domain; - if (type->type->byref) - return mono_array_new (domain, mono_defaults.monotype_class, 0); + if (type->type->byref) { + MonoArray *result = mono_array_new_cached (domain, mono_defaults.runtimetype_class, 0, &error); + mono_error_set_pending_exception (&error); + return result; + } klass = mono_class_from_mono_type (type->type); /* @@ -4377,7 +4538,9 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint if (name != NULL) { if (str == NULL) { - str = mono_string_to_utf8 (name); + str = mono_string_to_utf8_checked (name, &error); + if (!is_ok (&error)) + goto leave; mono_identifier_unescape_type_name_chars (str); } @@ -4386,20 +4549,25 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint } rt = mono_type_get_object_checked (domain, &nested->byval_arg, &error); - mono_error_raise_exception (&error); + if (!is_ok (&error)) + goto leave; mono_ptr_array_append (tmp_array, (MonoObject*) rt); } - res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array)); + res = mono_array_new_cached (domain, mono_defaults.runtimetype_class, mono_ptr_array_size (tmp_array), &error); + if (!is_ok (&error)) + goto leave; for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); +leave: mono_ptr_array_destroy (tmp_array); g_free (str); + mono_error_set_pending_exception (&error); return res; } @@ -4415,7 +4583,9 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as /* On MS.NET, this does not fire a TypeResolve event */ type_resolve = TRUE; - str = mono_string_to_utf8 (name); + str = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; /*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/ if (!mono_reflection_parse_type (str, &info)) { g_free (str); @@ -4444,7 +4614,7 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (module != NULL) { if (module->image) { - type = mono_reflection_get_type_checked (module->image, &info, ignoreCase, &type_resolve, &error); + type = mono_reflection_get_type_checked (module->image, module->image, &info, ignoreCase, &type_resolve, &error); if (!is_ok (&error)) { g_free (str); mono_reflection_free_type_info (&info); @@ -4464,7 +4634,7 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (abuilder->modules) { for (i = 0; i < mono_array_length (abuilder->modules); ++i) { MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i); - type = mono_reflection_get_type_checked (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve, &error); + type = mono_reflection_get_type_checked (&mb->dynamic_image->image, &mb->dynamic_image->image, &info, ignoreCase, &type_resolve, &error); if (!is_ok (&error)) { g_free (str); mono_reflection_free_type_info (&info); @@ -4479,7 +4649,7 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (!type && abuilder->loaded_modules) { for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) { MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i); - type = mono_reflection_get_type_checked (mod->image, &info, ignoreCase, &type_resolve, &error); + type = mono_reflection_get_type_checked (mod->image, mod->image, &info, ignoreCase, &type_resolve, &error); if (!is_ok (&error)) { g_free (str); mono_reflection_free_type_info (&info); @@ -4492,7 +4662,7 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as } } else { - type = mono_reflection_get_type_checked (assembly->assembly->image, &info, ignoreCase, &type_resolve, &error); + type = mono_reflection_get_type_checked (assembly->assembly->image, assembly->assembly->image, &info, ignoreCase, &type_resolve, &error); if (!is_ok (&error)) { g_free (str); mono_reflection_free_type_info (&info); @@ -4508,20 +4678,9 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (throwOnError) e = mono_get_exception_type_load (name, NULL); - if (mono_loader_get_last_error () && mono_defaults.generic_ilist_class) - e = mono_loader_error_prepare_exception (mono_loader_get_last_error ()); - - mono_loader_clear_error (); - if (e != NULL) mono_set_pending_exception (e); return NULL; - } else if (mono_loader_get_last_error ()) { - if (throwOnError) { - mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); - return NULL; - } - mono_loader_clear_error (); } if (type->type == MONO_TYPE_CLASS) { @@ -4531,7 +4690,6 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as if (throwOnError && mono_class_has_failure (klass)) { /* report SecurityException (or others) that occured when loading the assembly */ MonoException *exc = mono_class_get_exception_for_failure (klass); - mono_loader_clear_error (); mono_set_pending_exception (exc); return NULL; } @@ -4640,7 +4798,9 @@ ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoImageOpenStatus status; MonoReflectionAssembly* result = NULL; - name = mono_string_to_utf8 (mname); + name = mono_string_to_utf8_checked (mname, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; res = mono_assembly_load_with_partial_name (name, &status); g_free (name); @@ -4715,8 +4875,11 @@ ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAs ICALL_EXPORT MonoArray* ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly) { + MonoError error; MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; - MonoArray *result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows); + MonoArray *result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, table->rows, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; int i; const char *val; @@ -4772,7 +4935,10 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF]; count = t->rows; - result = mono_array_new (domain, mono_class_get_assembly_name_class (), count); + result = mono_array_new_checked (domain, mono_class_get_assembly_name_class (), count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + if (count > 0 && !create_culture) { MonoMethodDesc *desc = mono_method_desc_new ( @@ -4791,7 +4957,8 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse aname = (MonoReflectionAssemblyName *) mono_object_new_checked ( domain, mono_class_get_assembly_name_class (), &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]))); @@ -4804,7 +4971,8 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */ version = create_version (domain, aname->major, aname->minor, aname->build, aname->revision, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; MONO_OBJECT_SETREF (aname, version, version); @@ -4815,7 +4983,8 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse args [1] = &assembly_ref; o = mono_runtime_invoke_checked (create_culture, NULL, args, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; MONO_OBJECT_SETREF (aname, cultureInfo, o); } @@ -4827,14 +4996,26 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) { /* public key token isn't copied - the class library will automatically generate it from the public key if required */ - MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len)); - memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len); + MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + + MONO_OBJECT_SETREF (aname, publicKey, pkey); + memcpy (mono_array_addr (pkey, guint8, 0), pkey_ptr, pkey_len); } else { - MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, pkey_len)); - memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len); + MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + + MONO_OBJECT_SETREF (aname, keyToken, keyToken); + memcpy (mono_array_addr (keyToken, guint8, 0), pkey_ptr, pkey_len); } } else { - MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0)); + MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + + MONO_OBJECT_SETREF (aname, keyToken, keyToken); } /* note: this function doesn't return the codebase on purpose (i.e. it can @@ -4866,7 +5047,6 @@ 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; guint32 cols [MONO_MANIFEST_SIZE]; @@ -4874,6 +5054,10 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflection const char *val; MonoImage *module; + char *n = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); @@ -4902,7 +5086,8 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflection MonoReflectionModule *rm = mono_module_get_object_checked (mono_domain_get (), module, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) rm); return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size); @@ -4919,7 +5104,9 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflec const char *val; char *n; - n = mono_string_to_utf8 (name); + n = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return FALSE; for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); @@ -4982,6 +5169,7 @@ ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflec ICALL_EXPORT MonoObject* ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules) { + MonoError error; MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE]; MonoArray *result = NULL; int i, count; @@ -4990,7 +5178,10 @@ ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *a /* check hash if needed */ if (name) { - n = mono_string_to_utf8 (name); + n = mono_string_to_utf8_checked (name, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + for (i = 0; i < table->rows; ++i) { val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME)); if (strcmp (val, n) == 0) { @@ -5012,7 +5203,10 @@ ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *a count ++; } - result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, count); + result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + count = 0; for (i = 0; i < table->rows; ++i) { @@ -5056,16 +5250,21 @@ ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly real_module_count ++; klass = mono_class_get_module_class (); - res = mono_array_new (domain, klass, 1 + real_module_count + file_count); + res = mono_array_new_checked (domain, klass, 1 + real_module_count + file_count, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; MonoReflectionModule *image_obj = mono_module_get_object_checked (domain, image, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + mono_array_setref (res, 0, image_obj); j = 1; for (i = 0; i < module_count; ++i) if (modules [i]) { MonoReflectionModule *rm = mono_module_get_object_checked (domain, modules[i], &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, j, rm); ++j; } @@ -5074,7 +5273,8 @@ ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE); 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); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, j, rm); } else { @@ -5085,7 +5285,8 @@ ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly return NULL; } MonoReflectionModule *rm = mono_module_get_object_checked (domain, m, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_setref (res, j, rm); } } @@ -5110,7 +5311,7 @@ ves_icall_GetCurrentMethod (void) m = ((MonoMethodInflated*)m)->declaring; res = mono_method_get_object_checked (mono_domain_get (), m, NULL, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return res; } @@ -5170,7 +5371,7 @@ ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMeth } else klass = method->klass; res = mono_method_get_object_checked (mono_domain_get (), method, klass, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return res; } @@ -5271,13 +5472,13 @@ ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full } ICALL_EXPORT int -vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *rfield) +vell_icall_RuntimeType_get_core_clr_security_level (MonoReflectionType *rfield) { MonoError error; MonoClass *klass = mono_class_from_mono_type (rfield->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return mono_security_core_clr_class_level (klass); } @@ -5379,11 +5580,15 @@ fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *a pkey_ptr = (char*)name->public_key; pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr); - MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len)); + MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, error); + return_if_nok (error); + MONO_OBJECT_SETREF (aname, publicKey, pkey); memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len); aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG; } else if (default_publickey) { - MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, 0)); + MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error); + return_if_nok (error); + MONO_OBJECT_SETREF (aname, publicKey, pkey); aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG; } @@ -5392,8 +5597,11 @@ fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *a int i, j; char *p; - MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8)); - p = mono_array_addr (aname->keyToken, char, 0); + MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 8, error); + return_if_nok (error); + + MONO_OBJECT_SETREF (aname, keyToken, keyToken); + p = mono_array_addr (keyToken, char, 0); for (i = 0, j = 0; i < 8; i++) { *p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4; @@ -5401,7 +5609,9 @@ fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *a p++; } } else if (default_token) { - MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0)); + MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error); + return_if_nok (error); + MONO_OBJECT_SETREF (aname, keyToken, keyToken); } } @@ -5451,7 +5661,9 @@ ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoAssemblyName name; char *dirname; - filename = mono_string_to_utf8 (fname); + filename = mono_string_to_utf8_checked (fname, &error); + if (mono_error_set_pending_exception (&error)) + return; dirname = g_path_get_dirname (filename); replace_shadow_path (mono_domain_get (), dirname, &filename); @@ -5551,13 +5763,14 @@ mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **excepti } else { count = tdef->rows - 1; } - res = mono_array_new (domain, mono_defaults.monotype_class, count); - *exceptions = mono_array_new (domain, mono_defaults.exception_class, count); + res = mono_array_new_checked (domain, mono_defaults.runtimetype_class, count, error); + return_val_if_nok (error, NULL); + *exceptions = mono_array_new_checked (domain, mono_defaults.exception_class, count, error); + return_val_if_nok (error, NULL); count = 0; for (i = 1; i < tdef->rows; ++i) { if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) { klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, error); - mono_loader_assert_no_error (); /* Plug any leaks */ if (klass) { rt = mono_type_get_object_checked (domain, &klass->byval_arg, error); @@ -5593,7 +5806,8 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, image = assembly->assembly->image; table = &image->tables [MONO_TABLE_FILE]; res = mono_module_get_types (domain, image, &exceptions, exportedOnly, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; /* Append data from all modules in the assembly */ for (i = 0; i < table->rows; ++i) { @@ -5604,7 +5818,9 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoArray *res2; res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + /* Append the new types to the end of the array */ if (mono_array_length (res2) > 0) { @@ -5614,12 +5830,16 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, len1 = mono_array_length (res); len2 = mono_array_length (res2); - res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2); + res3 = mono_array_new_checked (domain, mono_defaults.runtimetype_class, len1 + len2, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_memcpy_refs (res3, 0, res, 0, len1); mono_array_memcpy_refs (res3, len1, res2, 0, len2); res = res3; - ex3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2); + ex3 = mono_array_new_checked (domain, mono_defaults.runtimetype_class, len1 + len2, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1); mono_array_memcpy_refs (ex3, len1, ex2, 0, len2); exceptions = ex3; @@ -5659,9 +5879,11 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoArray *exl = NULL; int j, length = g_list_length (list) + ex_count; - mono_loader_clear_error (); - - exl = mono_array_new (domain, mono_defaults.exception_class, length); + exl = mono_array_new_checked (domain, mono_defaults.exception_class, length, &error); + if (mono_error_set_pending_exception (&error)) { + g_list_free (list); + return NULL; + } /* Types for which mono_class_get_checked () succeeded */ for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) { MonoException *exc = mono_class_get_exception_for_failure ((MonoClass *)tmp->data); @@ -5684,7 +5906,6 @@ ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, mono_error_set_pending_exception (&error); return NULL; } - mono_loader_clear_error (); mono_set_pending_exception (exc); return NULL; } @@ -5703,7 +5924,10 @@ ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName * gboolean is_token_defined; aname.public_key = NULL; - val = mono_string_to_utf8 (assname); + val = mono_string_to_utf8_checked (assname, &error); + if (mono_error_set_pending_exception (&error)) + return FALSE; + if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) { g_free ((guint8*) aname.public_key); g_free (val); @@ -5803,13 +6027,16 @@ ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *modul MonoArray *exceptions; int i; - if (!module->image) - return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0); - else { + if (!module->image) { + MonoArray *arr = mono_array_new_checked (mono_object_domain (module), mono_defaults.runtimetype_class, 0, &error); + mono_error_set_pending_exception (&error); + return arr; + } else { MonoArray *res; res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; for (i = 0; i < mono_array_length (exceptions); ++i) { MonoException *ex = mono_array_get (exceptions, MonoException *, i); @@ -5990,7 +6217,9 @@ ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 /* FIXME: What to do if the index points into the middle of a string ? */ - return mono_ldstr (mono_domain_get (), image, index); + MonoString *result = mono_ldstr_checked (mono_domain_get (), image, index, &error); + mono_error_set_pending_exception (&error); + return result; } ICALL_EXPORT MonoClassField* @@ -6062,7 +6291,7 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error); if (t) { ret = (MonoObject*) mono_type_get_object_checked (mono_domain_get (), t, &merror); - mono_error_raise_exception (&merror); + mono_error_set_pending_exception (&merror); return ret; } @@ -6074,7 +6303,7 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error); if (m) { ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror); - mono_error_raise_exception (&merror); + mono_error_set_pending_exception (&merror); return ret; } else @@ -6084,7 +6313,7 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error); if (f) { ret =(MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror); - mono_error_raise_exception (&merror); + mono_error_set_pending_exception (&merror); return ret; } else @@ -6095,7 +6324,7 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error); if (m) { ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror); - mono_error_raise_exception (&merror); + mono_error_set_pending_exception (&merror); return ret; } else @@ -6105,7 +6334,7 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error); if (f) { ret = (MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror); - mono_error_raise_exception (&merror); + mono_error_set_pending_exception (&merror); return ret; } else @@ -6121,8 +6350,9 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 } ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error) +ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error) { + MonoError error; int table = mono_metadata_token_table (token); int idx = mono_metadata_token_index (token); MonoTableInfo *tables = image->tables; @@ -6130,7 +6360,7 @@ ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 t const char *ptr; MonoArray *res; - *error = ResolveTokenError_OutOfRange; + *resolve_error = ResolveTokenError_OutOfRange; /* FIXME: Support other tables ? */ if (table != MONO_TABLE_STANDALONESIG) @@ -6147,7 +6377,9 @@ ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 t ptr = mono_metadata_blob_heap (image, sig); len = mono_metadata_decode_blob_size (ptr, &ptr); - res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, len); + res = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, len, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; memcpy (mono_array_addr (res, guint8, 0), ptr, len); return res; } @@ -6159,8 +6391,10 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon MonoReflectionType *ret; MonoClass *klass; int isbyref = 0, rank; - char *str = mono_string_to_utf8 (smodifiers); char *p; + char *str = mono_string_to_utf8_checked (smodifiers, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; klass = mono_class_from_mono_type (tb->type.type); p = str; @@ -6178,7 +6412,7 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon g_free (str); ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->this_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; case '*': @@ -6216,7 +6450,7 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon g_free (str); ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -6251,7 +6485,7 @@ check_for_invalid_type (MonoClass *klass, MonoError *error) } ICALL_EXPORT MonoReflectionType * -ves_icall_Type_make_array_type (MonoReflectionType *type, int rank) +ves_icall_RuntimeType_make_array_type (MonoReflectionType *type, int rank) { MonoError error; MonoReflectionType *ret; @@ -6259,7 +6493,7 @@ ves_icall_Type_make_array_type (MonoReflectionType *type, int rank) klass = mono_class_from_mono_type (type->type); check_for_invalid_type (klass, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); if (rank == 0) //single dimentional array aklass = mono_array_class_get (klass, 1); @@ -6267,13 +6501,13 @@ ves_icall_Type_make_array_type (MonoReflectionType *type, int rank) aklass = mono_bounded_array_class_get (klass, rank, TRUE); ret = mono_type_get_object_checked (mono_object_domain (type), &aklass->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } ICALL_EXPORT MonoReflectionType * -ves_icall_Type_make_byref_type (MonoReflectionType *type) +ves_icall_RuntimeType_make_byref_type (MonoReflectionType *type) { MonoError error; MonoReflectionType *ret; @@ -6281,18 +6515,21 @@ ves_icall_Type_make_byref_type (MonoReflectionType *type) klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + check_for_invalid_type (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; ret = mono_type_get_object_checked (mono_object_domain (type), &klass->this_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } ICALL_EXPORT MonoReflectionType * -ves_icall_Type_MakePointerType (MonoReflectionType *type) +ves_icall_RuntimeType_MakePointerType (MonoReflectionType *type) { MonoError error; MonoReflectionType *ret; @@ -6300,14 +6537,16 @@ ves_icall_Type_MakePointerType (MonoReflectionType *type) klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; check_for_invalid_type (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; pklass = mono_ptr_class_get (type->type); ret = mono_type_get_object_checked (mono_object_domain (type), &pklass->byval_arg, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -6323,7 +6562,8 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon MonoMethod *method = info->method; mono_class_init_checked (delegate_class, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (!(delegate_class->parent == mono_defaults.multicastdelegate_class)) { /* FIXME improve this exception message */ @@ -6345,20 +6585,26 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon } delegate = mono_object_new_checked (mono_object_domain (type), delegate_class, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (method_is_dynamic (method)) { /* Creating a trampoline would leak memory */ - func = mono_compile_method (method); + func = mono_compile_method_checked (method, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; } else { if (target && method->flags & METHOD_ATTRIBUTE_VIRTUAL && method->klass != mono_object_class (target)) method = mono_object_get_virtual_method (target, method); - func = mono_create_ftnptr (mono_domain_get (), - mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE)); + gpointer trampoline = mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; + func = mono_create_ftnptr (mono_domain_get (), trampoline); } - mono_delegate_ctor_with_method (delegate, target, func, method); - + mono_delegate_ctor_with_method (delegate, target, func, method, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; return delegate; } @@ -6371,7 +6617,9 @@ ves_icall_System_Delegate_AllocDelegateLike_internal (MonoDelegate *delegate) g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class)); ret = (MonoMulticastDelegate*) mono_object_new_checked (mono_object_domain (delegate), mono_object_class (delegate), &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + ret->delegate.invoke_impl = mono_runtime_create_delegate_trampoline (mono_object_class (delegate)); return ret; @@ -6383,7 +6631,7 @@ ves_icall_System_Delegate_GetVirtualMethod_internal (MonoDelegate *delegate) 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); + mono_error_set_pending_exception (&error); return ret; } @@ -6493,7 +6741,9 @@ ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoStri MonoClass *klass; res = mono_object_new_checked (domain, mono_defaults.transparent_proxy_class, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + tp = (MonoTransparentProxy*) res; MONO_OBJECT_SETREF (tp, rp, rp); @@ -6508,17 +6758,15 @@ ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoStri } tp->custom_type_info = (mono_object_isinst_checked (this_obj, mono_defaults.iremotingtypeinfo_class, &error) != NULL); - if (!is_ok (&error)) { - mono_error_set_pending_exception (&error); + if (mono_error_set_pending_exception (&error)) return NULL; - } tp->remote_class = mono_remote_class (domain, class_name, klass, &error); - if (!is_ok (&error)) { - mono_error_set_pending_exception (&error); + if (mono_error_set_pending_exception (&error)) return NULL; - } - res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp); + res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; return res; } @@ -6527,7 +6775,7 @@ ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp) { 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); + mono_error_set_pending_exception (&error); return ret; } @@ -6558,7 +6806,7 @@ ves_icall_System_Environment_get_MachineName (void) if (GetComputerName (buf, (PDWORD) &len)) { MonoError error; result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); } g_free (buf); @@ -6644,13 +6892,16 @@ ves_icall_System_Environment_GetIs64BitOperatingSystem (void) ICALL_EXPORT MonoString * ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name) { + MonoError error; const gchar *value; gchar *utf8_name; if (name == NULL) return NULL; - utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */ + utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */ + if (mono_error_set_pending_exception (&error)) + return NULL; value = g_getenv (utf8_name); g_free (utf8_name); @@ -6685,10 +6936,20 @@ char **environ; #endif #endif +ICALL_EXPORT MonoArray * +ves_icall_System_Environment_GetCoomandLineArgs (void) +{ + MonoError error; + MonoArray *result = mono_runtime_get_main_args_checked (&error); + mono_error_set_pending_exception (&error); + return result; +} + ICALL_EXPORT MonoArray * ves_icall_System_Environment_GetEnvironmentVariableNames (void) { #ifdef HOST_WIN32 + MonoError error; MonoArray *names; MonoDomain *domain; MonoString *str; @@ -6712,7 +6973,9 @@ ves_icall_System_Environment_GetEnvironmentVariableNames (void) } domain = mono_domain_get (); - names = mono_array_new (domain, mono_defaults.string_class, n); + names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (env_strings) { n = 0; @@ -6724,7 +6987,9 @@ ves_icall_System_Environment_GetEnvironmentVariableNames (void) g_assert(equal_str); MonoError error; str = mono_string_new_utf16_checked (domain, env_string, equal_str-env_string, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; + mono_array_setref (names, n, str); n++; } @@ -6739,6 +7004,7 @@ ves_icall_System_Environment_GetEnvironmentVariableNames (void) return names; #else + MonoError error; MonoArray *names; MonoDomain *domain; MonoString *str; @@ -6750,7 +7016,9 @@ ves_icall_System_Environment_GetEnvironmentVariableNames (void) ++ n; domain = mono_domain_get (); - names = mono_array_new (domain, mono_defaults.string_class, n); + names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; n = 0; for (e = environ; *e != 0; ++ e) { @@ -6769,14 +7037,6 @@ ves_icall_System_Environment_GetEnvironmentVariableNames (void) #endif } -/* - * If your platform lacks setenv/unsetenv, you must upgrade your glib. - */ -#if !GLIB_CHECK_VERSION(2,4,0) -#define g_setenv(a,b,c) setenv(a,b,c) -#define g_unsetenv(a) unsetenv(a) -#endif - ICALL_EXPORT void ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value) { @@ -6802,7 +7062,9 @@ ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, M g_free (utf16_name); g_free (utf16_value); #else - utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */ + utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */ + if (mono_error_set_pending_exception (&error)) + return; if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) { g_unsetenv (utf8_name); @@ -6868,7 +7130,7 @@ ves_icall_System_Environment_GetWindowsFolderPath (int folder) ++ len; MonoError error; MonoString *res = mono_string_new_utf16_checked (mono_domain_get (), path, len, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return res; } #else @@ -6913,18 +7175,24 @@ ves_icall_System_Environment_GetLogicalDrives (void) } while (*dname); dname = ptr; - result = mono_array_new (domain, mono_defaults.string_class, ndrives); + result = mono_array_new_checked (domain, mono_defaults.string_class, ndrives, &error); + if (mono_error_set_pending_exception (&error)) + goto leave; + ndrives = 0; do { len = 0; u16 = dname; while (*u16) { u16++; len ++; } drivestr = mono_string_new_utf16_checked (domain, dname, len, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + goto leave; + mono_array_setref (result, ndrives++, drivestr); while (*dname++); } while (*dname); +leave: if (ptr != buf) g_free (ptr); @@ -6934,11 +7202,14 @@ ves_icall_System_Environment_GetLogicalDrives (void) ICALL_EXPORT MonoString * ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path) { + MonoError error; gunichar2 volume_name [MAX_PATH + 1]; if (GetVolumeInformation (mono_string_chars (path), NULL, 0, NULL, NULL, NULL, volume_name, MAX_PATH + 1) == FALSE) return NULL; - return mono_string_from_utf16 (volume_name); + MonoString *result = mono_string_from_utf16_checked (volume_name, &error); + mono_error_set_pending_exception (&error); + return result; } ICALL_EXPORT MonoString * @@ -7043,6 +7314,14 @@ ves_icall_System_Environment_BroadcastSettingChange (void) #endif } +ICALL_EXPORT +gint32 +ves_icall_System_Environment_get_TickCount (void) +{ + /* this will overflow after ~24 days */ + return (gint32) (mono_msec_boottime () & 0xffffffff); +} + ICALL_EXPORT gint32 ves_icall_System_Runtime_Versioning_VersioningHelper_GetRuntimeId (void) { @@ -7054,7 +7333,9 @@ ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this_obj, MonoReflectionMethod *method, MonoArray *out_args) { - mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args); + MonoError error; + mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args, &error); + mono_error_set_pending_exception (&error); } #ifndef DISABLE_REMOTING @@ -7088,7 +7369,8 @@ ves_icall_Remoting_RemotingServices_GetVirtualMethod ( method = rmethod->method; klass = mono_class_from_mono_type (rtype->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (MONO_CLASS_IS_INTERFACE (klass)) return NULL; @@ -7124,7 +7406,7 @@ ves_icall_Remoting_RemotingServices_GetVirtualMethod ( return NULL; ret = mono_method_get_object_checked (mono_domain_get (), res, NULL, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -7166,7 +7448,8 @@ ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClas domain = mono_object_domain (type); klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (MONO_CLASS_IS_INTERFACE (klass) || (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) { mono_set_pending_exception (mono_get_exception_argument ("type", "Type cannot be instantiated")); @@ -7175,7 +7458,9 @@ ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClas if (klass->rank >= 1) { g_assert (klass->rank == 1); - return (MonoObject *) mono_array_new (domain, klass->element_class, 0); + ret = (MonoObject *) mono_array_new_checked (domain, klass->element_class, 0, &error); + mono_error_set_pending_exception (&error); + return ret; } else { MonoVTable *vtable = mono_class_vtable_full (domain, klass, &error); if (!is_ok (&error)) { @@ -7235,7 +7520,10 @@ ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name) ICALL_EXPORT gpointer ves_icall_RuntimeMethodHandle_GetFunctionPointer (MonoMethod *method) { - return mono_compile_method (method); + MonoError error; + gpointer result = mono_compile_method_checked (method, &error); + mono_error_set_pending_exception (&error); + return result; } ICALL_EXPORT MonoString * @@ -7261,9 +7549,11 @@ ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void) return mcpath; } +/* this is an icall */ static MonoString * get_bundled_app_config (void) { + MonoError error; const gchar *app_config; MonoDomain *domain; MonoString *file; @@ -7277,7 +7567,9 @@ get_bundled_app_config (void) return NULL; // Retrieve config file and remove the extension - config_file_name = mono_string_to_utf8 (file); + config_file_name = mono_string_to_utf8_checked (file, &error); + if (mono_error_set_pending_exception (&error)) + return NULL; config_file_path = mono_portability_find_file (config_file_name, TRUE); if (!config_file_path) config_file_path = config_file_name; @@ -7410,14 +7702,15 @@ ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type) domain = mono_object_domain (type); klass = mono_class_from_mono_type (type->type); mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; if (mono_class_is_nullable (klass)) /* No arguments -> null */ return NULL; result = mono_object_new_checked (domain, klass, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return result; } @@ -7478,7 +7771,6 @@ ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definiti */ MonoGenericContext *parent_inst = NULL; 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); if (!mono_error_ok (&error)) { mono_error_set_pending_exception (&error); @@ -7548,7 +7840,7 @@ ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definiti return m; ret = mono_method_get_object_checked (mono_domain_get (), result, NULL, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return ret; } @@ -7747,7 +8039,7 @@ ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod * MonoError error; prelink_method (method->method, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); } ICALL_EXPORT void @@ -7759,11 +8051,13 @@ ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType gpointer iter = NULL; mono_class_init_checked (klass, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; while ((m = mono_class_get_methods (klass, &iter))) { prelink_method (m, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return; } } @@ -7802,7 +8096,8 @@ type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoE } if (!count) return NULL; - res = mono_array_new (mono_domain_get (), mono_defaults.systemtype_class, count); + res = mono_array_new_checked (mono_domain_get (), mono_defaults.systemtype_class, count, error); + return_val_if_nok (error, NULL); count = 0; for (i = 0; i < type->num_mods; ++i) { if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) { @@ -7858,7 +8153,7 @@ ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameter *param, MonoBo type = sig->params [pos]; res = type_array_from_modifiers (image, type, optional, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return res; } @@ -7887,7 +8182,7 @@ ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionProperty *property, M if (!type) return NULL; res = type_array_from_modifiers (image, type, optional, &error); - mono_error_raise_exception (&error); + mono_error_set_pending_exception (&error); return res; } @@ -7950,7 +8245,8 @@ custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type) gboolean found; mono_class_init_checked (attr_class, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return FALSE; cinfo = mono_reflection_get_custom_attrs_info_checked (obj, &error); if (!is_ok (&error)) { @@ -7974,7 +8270,8 @@ custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type) if (attr_class) { mono_class_init_checked (attr_class, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; } res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error); @@ -7983,12 +8280,7 @@ custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type) return NULL; } - if (mono_loader_get_last_error ()) { - mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); - return NULL; - } else { - return res; - } + return res; } ICALL_EXPORT MonoArray* @@ -8029,7 +8321,8 @@ ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code) message = mono_string_new (mono_domain_get (), "Error looking up error string"); } else { message = mono_string_new_utf16_checked (mono_domain_get (), buf, ret, &error); - mono_error_raise_exception (&error); + if (mono_error_set_pending_exception (&error)) + return NULL; } return message;