* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Copyright 2012 Xamarin Inc
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#undef ASSEMBLY_LOAD_DEBUG
#include <config.h>
#include <mono/metadata/threads-types.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/profiler-private.h>
+#include <mono/metadata/reflection-internals.h>
#include <mono/utils/mono-uri.h>
#include <mono/utils/mono-logger-internals.h>
#include <mono/utils/mono-path.h>
* Changes which are already detected at runtime, like the addition
* of icalls, do not require an increment.
*/
-#define MONO_CORLIB_VERSION 140
+#define MONO_CORLIB_VERSION 143
typedef struct
{
add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *hash);
static MonoAppDomain *
-mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *setup);
+mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *setup, MonoError *error);
static char *
get_shadow_assembly_location_base (MonoDomain *domain, MonoError *error);
static MonoLoadFunc load_function = NULL;
+/* Lazy class loading functions */
+static GENERATE_GET_CLASS_WITH_CACHE (assembly, System.Reflection, Assembly)
+
void
mono_install_runtime_load (MonoLoadFunc func)
{
static void
create_domain_objects (MonoDomain *domain)
{
+ MonoError error;
MonoDomain *old_domain = mono_domain_get ();
MonoString *arg;
MonoVTable *string_vt;
string_vt = mono_class_vtable (domain, mono_defaults.string_class);
string_empty_fld = mono_class_get_field_from_name (mono_defaults.string_class, "Empty");
g_assert (string_empty_fld);
- mono_field_static_set_value (string_vt, string_empty_fld, mono_string_intern (mono_string_new (domain, "")));
+ MonoString *empty_str = mono_string_intern_checked (mono_string_new (domain, ""), &error);
+ mono_error_assert_ok (&error);
+ mono_field_static_set_value (string_vt, string_empty_fld, empty_str);
/*
* Create an instance early since we can't do it when there is no memory.
domain->stack_overflow_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL);
/*The ephemeron tombstone i*/
- domain->ephemeron_tombstone = mono_object_new (domain, mono_defaults.object_class);
+ domain->ephemeron_tombstone = mono_object_new_checked (domain, mono_defaults.object_class, &error);
+ mono_error_assert_ok (&error);
if (domain != old_domain) {
mono_thread_pop_appdomain_ref ();
*
*/
void
-mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
- MonoThreadAttachCB attach_cb)
+mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb)
+{
+ MonoError error;
+ mono_runtime_init_checked (domain, start_cb, attach_cb, &error);
+ mono_error_cleanup (&error);
+}
+
+void
+mono_runtime_init_checked (MonoDomain *domain, MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb, MonoError *error)
{
MonoAppDomainSetup *setup;
MonoAppDomain *ad;
MonoClass *klass;
+ mono_error_init (error);
+
mono_portability_helpers_init ();
mono_gc_base_init ();
mono_install_assembly_postload_search_hook ((MonoAssemblySearchFunc)mono_domain_assembly_postload_search, GUINT_TO_POINTER (FALSE));
mono_install_assembly_postload_refonly_search_hook ((MonoAssemblySearchFunc)mono_domain_assembly_postload_search, GUINT_TO_POINTER (TRUE));
mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
- mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
mono_thread_init (start_cb, attach_cb);
- klass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
- setup = (MonoAppDomainSetup *) mono_object_new_pinned (domain, klass);
+ klass = mono_class_load_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
+ setup = (MonoAppDomainSetup *) mono_object_new_pinned (domain, klass, error);
+ return_if_nok (error);
+
+ klass = mono_class_load_from_name (mono_defaults.corlib, "System", "AppDomain");
+
+ ad = (MonoAppDomain *) mono_object_new_pinned (domain, klass, error);
+ return_if_nok (error);
- klass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
- ad = (MonoAppDomain *) mono_object_new_pinned (domain, klass);
ad->data = domain;
domain->domain = ad;
domain->setup = setup;
mono_gc_init ();
/* contexts use GC handles, so they must be initialized after the GC */
- mono_context_init (domain);
+ mono_context_init_checked (domain, error);
+ return_if_nok (error);
mono_context_set (domain->default_context);
#ifndef DISABLE_SOCKETS
static int
mono_get_corlib_version (void)
{
+ MonoError error;
MonoClass *klass;
MonoClassField *field;
MonoObject *value;
- klass = mono_class_from_name (mono_defaults.corlib, "System", "Environment");
+ klass = mono_class_load_from_name (mono_defaults.corlib, "System", "Environment");
mono_class_init (klass);
field = mono_class_get_field_from_name (klass, "mono_corlib_version");
if (!field)
return -1;
if (! (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
return -1;
- value = mono_field_get_value_object (mono_domain_get (), field, NULL);
+ value = mono_field_get_value_object_checked (mono_domain_get (), field, NULL, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
return *(gint32*)((gchar*)value + sizeof (MonoObject));
}
*/
void
mono_context_init (MonoDomain *domain)
+{
+ MonoError error;
+ mono_context_init_checked (domain, &error);
+ mono_error_cleanup (&error);
+}
+
+void
+mono_context_init_checked (MonoDomain *domain, MonoError *error)
{
MonoClass *klass;
MonoAppContext *context;
- klass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
- context = (MonoAppContext *) mono_object_new_pinned (domain, klass);
+ mono_error_init (error);
+
+ klass = mono_class_load_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
+ context = (MonoAppContext *) mono_object_new_pinned (domain, klass, error);
+ return_if_nok (error);
+
context->domain_id = domain->domain_id;
context->context_id = 0;
ves_icall_System_Runtime_Remoting_Contexts_Context_RegisterContext (context);
MonoDomain *
mono_domain_create_appdomain (char *friendly_name, char *configuration_file)
{
+ MonoError error;
MonoAppDomain *ad;
MonoAppDomainSetup *setup;
MonoClass *klass;
- klass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
- setup = (MonoAppDomainSetup *) mono_object_new (mono_domain_get (), klass);
+ klass = mono_class_load_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
+ setup = (MonoAppDomainSetup *) mono_object_new_checked (mono_domain_get (), klass, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
setup->configuration_file = configuration_file != NULL ? mono_string_new (mono_domain_get (), configuration_file) : NULL;
- ad = mono_domain_create_appdomain_internal (friendly_name, setup);
+ ad = mono_domain_create_appdomain_internal (friendly_name, setup, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
return mono_domain_from_appdomain (ad);
}
}
static MonoAppDomainSetup*
-copy_app_domain_setup (MonoDomain *domain, MonoAppDomainSetup *setup)
+copy_app_domain_setup (MonoDomain *domain, MonoAppDomainSetup *setup, MonoError *error)
{
- MonoDomain *caller_domain = mono_domain_get ();
- MonoClass *ads_class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
- MonoAppDomainSetup *copy = (MonoAppDomainSetup*)mono_object_new (domain, ads_class);
+ MonoDomain *caller_domain;
+ MonoClass *ads_class;
+ MonoAppDomainSetup *copy;
+
+ mono_error_init (error);
+
+ caller_domain = mono_domain_get ();
+ ads_class = mono_class_load_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
+
+ copy = (MonoAppDomainSetup*)mono_object_new_checked (domain, ads_class, error);
+ return_val_if_nok (error, NULL);
mono_domain_set_internal (domain);
}
static MonoAppDomain *
-mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *setup)
+mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *setup, MonoError *error)
{
- MonoError error;
MonoClass *adclass;
MonoAppDomain *ad;
MonoDomain *data;
char *shadow_location;
-
- adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
+
+ mono_error_init (error);
+
+ adclass = mono_class_load_from_name (mono_defaults.corlib, "System", "AppDomain");
/* FIXME: pin all those objects */
data = mono_domain_create();
- ad = (MonoAppDomain *) mono_object_new (data, adclass);
+ ad = (MonoAppDomain *) mono_object_new_checked (data, adclass, error);
+ return_val_if_nok (error, NULL);
ad->data = data;
data->domain = ad;
data->friendly_name = g_strdup (friendly_name);
if (!setup->application_base) {
/* Inherit from the root domain since MS.NET does this */
MonoDomain *root = mono_get_root_domain ();
- if (root->setup->application_base)
- MONO_OBJECT_SETREF (setup, application_base, mono_string_new_utf16 (data, mono_string_chars (root->setup->application_base), mono_string_length (root->setup->application_base)));
+ if (root->setup->application_base) {
+ MonoString *s = mono_string_new_utf16_checked (data, mono_string_chars (root->setup->application_base), mono_string_length (root->setup->application_base), error);
+ mono_error_assert_ok (error); /* FIXME don't swallow the error */
+ MONO_OBJECT_SETREF (setup, application_base, s);
+ }
}
- mono_context_init (data);
+ mono_context_init_checked (data, error);
+ return_val_if_nok (error, NULL);
+
+ data->setup = copy_app_domain_setup (data, setup, error);
+ if (!mono_error_ok (error)) {
+ g_free (data->friendly_name);
+ return NULL;
+ }
- data->setup = copy_app_domain_setup (data, setup);
mono_domain_set_options_from_config (data);
add_assemblies_to_domain (data, mono_defaults.corlib->assembly, NULL);
#ifndef DISABLE_SHADOW_COPY
/*FIXME, guard this for when the debugger is not running */
- shadow_location = get_shadow_assembly_location_base (data, &error);
- if (!mono_error_ok (&error))
- mono_error_raise_exception (&error);
+ shadow_location = get_shadow_assembly_location_base (data, error);
+ if (!mono_error_ok (error)) {
+ g_free (data->friendly_name);
+ return NULL;
+ }
+
g_free (shadow_location);
#endif
* mono_domain_has_type_resolve:
* @domain: application domains being looked up
*
- * Returns true if the AppDomain.TypeResolve field has been
+ * Returns: TRUE if the AppDomain.TypeResolve field has been
* set.
*/
gboolean
MonoReflectionAssembly *
mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
{
+ MonoError error;
+ MonoReflectionAssembly *ret = mono_domain_try_type_resolve_checked (domain, name, tb, &error);
+ mono_error_cleanup (&error);
+
+ return ret;
+}
+
+MonoReflectionAssembly *
+mono_domain_try_type_resolve_checked (MonoDomain *domain, char *name, MonoObject *tb, MonoError *error)
+{
+ static MonoMethod *method = NULL;
+ MonoReflectionAssembly *ret;
MonoClass *klass;
void *params [1];
- static MonoMethod *method = NULL;
+
+ mono_error_init (error);
g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
*params = (MonoObject*)mono_string_new (mono_domain_get (), name);
else
*params = tb;
- return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
+
+ ret = (MonoReflectionAssembly *) mono_runtime_invoke_checked (method, domain->domain, params, error);
+ return_val_if_nok (error, NULL);
+
+ return ret;
}
/**
mono_set_pending_exception (mono_get_exception_not_supported ("AppDomain creation is not supported on this runtime."));
return NULL;
#else
- char *fname = mono_string_to_utf8 (friendly_name);
- MonoAppDomain *ad = mono_domain_create_appdomain_internal (fname, setup);
-
+ MonoError error;
+ char *fname;
+ MonoAppDomain *ad;
+
+ fname = mono_string_to_utf8 (friendly_name);
+ ad = mono_domain_create_appdomain_internal (fname, setup, &error);
+
g_free (fname);
+ mono_error_raise_exception (&error);
+
return ad;
#endif
}
MonoArray *
ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad, MonoBoolean refonly)
{
+ MonoError error;
MonoDomain *domain = ad->data;
MonoAssembly* ass;
- static MonoClass *System_Reflection_Assembly;
MonoArray *res;
GSList *tmp;
int i;
GPtrArray *assemblies;
- if (!System_Reflection_Assembly)
- System_Reflection_Assembly = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection", "Assembly");
+ mono_error_init (&error);
/*
* Make a copy of the list of assemblies because we can't hold the assemblies
}
mono_domain_assemblies_unlock (domain);
- res = mono_array_new (domain, System_Reflection_Assembly, assemblies->len);
+ res = mono_array_new (domain, mono_class_get_assembly_class (), assemblies->len);
for (i = 0; i < assemblies->len; ++i) {
ass = (MonoAssembly *)g_ptr_array_index (assemblies, i);
- mono_array_setref (res, i, mono_assembly_get_object (domain, ass));
+ MonoReflectionAssembly *ass_obj = mono_assembly_get_object_checked (domain, ass, &error);
+ if (!mono_error_ok (&error))
+ goto leave;
+ mono_array_setref (res, i, ass_obj);
}
+leave:
g_ptr_array_free (assemblies, TRUE);
-
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
return res;
}
MonoReflectionAssembly *
-mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly)
+mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly, MonoError *error)
{
+ MonoReflectionAssembly *ret;
MonoClass *klass;
MonoMethod *method;
MonoBoolean isrefonly;
gpointer params [3];
+ mono_error_init (error);
+
if (mono_runtime_get_no_exec ())
return NULL;
isrefonly = refonly ? 1 : 0;
params [0] = fname;
- params [1] = (requesting) ? mono_assembly_get_object (domain, requesting) : NULL;
+ if (requesting) {
+ params[1] = mono_assembly_get_object_checked (domain, requesting, error);
+ return_val_if_nok (error, NULL);
+ } else
+ params [1] = NULL;
params [2] = &isrefonly;
- return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
+
+ ret = (MonoReflectionAssembly *) mono_runtime_invoke_checked (method, domain->domain, params, error);
+ return_val_if_nok (error, NULL);
+
+ return ret;
}
MonoAssembly *
mono_domain_assembly_postload_search (MonoAssemblyName *aname, MonoAssembly *requesting,
gboolean refonly)
{
+ MonoError error;
MonoReflectionAssembly *assembly;
MonoDomain *domain = mono_domain_get ();
char *aname_str;
g_free (aname_str);
return NULL;
}
- assembly = mono_try_assembly_resolve (domain, str, requesting, refonly);
+
+ assembly = mono_try_assembly_resolve (domain, str, requesting, refonly, &error);
+ if (!mono_error_ok (&error)) {
+ g_free (aname_str);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+ }
+
g_free (aname_str);
if (assembly)
{
static MonoClassField *assembly_load_field;
static MonoMethod *assembly_load_method;
+ MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoReflectionAssembly *ref_assembly;
MonoClass *klass;
return;
}
- ref_assembly = mono_assembly_get_object (domain, assembly);
- g_assert (ref_assembly);
+ ref_assembly = mono_assembly_get_object_checked (domain, assembly, &error);
+ mono_error_assert_ok (&error);
if (assembly_load_method == NULL) {
assembly_load_method = mono_class_get_method_from_name (klass, "DoAssemblyLoad", -1);
}
*params = ref_assembly;
- mono_runtime_invoke (assembly_load_method, domain->domain, params, NULL);
+
+ mono_runtime_invoke_checked (assembly_load_method, domain->domain, params, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
}
/*
}
char *
-mono_make_shadow_copy (const char *filename)
+mono_make_shadow_copy (const char *filename, MonoError *error)
{
+ mono_error_init (error);
return (char *) filename;
}
#else
setup = domain->setup;
if (setup->cache_path != NULL && setup->application_name != NULL) {
cache_path = mono_string_to_utf8_checked (setup->cache_path, error);
- if (!mono_error_ok (error))
- return NULL;
+ return_val_if_nok (error, NULL);
+
#ifndef TARGET_WIN32
{
gint i;
FIXME bubble up the error instead of raising it here
*/
char *
-mono_make_shadow_copy (const char *filename)
+mono_make_shadow_copy (const char *filename, MonoError *oerror)
{
MonoError error;
gchar *sibling_source, *sibling_target;
guint32 attrs;
char *shadow;
gboolean copy_result;
- MonoException *exc;
struct stat src_sbuf;
struct utimbuf utbuf;
char *dir_name = g_path_get_dirname (filename);
MonoDomain *domain = mono_domain_get ();
char *shadow_dir;
+ mono_error_init (oerror);
+
set_domain_search_path (domain);
if (!mono_is_shadow_copy_enabled (domain, dir_name)) {
if (!mono_error_ok (&error)) {
mono_error_cleanup (&error);
g_free (dir_name);
- exc = mono_get_exception_execution_engine ("Failed to create shadow copy (invalid characters in shadow directory name).");
- mono_raise_exception (exc);
+ mono_error_set_execution_engine (oerror, "Failed to create shadow copy (invalid characters in shadow directory name).");
+ return NULL;
}
if (strstr (dir_name, shadow_dir)) {
shadow = get_shadow_assembly_location (filename, &error);
if (!mono_error_ok (&error)) {
mono_error_cleanup (&error);
- exc = mono_get_exception_execution_engine ("Failed to create shadow copy (invalid characters in file name).");
- mono_raise_exception (exc);
+ mono_error_set_execution_engine (oerror, "Failed to create shadow copy (invalid characters in file name).");
+ return NULL;
}
if (ensure_directory_exists (shadow) == FALSE) {
g_free (shadow);
- exc = mono_get_exception_execution_engine ("Failed to create shadow copy (ensure directory exists).");
- mono_raise_exception (exc);
+ mono_error_set_execution_engine (oerror, "Failed to create shadow copy (ensure directory exists).");
+ return NULL;
}
if (!private_file_needs_copying (filename, &src_sbuf, shadow))
if (GetLastError() == ERROR_FILE_NOT_FOUND || GetLastError() == ERROR_PATH_NOT_FOUND)
return NULL; /* file not found, shadow copy failed */
- exc = mono_get_exception_execution_engine ("Failed to create shadow copy (CopyFile).");
- mono_raise_exception (exc);
+ mono_error_set_execution_engine (oerror, "Failed to create shadow copy (CopyFile).");
+ return NULL;
}
/* attempt to copy .mdb, .config if they exist */
if (copy_result == FALSE) {
g_free (shadow);
- exc = mono_get_exception_execution_engine ("Failed to create shadow copy of sibling data (CopyFile).");
- mono_raise_exception (exc);
+ mono_error_set_execution_engine (oerror, "Failed to create shadow copy of sibling data (CopyFile).");
+ return NULL;
}
/* Create a .ini file containing the original assembly location */
if (!shadow_copy_create_ini (shadow, filename)) {
g_free (shadow);
- exc = mono_get_exception_execution_engine ("Failed to create shadow copy .ini file.");
- mono_raise_exception (exc);
+ mono_error_set_execution_engine (oerror, "Failed to create shadow copy .ini file.");
+ return NULL;
}
utbuf.actime = src_sbuf.st_atime;
MonoReflectionAssembly *
ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, MonoBoolean refOnly)
{
+ MonoError error;
+ MonoReflectionAssembly *result;
MonoDomain *domain = mono_domain_get ();
char *name, *filename;
MonoImageOpenStatus status = MONO_IMAGE_OK;
g_free (name);
- return mono_assembly_get_object (domain, ass);
+ result = mono_assembly_get_object_checked (domain, ass, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoReflectionAssembly *
MonoArray *raw_symbol_store, MonoObject *evidence,
MonoBoolean refonly)
{
+ MonoError error;
MonoAssembly *ass;
MonoReflectionAssembly *refass = NULL;
MonoDomain *domain = ad->data;
return NULL;
}
- refass = mono_assembly_get_object (domain, ass);
- MONO_OBJECT_SETREF (refass, evidence, evidence);
+ refass = mono_assembly_get_object_checked (domain, ass, &error);
+ if (!refass)
+ mono_error_set_pending_exception (&error);
+ else
+ MONO_OBJECT_SETREF (refass, evidence, evidence);
return refass;
}
MonoReflectionAssembly *
ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoString *assRef, MonoObject *evidence, MonoBoolean refOnly)
{
+ MonoError error;
MonoDomain *domain = ad->data;
MonoImageOpenStatus status = MONO_IMAGE_OK;
MonoAssembly *ass;
if (!parsed) {
/* This is a parse error... */
- if (!refOnly)
- refass = mono_try_assembly_resolve (domain, assRef, NULL, refOnly);
+ if (!refOnly) {
+ refass = mono_try_assembly_resolve (domain, assRef, NULL, refOnly, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ }
return refass;
}
if (!ass) {
/* MS.NET doesn't seem to call the assembly resolve handler for refonly assemblies */
- if (!refOnly)
- refass = mono_try_assembly_resolve (domain, assRef, NULL, refOnly);
+ if (!refOnly) {
+ refass = mono_try_assembly_resolve (domain, assRef, NULL, refOnly, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ }
else
refass = NULL;
if (!refass) {
}
if (refass == NULL)
- refass = mono_assembly_get_object (domain, ass);
+ refass = mono_assembly_get_object_checked (domain, ass, &error);
- MONO_OBJECT_SETREF (refass, evidence, evidence);
+ if (refass == NULL)
+ mono_error_set_pending_exception (&error);
+ else
+ MONO_OBJECT_SETREF (refass, evidence, evidence);
return refass;
}
void
ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
{
+ MonoException *exc = NULL;
MonoDomain * domain = mono_domain_get_by_id (domain_id);
if (NULL == domain) {
- MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
+ mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
mono_set_pending_exception (exc);
return;
}
return;
#endif
- mono_domain_unload (domain);
+ mono_domain_try_unload (domain, (MonoObject**)&exc);
+ if (exc)
+ mono_set_pending_exception (exc);
}
gboolean
mono_domain_lock (mono_root_domain);
if (process_guid_set) {
mono_domain_unlock (mono_root_domain);
- return mono_string_new_utf16 (mono_domain_get (), process_guid, sizeof(process_guid)/2);
+ MonoError error;
+ MonoString *res = NULL;
+ res = mono_string_new_utf16_checked (mono_domain_get (), process_guid, sizeof(process_guid)/2, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
memcpy (process_guid, mono_string_chars(newguid), sizeof(process_guid));
process_guid_set = TRUE;
static guint32 WINAPI
unload_thread_main (void *arg)
{
+ MonoError error;
unload_data *data = (unload_data*)arg;
MonoDomain *domain = data->domain;
MonoThread *thread;
/* Have to attach to the runtime so shutdown can wait for this thread */
/* Force it to be attached to avoid racing during shutdown. */
- thread = mono_thread_attach_full (mono_get_root_domain (), TRUE);
+ thread = mono_thread_attach_full (mono_get_root_domain (), TRUE, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
/*
* FIXME: Abort our parent thread last, so we can return a failure
{
MonoObject *exc = NULL;
mono_domain_try_unload (domain, &exc);
- if (exc)
- mono_raise_exception ((MonoException*)exc);
}
static guint32
void
mono_domain_try_unload (MonoDomain *domain, MonoObject **exc)
{
+ MonoError error;
HANDLE thread_handle;
MonoAppDomainState prev_state;
MonoMethod *method;
method = mono_class_get_method_from_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload", -1);
g_assert (method);
- mono_runtime_invoke (method, domain->domain, NULL, exc);
+ mono_runtime_try_invoke (method, domain->domain, NULL, exc, &error);
+
+ if (!mono_error_ok (&error)) {
+ if (*exc)
+ mono_error_cleanup (&error);
+ else
+ *exc = (MonoObject*)mono_error_convert_to_exception (&error);
+ }
+
if (*exc) {
/* Roll back the state change */
domain->state = MONO_APPDOMAIN_CREATED;
projects / mono.git / blobdiff