/*
* appdomain.c: AppDomain functions
*
- * Author:
+ * Authors:
* Dietmar Maurer (dietmar@ximian.com)
+ * Patrik Torstensson
+ * Gonzalo Paniagua Javier (gonzalo@ximian.com)
*
- * (C) 2001 Ximian, Inc.
+ * (c) 2001-2003 Ximian, Inc. (http://www.ximian.com)
*/
#include <config.h>
#include <glib.h>
#include <string.h>
+#include <mono/os/gc_wrapper.h>
+
#include <mono/metadata/object.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/assembly.h>
#include <mono/metadata/exception.h>
-#include <mono/metadata/cil-coff.h>
+#include <mono/metadata/threads.h>
+#include <mono/metadata/socket-io.h>
+#include <mono/metadata/tabledefs.h>
+#include <mono/metadata/gc-internal.h>
+
+HANDLE mono_delegate_semaphore = NULL;
+CRITICAL_SECTION mono_delegate_section;
+
+static MonoAssembly *
+mono_domain_assembly_preload (MonoAssemblyName *aname,
+ gchar **assemblies_path,
+ gpointer user_data);
+
+static void
+mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
-static guint32 appdomain_thread_id = 0;
+static MonoMethod *
+look_for_method_by_name (MonoClass *klass, const gchar *name);
+/*
+ * mono_runtime_init:
+ * @domain: domain returned by mono_init ()
+ *
+ * Initialize the core AppDomain: this function will run also some
+ * IL initialization code, so it needs the execution engine to be fully
+ * operational.
+ *
+ * AppDomain.SetupInformation is set up in mono_runtime_exec_main, where
+ * we know the entry_assembly.
+ *
+ */
void
-mono_appdomain_init (char *friendly_name)
+mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
+ MonoThreadAttachCB attach_cb)
{
- static gboolean initialized = FALSE;
MonoAppDomainSetup *setup;
MonoAppDomain *ad;
MonoClass *class;
- MonoString *name;
+
+ mono_install_assembly_preload_hook (mono_domain_assembly_preload, NULL);
+ mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
+ mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
- if (initialized)
- return;
+ class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
+ setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
- appdomain_thread_id = TlsAlloc ();
+ class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
+ ad = (MonoAppDomain *) mono_object_new (domain, class);
+ ad->data = domain;
+ domain->domain = ad;
+ domain->setup = setup;
- class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
- setup = (MonoAppDomainSetup *) mono_object_new (class);
- ves_icall_System_AppDomainSetup_InitAppDomainSetup (setup);
+ mono_delegate_semaphore = CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
+ g_assert (mono_delegate_semaphore != INVALID_HANDLE_VALUE);
+ InitializeCriticalSection (&mono_delegate_section);
+
+ mono_thread_init (start_cb, attach_cb);
+
+ /* GC init has to happen after thread init */
+ mono_gc_init ();
- name = mono_string_new (friendly_name);
- ad = ves_icall_System_AppDomain_createDomain (name, setup);
+ mono_network_init ();
- TlsSetValue (appdomain_thread_id, ad->data);
+ return;
}
+/* This must not be called while there are still running threads executing
+ * managed code.
+ */
void
-ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
+mono_runtime_cleanup (MonoDomain *domain)
{
- // fixme: implement me
+ /* Not really needed, but do it anyway */
+ mono_gc_cleanup ();
+
+ mono_network_cleanup ();
}
-static MonoObject *
-mono_appdomain_transfer_object (MonoAppDomainData *src, MonoAppDomainData *dst, MonoObject *obj)
+gboolean
+mono_domain_has_type_resolve (MonoDomain *domain)
{
- /* fixme: transfer an object from one domain into another */
- g_assert_not_reached ();
- return obj;
+ static MonoClassField *field = NULL;
+ MonoObject *o;
+
+ if (field == NULL) {
+ MonoClass *klass = mono_defaults.appdomain_class;
+ int i;
+
+ for (i = 0; i < klass->field.count; ++i)
+ if (strcmp (klass->fields [i].name, "TypeResolve") == 0)
+ field = &klass->fields [i];
+ g_assert (field);
+ }
+
+ mono_field_get_value ((MonoObject*)(domain->domain), field, &o);
+ return o != NULL;
+}
+
+MonoReflectionAssembly *
+mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
+{
+ MonoClass *klass;
+ void *params [1];
+ static MonoMethod *method = NULL;
+
+ g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
+
+ if (method == NULL) {
+ klass = domain->domain->mbr.obj.vtable->klass;
+ g_assert (klass);
+
+ method = look_for_method_by_name (klass, "DoTypeResolve");
+ if (method == NULL) {
+ g_warning ("Method AppDomain.DoTypeResolve not found.\n");
+ return NULL;
+ }
+ }
+
+ if (name)
+ *params = (MonoObject*)mono_string_new (mono_domain_get (), name);
+ else
+ *params = tb;
+ return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
+}
+
+void
+ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
+{
+ MonoDomain* domain = mono_domain_get ();
+ MonoAssembly *assembly;
+ gchar *str;
+ gchar *config_suffix;
+
+ MONO_ARCH_SAVE_REGS;
+
+ assembly = domain->entry_assembly;
+ g_assert (assembly);
+
+ setup->application_base = mono_string_new (domain, assembly->basedir);
+
+ config_suffix = g_strconcat (assembly->aname.name, ".exe.config", NULL);
+ str = g_build_filename (assembly->basedir, config_suffix, NULL);
+ g_free (config_suffix);
+ setup->configuration_file = mono_string_new (domain, str);
+ g_free (str);
}
MonoObject *
ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
{
- MonoAppDomainData *add = ad->data;
- MonoAppDomainData *cur = mono_appdomain_get ();
+ MonoDomain *add = ad->data;
MonoObject *o;
char *str;
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (name != NULL);
str = mono_string_to_utf8 (name);
+ mono_domain_lock (add);
+
if (!strcmp (str, "APPBASE"))
o = (MonoObject *)add->setup->application_base;
else if (!strcmp (str, "APP_CONFIG_FILE"))
else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
o = (MonoObject *)add->setup->shadow_copy_files;
else
- o = g_hash_table_lookup (add->env, str);
+ o = mono_g_hash_table_lookup (add->env, name);
+ mono_domain_unlock (add);
g_free (str);
if (!o)
return NULL;
- return mono_appdomain_transfer_object (add, cur, o);
+ return o;
}
void
ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
{
- MonoAppDomainData *add = ad->data;
- MonoAppDomainData *cur = mono_appdomain_get ();
- MonoObject *o;
- char *str;
+ MonoDomain *add = ad->data;
+
+ MONO_ARCH_SAVE_REGS;
g_assert (ad != NULL);
g_assert (name != NULL);
- o = mono_appdomain_transfer_object (cur, add, data);
+ mono_domain_lock (add);
- /* fixme: need a hash func for MonoString */
- str = mono_string_to_utf8 (name);
- g_hash_table_insert (add->env, str, o);
- g_free (str);
+ mono_g_hash_table_insert (add->env, name, data);
+
+ mono_domain_unlock (add);
}
MonoAppDomainSetup *
ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (ad->data != NULL);
MonoString *
ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (ad->data != NULL);
- return ad->data->friendly_name;
-}
-
-inline MonoAppDomainData *
-mono_appdomain_get ()
-{
- return ((MonoAppDomainData *)TlsGetValue (appdomain_thread_id));
-}
-
-inline void
-mono_appdomain_set (MonoAppDomainData *domain)
-{
- TlsSetValue (appdomain_thread_id, domain);
+ return mono_string_new (ad->data, ad->data->friendly_name);
}
MonoAppDomain *
ves_icall_System_AppDomain_getCurDomain ()
{
- MonoAppDomainData *add = mono_appdomain_get ();
+ MonoDomain *add = mono_domain_get ();
+
+ MONO_ARCH_SAVE_REGS;
+
return add->domain;
}
MonoAppDomain *
ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
{
+ /*MonoDomain *domain = mono_domain_get (); */
MonoClass *adclass;
MonoAppDomain *ad;
- MonoAppDomainData *data;
+ MonoDomain *data;
+ MONO_ARCH_SAVE_REGS;
+
adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
-
- // fixme: pin all those objects
- ad = (MonoAppDomain *) mono_object_new (adclass);
- ad->data = data = g_new0 (MonoAppDomainData, 1);
+
+ /* FIXME: pin all those objects */
+ data = mono_domain_create();
+
+ ad = (MonoAppDomain *) mono_object_new (data, adclass);
+ ad->data = data;
data->domain = ad;
data->setup = setup;
- data->friendly_name = friendly_name;
-
- data->env = g_hash_table_new (g_str_hash, g_str_equal);
- data->assemblies = g_hash_table_new (g_str_hash, g_str_equal);
+ data->friendly_name = mono_string_to_utf8 (friendly_name);
- // fixme: what to do next ?
+ /* FIXME: what to do next ? */
return ad;
}
typedef struct {
MonoArray *res;
+ MonoDomain *domain;
int idx;
} add_assembly_helper_t;
{
add_assembly_helper_t *ah = (add_assembly_helper_t *) user_data;
- mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (value));
+ mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (ah->domain, value));
}
-//
-// This is not correct, because we return all the assemblies loaded, and not
-// those that come from the AppDomain, but its better than nothing.
-//
MonoArray *
ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
{
+ MonoDomain *domain = ad->data;
static MonoClass *System_Reflection_Assembly;
- GHashTable *assemblies = mono_get_assemblies ();
MonoArray *res;
add_assembly_helper_t ah;
+ MONO_ARCH_SAVE_REGS;
+
if (!System_Reflection_Assembly)
System_Reflection_Assembly = mono_class_from_name (
mono_defaults.corlib, "System.Reflection", "Assembly");
- res = mono_array_new (System_Reflection_Assembly, g_hash_table_size (assemblies));
+ res = mono_array_new (domain, System_Reflection_Assembly, g_hash_table_size (domain->assemblies));
+ ah.domain = domain;
ah.res = res;
ah.idx = 0;
- g_hash_table_foreach (assemblies, add_assembly, &ah);
+ mono_domain_lock (domain);
+ g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
+ mono_domain_unlock (domain);
return res;
}
+/*
+ * Used to find methods in AppDomain class.
+ * It only works if there are no multiple signatures for any given method name
+ */
+static MonoMethod *
+look_for_method_by_name (MonoClass *klass, const gchar *name)
+{
+ gint i;
+ MonoMethod *method;
+
+ for (i = 0; i < klass->method.count; i++) {
+ method = klass->methods [i];
+ if (!strcmp (method->name, name))
+ return method;
+ }
+
+ return NULL;
+}
+
+static MonoReflectionAssembly *
+try_assembly_resolve (MonoDomain *domain, MonoString *fname)
+{
+ MonoClass *klass;
+ MonoMethod *method;
+ void *params [1];
+
+ g_assert (domain != NULL && fname != NULL);
+
+ klass = domain->domain->mbr.obj.vtable->klass;
+ g_assert (klass);
+
+ method = look_for_method_by_name (klass, "DoAssemblyResolve");
+ if (method == NULL) {
+ g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
+ return NULL;
+ }
+
+ *params = fname;
+ return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
+}
+
+static void
+add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass)
+{
+ gint i;
+
+ if (g_hash_table_lookup (domain->assemblies, ass->aname.name))
+ return; /* This is ok while no lazy loading of assemblies */
+
+ mono_domain_lock (domain);
+ g_hash_table_insert (domain->assemblies, (gpointer) ass->aname.name, ass);
+ mono_domain_unlock (domain);
+
+ for (i = 0; ass->image->references [i] != NULL; i++)
+ add_assemblies_to_domain (domain, ass->image->references [i]);
+}
+
+static void
+mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
+{
+ MonoDomain *domain = mono_domain_get ();
+ MonoReflectionAssembly *ref_assembly;
+ MonoClass *klass;
+ MonoMethod *method;
+ void *params [1];
+
+ klass = domain->domain->mbr.obj.vtable->klass;
+
+
+ method = look_for_method_by_name (klass, "DoAssemblyLoad");
+ if (method == NULL) {
+ g_warning ("Method AppDomain.DoAssemblyLoad not found.\n");
+ return;
+ }
+
+ add_assemblies_to_domain (domain, assembly);
+
+ ref_assembly = mono_assembly_get_object (domain, assembly);
+ g_assert (ref_assembly);
+
+ *params = ref_assembly;
+ mono_runtime_invoke (method, domain->domain, params, NULL);
+}
+
+static void
+set_domain_search_path (MonoDomain *domain)
+{
+ MonoAppDomainSetup *setup;
+ gchar **tmp;
+ gchar *utf8;
+ gint i;
+ gint npaths = 0;
+ gchar **pvt_split = NULL;
+
+ if (domain->search_path != NULL)
+ return;
+
+ setup = domain->setup;
+ if (setup->application_base)
+ npaths++;
+
+ if (setup->private_bin_path) {
+ utf8 = mono_string_to_utf8 (setup->private_bin_path);
+ pvt_split = g_strsplit (utf8, G_SEARCHPATH_SEPARATOR_S, 1000);
+ g_free (utf8);
+ for (tmp = pvt_split; *tmp; tmp++, npaths++);
+ }
+
+ if (!npaths) {
+ if (pvt_split)
+ g_strfreev (pvt_split);
+ /*
+ * Don't do this because the first time is called, the domain
+ * setup is not finished.
+ *
+ * domain->search_path = g_malloc (sizeof (char *));
+ * domain->search_path [0] = NULL;
+ */
+ return;
+ }
+
+ domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
+ tmp [npaths] = NULL;
+ if (setup->application_base) {
+ *tmp = mono_string_to_utf8 (setup->application_base);
+ /* FIXME: is this needed? */
+ if (strncmp (*tmp, "file://", 7) == 0) {
+ gchar *file = *tmp;
+ *tmp = g_strdup (*tmp + 7);
+ g_free (file);
+ }
+
+ } else {
+ *tmp = g_strdup ("");
+ }
+
+ for (i = 1; pvt_split && i < npaths; i++) {
+ if (*tmp [0] == '\0' || g_path_is_absolute (pvt_split [i - 1])) {
+ tmp [i] = g_strdup (pvt_split [i - 1]);
+ continue;
+ }
+
+ tmp [i] = g_build_filename (tmp [0], pvt_split [i - 1], NULL);
+ }
+
+ if (setup->private_bin_path_probe != NULL && setup->application_base) {
+ g_free (tmp [0]);
+ tmp [0] = g_strdup ("");
+ }
+
+
+ g_strfreev (pvt_split);
+}
+
+static MonoAssembly *
+real_load (gchar **search_path, gchar *filename)
+{
+ MonoAssembly *result;
+ gchar **path;
+ gchar *fullpath;
+
+ for (path = search_path; *path; path++) {
+ if (**path == '\0')
+ continue; /* Ignore empty ApplicationBase */
+ fullpath = g_build_filename (*path, filename, NULL);
+ result = mono_assembly_open (fullpath, NULL);
+ g_free (fullpath);
+ if (result)
+ return result;
+ }
+
+ return NULL;
+}
+
+/*
+ * Try loading the assembly from ApplicationBase and PrivateBinPath
+ * and then from assemblies_path if any.
+ */
+static MonoAssembly *
+mono_domain_assembly_preload (MonoAssemblyName *aname,
+ gchar **assemblies_path,
+ gpointer user_data)
+{
+ MonoDomain *domain = mono_domain_get ();
+ MonoAssembly *result;
+ gchar *dll, *exe;
+
+ set_domain_search_path (domain);
+
+ dll = g_strconcat (aname->name, ".dll", NULL);
+ exe = g_strdup (dll);
+ strcpy (exe + strlen (exe) - 4, ".exe");
+
+ if (domain->search_path && domain->search_path [0] != NULL) {
+ /* TODO: should also search in name/name.dll and name/name.exe from appbase */
+ result = real_load (domain->search_path, dll);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+
+ result = real_load (domain->search_path, exe);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+ }
+
+ if (assemblies_path && assemblies_path [0] != NULL) {
+ result = real_load (assemblies_path, dll);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+
+ result = real_load (assemblies_path, exe);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+ }
+
+ g_free (dll);
+ g_free (exe);
+ return NULL;
+}
MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoReflectionAssemblyName *assRef, MonoObject *evidence)
+ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
{
+ MonoDomain *domain = mono_domain_get ();
char *name, *filename;
- enum MonoImageOpenStatus status = MONO_IMAGE_OK;
+ MonoImageOpenStatus status = MONO_IMAGE_OK;
MonoAssembly *ass;
+ MONO_ARCH_SAVE_REGS;
+
+ if (fname == NULL) {
+ MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
+ mono_raise_exception (exc);
+ }
+
+ name = filename = mono_string_to_utf8 (fname);
+
+ /* FIXME: move uri handling to mono_assembly_open */
+ if (strncmp (filename, "file://", 7) == 0)
+ filename += 7;
+
+ ass = mono_assembly_open (filename, &status);
+
+ g_free (name);
+
+ if (!ass){
+ MonoException *exc = mono_get_exception_file_not_found (fname);
+ mono_raise_exception (exc);
+ }
+
+ return mono_assembly_get_object (domain, ass);
+}
+
+static void
+free_assembly_name (MonoAssemblyName *aname)
+{
+ if (aname == NULL)
+ return;
+
+ g_free ((void *) aname->name);
+ g_free ((void *) aname->culture);
+ g_free ((void *) aname->hash_value);
+}
+
+static gboolean
+get_info_from_assembly_name (MonoReflectionAssemblyName *assRef, MonoAssemblyName *aname)
+{
+ gchar *name;
+ gchar *value;
+ gchar **parts;
+ gchar **tmp;
+ gint major, minor, build, revision;
+
+ memset (aname, 0, sizeof (MonoAssemblyName));
+
+ name = mono_string_to_utf8 (assRef->name);
+ parts = tmp = g_strsplit (name, ",", 4);
+ g_free (name);
+ if (!tmp || !*tmp) {
+ g_strfreev (tmp);
+ return FALSE;
+ }
+
+ value = g_strstrip (*tmp);
+ /* g_print ("Assembly name: %s\n", value); */
+ aname->name = g_strdup (value);
+ tmp++;
+ if (!*tmp) {
+ g_strfreev (parts);
+ return TRUE;
+ }
+
+ value = g_strstrip (*tmp);
+ if (strncmp (value, "Version=", 8)) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ if (sscanf (value + 8, "%u.%u.%u.%u", &major, &minor, &build, &revision) != 4) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ /* g_print ("Version: %u.%u.%u.%u\n", major, minor, build, revision); */
+ aname->major = major;
+ aname->minor = minor;
+ aname->build = build;
+ aname->revision = revision;
+ tmp++;
+
+ if (!*tmp) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ value = g_strstrip (*tmp);
+ if (strncmp (value, "Culture=", 8)) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ /* g_print ("Culture: %s\n", aname->culture); */
+ aname->culture = g_strstrip (g_strdup (value + 8));
+ tmp++;
+
+ if (!*tmp) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ value = g_strstrip (*tmp);
+ if (strncmp (value, "PublicKeyToken=", 15)) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ value += 15;
+ if (*value && strcmp (value, "null")) {
+ gint i, len;
+ gchar h, l;
+ gchar *result;
+
+ value = g_strstrip (g_strdup (value));
+ len = strlen (value);
+ if (len % 2) {
+ g_free (value);
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ aname->hash_len = len / 2;
+ aname->hash_value = g_malloc0 (aname->hash_len);
+ result = (gchar *) aname->hash_value;
+
+ for (i = 0; i < len; i++) {
+ if (i % 2) {
+ l = g_ascii_xdigit_value (value [i]);
+ if (l == -1) {
+ g_free (value);
+ g_strfreev (parts);
+ return FALSE;
+ }
+ result [i / 2] = (h * 16) + l;
+ } else {
+ h = g_ascii_xdigit_value (value [i]);
+ if (h == -1) {
+ g_free (value);
+ g_strfreev (parts);
+ return FALSE;
+ }
+ }
+ }
+ g_free (value);
+
+ /*
+ g_print ("PublicKeyToken: ");
+ for (i = 0; i < aname->hash_len; i++) {
+ g_print ("%x", 0x00FF & aname->hash_value [i]);
+ }
+ g_print ("\n");
+ */
+ }
+
+ g_strfreev (parts);
+ return TRUE;
+}
+
+MonoReflectionAssembly *
+ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoReflectionAssemblyName *assRef, MonoObject *evidence)
+{
+ MonoDomain *domain = ad->data;
+ MonoImageOpenStatus status = MONO_IMAGE_OK;
+ MonoAssembly *ass;
+ MonoAssemblyName aname;
+ MonoReflectionAssembly *refass = NULL;
+
+ MONO_ARCH_SAVE_REGS;
+
+ memset (&aname, 0, sizeof (aname));
+
/* FIXME : examine evidence? */
g_assert (assRef != NULL);
g_assert (assRef->name != NULL);
- /* FIXME : examine version, culture info */
+ if (!get_info_from_assembly_name (assRef, &aname)) {
+ MonoException *exc;
- name = filename = mono_string_to_utf8 (assRef->name);
+ free_assembly_name (&aname);
+ /* This is a parse error... */
+ exc = mono_get_exception_file_not_found (assRef->name);
+ mono_raise_exception (exc);
+ }
- if (strncmp (filename, "file://", 7) == 0)
- filename += 7;
+ ass = mono_assembly_load (&aname, NULL, &status);
+ free_assembly_name (&aname);
- ass = mono_assembly_open (filename, NULL, &status);
-
- g_free (name);
+ if (!ass && (refass = try_assembly_resolve (domain, assRef->name)) == NULL){
+ /* FIXME: it doesn't make much sense since we really don't have a filename ... */
+ MonoException *exc = mono_get_exception_file_not_found (assRef->name);
+ mono_raise_exception (exc);
+ }
- if (!ass)
- mono_raise_exception ((MonoException *)mono_exception_from_name (
- mono_defaults.corlib, "System.IO", "FileNotFoundException"));
+ if (refass != NULL)
+ return refass;
- return mono_assembly_get_object (ass);
+ return mono_assembly_get_object (domain, ass);
}
void
-ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
+ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
{
- g_warning ("AppDomain_Unload not implemented");
+ MonoDomain * domain = mono_domain_get_by_id (domain_id);
+
+ MONO_ARCH_SAVE_REGS;
+
+ if (NULL == domain) {
+ MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
+ mono_raise_exception (exc);
+ }
+
+
+ mono_domain_unload (domain, FALSE);
}
gint32
ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
MonoObject *evidence, MonoArray *args)
{
- MonoAppDomainData *cdom = mono_appdomain_get ();
MonoAssembly *assembly;
MonoImage *image;
- MonoCLIImageInfo *iinfo;
MonoMethod *method;
- gint32 (*mfunc) (MonoArray* args);
char *filename;
gint32 res;
- mono_appdomain_set (ad->data);
+ MONO_ARCH_SAVE_REGS;
filename = mono_string_to_utf8 (file);
- assembly = mono_assembly_open (filename, NULL, NULL);
+ assembly = mono_assembly_open (filename, NULL);
g_free (filename);
if (!assembly) {
mono_raise_exception ((MonoException *)mono_exception_from_name (
- mono_defaults.corlib, "System.IO", "FileNotFoundException"));
+ mono_defaults.corlib, "System.IO", "FileNotFoundException"));
}
image = assembly->image;
- iinfo = image->image_info;
- method = mono_get_method (image, iinfo->cli_cli_header.ch_entry_point, NULL);
+
+ method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
if (!method)
g_error ("No entry point method found in %s", image->name);
- res = mono_runtime_exec_main (method, args);
+ if (!args)
+ args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
- mono_appdomain_set (cdom);
+ res = mono_runtime_exec_main (method, (MonoArray *)args, NULL);
return res;
}
+
+gint32
+ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
+{
+ MONO_ARCH_SAVE_REGS;
+
+ return ad->data->domain_id;
+}
+
+MonoAppDomain *
+ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad)
+{
+ MonoDomain *old_domain = mono_domain_get();
+
+ MONO_ARCH_SAVE_REGS;
+
+ mono_domain_set(ad->data);
+
+ return old_domain->domain;
+}
+
+MonoAppDomain *
+ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid)
+{
+ MonoDomain *current_domain = mono_domain_get ();
+ MonoDomain *domain = mono_domain_get_by_id (domainid);
+
+ MONO_ARCH_SAVE_REGS;
+
+ mono_domain_set (domain);
+
+ return current_domain->domain;
+}
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalGetContext ()
+{
+ MONO_ARCH_SAVE_REGS;
+
+ return mono_context_get ();
+}
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
+{
+ MonoAppContext *old_context = mono_context_get ();
+ MonoDomain *context_domain = mono_domain_get_by_id (mc->domain_id);
+
+ MONO_ARCH_SAVE_REGS;
+
+ mono_context_set (mc);
+ mono_domain_set (context_domain);
+
+ return old_context;
+}
projects / mono.git / blobdiff