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_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;
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;
}
}
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;
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;
}
}
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;
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;
MonoType *type = NULL;
MonoAssembly *assembly = NULL;
gboolean type_resolve = FALSE;
+ MonoImage *rootimage = NULL;
mono_error_init (error);
*/
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
if (dest) {
assembly = dest->klass->image->assembly;
type_resolve = TRUE;
+ rootimage = assembly->image;
} else {
g_warning (G_STRLOC);
}
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<int, Local>
+ // 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<System.Generic.Dict<int, Local>> 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);
}
/* 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"));
+ mono_error_init (&error);
+ mono_error_set_argument (&error, "typeName", "failed parse: %s", str);
+ mono_error_set_pending_exception (&error);
}
+ g_free (str);
return NULL;
}
if (throwOnError)
e = mono_get_exception_type_load (name, NULL);
- mono_loader_clear_error ();
if (e) {
mono_set_pending_exception (e);
return NULL;
/* 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;
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))
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;
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;
}
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;
loader_error:
if (mono_class_has_failure (klass)) {
mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
- } else {
- mono_error_set_from_loader_error (&error);
- mono_loader_clear_error ();
}
failure:
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;
loader_error:
if (mono_class_has_failure (klass)) {
mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
- } else {
- mono_error_set_from_loader_error (&error);
- mono_loader_clear_error ();
}
failure:
if (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);
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);
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);
}
}
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);
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) {
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;
}
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);
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);
/* Types for which mono_class_get_checked () succeeded */
for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
mono_error_set_pending_exception (&error);
return NULL;
}
- mono_loader_clear_error ();
mono_set_pending_exception (exc);
return NULL;
}
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*
projects / mono.git / blobdiff