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 */
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 */
#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;
}
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;
}
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;
}
{
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
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)
{
mono_error_set_pending_exception (&error);
return result;
}
+#endif
static gboolean
get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
}
if (m->klass->image == mono_defaults.corlib && ((!strcmp (m->klass->name_space, "System.Reflection"))
- || (!strcmp (m->klass->name_space, "System"))))
+ || (!strcmp (m->klass->name_space, "System"))))
return FALSE;
if (!(*dest)) {
*/
m = mono_method_get_last_managed ();
dest = m;
-
- /* 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;
-
+ 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
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;
}
}
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;
}
}
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;
}
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;
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);
}
(((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;
}
(((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;
}
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);
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;
}
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;
}
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;
}
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);
}
}
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);
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 ++;
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;
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
else
return NULL;
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
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;
}
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);
}
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;
}
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;
}
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;
}
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);
}
res = create_type_array (domain, runtimeTypeArray, inst->type_argc);
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);
}
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;
}
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);
}
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;
}
res = mono_array_new (domain, mono_defaults.monotype_class, count);
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);
}
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;
}
}
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);
}
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);
}
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;
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);
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) {
}
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;
}
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."));
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
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);
}
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);
}
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;
}
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])));
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);
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);
}
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);
res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
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;
}
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 {
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);
}
}
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;
}
} 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;
}
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);
}
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) {
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) {
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);
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;
}
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
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
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
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
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 '*':
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;
}
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);
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;
}
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;
}
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;
}
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 */
}
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 */
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;
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;
}
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);
{
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;
}
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);
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++;
}
++ 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
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))
+ return NULL;
+
mono_array_setref (result, ndrives++, drivestr);
while (*dname++);
} while (*dname);
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;
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;
}
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"));
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;
}
*/
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);
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;
}
MonoError error;
prelink_method (method->method, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
}
ICALL_EXPORT void
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;
}
}
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;
}
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;
}
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)) {
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);
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;
projects / mono.git / blobdiff