XXX implement options
*/
static void*
-open_file_map (MonoString *path, int input_fd, int mode, gint64 *capacity, int access, int options, int *ioerror)
+open_file_map (const char *c_path, int input_fd, int mode, gint64 *capacity, int access, int options, int *ioerror)
{
- MonoError error;
struct stat buf;
- char *c_path = NULL;
MmapHandle *handle = NULL;
int result, fd;
- if (path) {
- c_path = mono_string_to_utf8_checked (path, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
- }
-
- if (path)
+ if (c_path)
result = stat (c_path, &buf);
else
result = fstat (input_fd, &buf);
}
}
- if (path) //FIXME use io portability?
+ if (c_path) //FIXME use io portability?
fd = open (c_path, file_mode_to_unix (mode) | access_mode_to_unix (access), DEFAULT_FILEMODE);
else
fd = dup (input_fd);
handle->fd = fd;
done:
- g_free (c_path);
return (void*)handle;
}
#define MONO_ANON_FILE_TEMPLATE "/mono.anonmap.XXXXXXXXX"
static void*
-open_memory_map (MonoString *mapName, int mode, gint64 *capacity, int access, int options, int *ioerror)
+open_memory_map (const char *c_mapName, int mode, gint64 *capacity, int access, int options, int *ioerror)
{
- MonoError error;
- char *c_mapName;
MmapHandle *handle;
if (*capacity <= 1) {
*ioerror = CAPACITY_MUST_BE_POSITIVE;
return NULL;
}
- c_mapName = mono_string_to_utf8_checked (mapName, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
-
named_regions_lock ();
handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName);
if (handle) {
done:
named_regions_unlock ();
- g_free (c_mapName);
return handle;
}
+/* This is an icall */
void *
mono_mmap_open_file (MonoString *path, int mode, MonoString *mapName, gint64 *capacity, int access, int options, int *ioerror)
{
MonoError error;
+ MmapHandle *handle = NULL;
g_assert (path || mapName);
- if (!mapName)
- return open_file_map (path, -1, mode, capacity, access, options, ioerror);
+ if (!mapName) {
+ char * c_path = mono_string_to_utf8_checked (path, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ handle = open_file_map (c_path, -1, mode, capacity, access, options, ioerror);
+ g_free (c_path);
+ return handle;
+ }
- if (path) {
- MmapHandle *handle;
- char *c_mapName = mono_string_to_utf8_checked (mapName, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ char *c_mapName = mono_string_to_utf8_checked (mapName, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ if (path) {
named_regions_lock ();
handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName);
if (handle) {
*ioerror = FILE_ALREADY_EXISTS;
handle = NULL;
} else {
- handle = (MmapHandle *)open_file_map (path, -1, mode, capacity, access, options, ioerror);
- if (handle) {
- handle->name = g_strdup (c_mapName);
- g_hash_table_insert (named_regions, handle->name, handle);
+ char *c_path = mono_string_to_utf8_checked (path, &error);
+ if (is_ok (&error)) {
+ handle = (MmapHandle *)open_file_map (c_path, -1, mode, capacity, access, options, ioerror);
+ if (handle) {
+ handle->name = g_strdup (c_mapName);
+ g_hash_table_insert (named_regions, handle->name, handle);
+ }
+ } else {
+ handle = NULL;
}
+ g_free (c_path);
}
named_regions_unlock ();
+ } else
+ handle = open_memory_map (c_mapName, mode, capacity, access, options, ioerror);
- g_free (c_mapName);
- return handle;
- }
-
- return open_memory_map (mapName, mode, capacity, access, options, ioerror);
+ g_free (c_mapName);
+ return handle;
}
+/* this is an icall */
void *
mono_mmap_open_handle (void *input_fd, MonoString *mapName, gint64 *capacity, int access, int options, int *ioerror)
{
handle = (MmapHandle *)open_file_map (NULL, GPOINTER_TO_INT (input_fd), FILE_MODE_OPEN, capacity, access, options, ioerror);
} else {
char *c_mapName = mono_string_to_utf8_checked (mapName, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
named_regions_lock ();
handle = (MmapHandle*)g_hash_table_lookup (named_regions, c_mapName);
}
static int
-id_from_string (MonoString *instance, gboolean is_process)
+id_from_string (const gchar *id_str, gboolean is_process)
{
- MonoError error;
int id = -1;
- if (mono_string_length (instance)) {
- char *id_str = mono_string_to_utf8_checked (instance, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (strcmp("", id_str) != 0) {
char *end;
id = strtol (id_str, &end, 0);
if (end == id_str && !is_process)
id = -1;
- g_free (id_str);
}
return id;
}
}
static void*
-cpu_get_impl (MonoString* counter, MonoString* instance, int *type, MonoBoolean *custom)
+cpu_get_impl (MonoString* counter, const gchar* instance, int *type, MonoBoolean *custom)
{
int id = id_from_string (instance, FALSE) << 5;
const CounterDesc *cdesc;
}
static void*
-network_get_impl (MonoString* counter, MonoString* instance, int *type, MonoBoolean *custom)
+network_get_impl (MonoString* counter, const gchar* instance, int *type, MonoBoolean *custom)
{
- MonoError error;
const CounterDesc *cdesc;
NetworkVtableArg *narg;
ImplVtable *vtable;
*custom = FALSE;
if ((cdesc = get_counter_in_category (&predef_categories [CATEGORY_NETWORK], counter))) {
- instance_name = mono_string_to_utf8_checked (instance, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ instance_name = g_strdup (instance);
narg = g_new0 (NetworkVtableArg, 1);
narg->id = cdesc->id;
narg->name = instance_name;
}
static void*
-process_get_impl (MonoString* counter, MonoString* instance, int *type, MonoBoolean *custom)
+process_get_impl (MonoString* counter, const gchar* instance, int *type, MonoBoolean *custom)
{
int id = id_from_string (instance, TRUE) << 5;
const CounterDesc *cdesc;
}
static void*
-mono_mem_get_impl (MonoString* counter, MonoString* instance, int *type, MonoBoolean *custom)
+mono_mem_get_impl (MonoString* counter, const gchar* instance, int *type, MonoBoolean *custom)
{
const CounterDesc *cdesc;
*custom = FALSE;
}
static ImplVtable*
-predef_vtable (void *arg, MonoString *instance)
+predef_vtable (void *arg, const gchar *pids)
{
- MonoError error;
MonoSharedArea *area;
PredefVtable *vtable;
- char *pids = mono_string_to_utf8_checked (instance, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
int pid;
pid = atoi (pids);
- g_free (pids);
area = load_sarea_for_pid (pid);
if (!area)
return NULL;
}
static void*
-predef_writable_get_impl (int cat, MonoString* counter, MonoString* instance, int *type, MonoBoolean *custom)
+predef_writable_get_impl (int cat, MonoString* counter, const gchar *instance, int *type, MonoBoolean *custom)
{
const CounterDesc *cdesc;
*custom = TRUE;
if ((cdesc = get_counter_in_category (&predef_categories [cat], counter))) {
*type = cdesc->type;
- if (instance == NULL || mono_string_compare_ascii (instance, "") == 0)
+ if (instance == NULL || strcmp (instance, "") == 0)
return create_vtable (GINT_TO_POINTER ((cdesc->id << 16) | cat), predef_writable_counter, predef_writable_update);
else
return predef_vtable (GINT_TO_POINTER ((cdesc->id << 16) | cat), instance);
}
static void*
-custom_get_impl (SharedCategory *cat, MonoString* counter, MonoString* instance, int *type)
+custom_get_impl (SharedCategory *cat, MonoString *counter, MonoString* instance, int *type, MonoError *error)
{
- MonoError error;
SharedCounter *scounter;
SharedInstance* inst;
char *name;
+ mono_error_init (error);
scounter = find_custom_counter (cat, counter);
if (!scounter)
return NULL;
+ name = mono_string_to_utf8_checked (counter, error);
+ return_val_if_nok (error, NULL);
*type = simple_type_to_type [scounter->type];
- name = mono_string_to_utf8_checked (counter, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
inst = custom_get_instance (cat, scounter, name);
g_free (name);
if (!inst)
mono_perfcounter_get_impl (MonoString* category, MonoString* counter, MonoString* instance,
MonoString* machine, int *type, MonoBoolean *custom)
{
+ MonoError error;
const CategoryDesc *cdesc;
+ void *result = NULL;
/* no support for counters on other machines */
if (mono_string_compare_ascii (machine, "."))
return NULL;
if (!scat)
return NULL;
*custom = TRUE;
- return custom_get_impl (scat, counter, instance, type);
+ result = custom_get_impl (scat, counter, instance, type, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ return result;
}
+ gchar *c_instance = mono_string_to_utf8_checked (instance, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
switch (cdesc->id) {
case CATEGORY_CPU:
- return cpu_get_impl (counter, instance, type, custom);
+ result = cpu_get_impl (counter, c_instance, type, custom);
+ break;
case CATEGORY_PROC:
- return process_get_impl (counter, instance, type, custom);
+ result = process_get_impl (counter, c_instance, type, custom);
+ break;
case CATEGORY_MONO_MEM:
- return mono_mem_get_impl (counter, instance, type, custom);
+ result = mono_mem_get_impl (counter, c_instance, type, custom);
+ break;
case CATEGORY_NETWORK:
- return network_get_impl (counter, instance, type, custom);
+ result = network_get_impl (counter, c_instance, type, custom);
+ break;
case CATEGORY_JIT:
case CATEGORY_EXC:
case CATEGORY_GC:
case CATEGORY_SECURITY:
case CATEGORY_ASPNET:
case CATEGORY_THREADPOOL:
- return predef_writable_get_impl (cdesc->id, counter, instance, type, custom);
+ result = predef_writable_get_impl (cdesc->id, counter, c_instance, type, custom);
+ break;
}
- return NULL;
+ g_free (c_instance);
+ return result;
}
MonoBoolean
if (!scat)
return FALSE;
name = mono_string_to_utf8_checked (instance, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
sinst = find_custom_instance (scat, name);
g_free (name);
if (sinst)
}
static guint32
-string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str)
+string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
- char *name = mono_string_to_utf8_checked (str, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ mono_error_init (error);
+ char *name = mono_string_to_utf8_checked (str, error);
+ return_val_if_nok (error, -1);
guint32 idx;
idx = string_heap_insert (sh, name);
g_free (name);
*mb->table_idx = table->next_idx ++;
g_hash_table_insert (assembly->method_to_table_idx, mb->mhandle, GUINT_TO_POINTER ((*mb->table_idx)));
values = table->values + *mb->table_idx * MONO_METHOD_SIZE;
- values [MONO_METHOD_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name);
+ values [MONO_METHOD_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name, error);
+ return_val_if_nok (error, FALSE);
values [MONO_METHOD_FLAGS] = mb->attrs;
values [MONO_METHOD_IMPLFLAGS] = mb->iattrs;
values [MONO_METHOD_SIGNATURE] = method_builder_encode_signature (assembly, mb, error);
values [MONO_PARAM_FLAGS] = pb->attrs;
values [MONO_PARAM_SEQUENCE] = i;
if (pb->name != NULL) {
- values [MONO_PARAM_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name);
+ values [MONO_PARAM_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name, error);
+ return_val_if_nok (error, FALSE);
} else {
values [MONO_PARAM_NAME] = 0;
}
values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | ncharset | extra_flags;
values [MONO_IMPLMAP_MEMBER] = (mb->table_idx << 1) | 1; /* memberforwarded: method */
- if (mb->dllentry)
- values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->dllentry);
- else
- values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name);
- moduleref = string_heap_insert_mstring (&assembly->sheap, mb->dll);
+ if (mb->dllentry) {
+ values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->dllentry, error);
+ return_val_if_nok (error, FALSE);
+ } else {
+ values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name, error);
+ return_val_if_nok (error, FALSE);
+ }
+ moduleref = string_heap_insert_mstring (&assembly->sheap, mb->dll, error);
+ return_val_if_nok (error, FALSE);
if (!(values [MONO_IMPLMAP_SCOPE] = find_index_in_table (assembly, MONO_TABLE_MODULEREF, MONO_MODULEREF_NAME, moduleref))) {
table = &assembly->tables [MONO_TABLE_MODULEREF];
table->rows ++;
fb->table_idx = table->next_idx ++;
g_hash_table_insert (assembly->field_to_table_idx, fb->handle, GUINT_TO_POINTER (fb->table_idx));
values = table->values + fb->table_idx * MONO_FIELD_SIZE;
- values [MONO_FIELD_NAME] = string_heap_insert_mstring (&assembly->sheap, fb->name);
+ values [MONO_FIELD_NAME] = string_heap_insert_mstring (&assembly->sheap, fb->name, error);
+ return_if_nok (error);
values [MONO_FIELD_FLAGS] = fb->attrs;
values [MONO_FIELD_SIGNATURE] = field_encode_signature (assembly, fb, error);
return_if_nok (error);
table = &assembly->tables [MONO_TABLE_PROPERTY];
pb->table_idx = table->next_idx ++;
values = table->values + pb->table_idx * MONO_PROPERTY_SIZE;
- values [MONO_PROPERTY_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name);
+ values [MONO_PROPERTY_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name, error);
+ return_if_nok (error);
values [MONO_PROPERTY_FLAGS] = pb->attrs;
values [MONO_PROPERTY_TYPE] = property_encode_signature (assembly, pb, error);
return_if_nok (error);
table = &assembly->tables [MONO_TABLE_EVENT];
eb->table_idx = table->next_idx ++;
values = table->values + eb->table_idx * MONO_EVENT_SIZE;
- values [MONO_EVENT_NAME] = string_heap_insert_mstring (&assembly->sheap, eb->name);
+ values [MONO_EVENT_NAME] = string_heap_insert_mstring (&assembly->sheap, eb->name, error);
+ return_if_nok (error);
values [MONO_EVENT_FLAGS] = eb->attrs;
MonoType *ebtype = mono_reflection_type_get_handle (eb->type, error);
return_if_nok (error);
return TRUE;
}
-static void
-mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly)
+static gboolean
+mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly, MonoError *error)
{
- MonoError error;
MonoDynamicTable *table;
guint32 *values;
char blob_size [6];
char *b = blob_size;
char *dir, *path;
+ mono_error_init (error);
+
table = &assembly->tables [MONO_TABLE_FILE];
table->rows++;
alloc_table (table, table->rows);
values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, module->image->module_name);
if (image_is_dynamic (module->image)) {
/* This depends on the fact that the main module is emitted last */
- dir = mono_string_to_utf8_checked (((MonoReflectionModuleBuilder*)module)->assemblyb->dir, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ dir = mono_string_to_utf8_checked (((MonoReflectionModuleBuilder*)module)->assemblyb->dir, error);
+ return_val_if_nok (error, FALSE);
path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
} else {
dir = NULL;
values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
table->next_idx ++;
+ return TRUE;
}
static void
-mono_image_fill_module_table (MonoDomain *domain, MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly)
+mono_image_fill_module_table (MonoDomain *domain, MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
{
MonoDynamicTable *table;
int i;
+ mono_error_init (error);
+
table = &assembly->tables [MONO_TABLE_MODULE];
mb->table_idx = table->next_idx ++;
- table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->module.name);
+ table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->module.name, error);
+ return_if_nok (error);
i = mono_image_add_stream_data (&assembly->guid, mono_array_addr (mb->guid, char, 0), 16);
i /= 16;
++i;
}
}
-static void
-assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, guint32 implementation)
+static gboolean
+assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, guint32 implementation, MonoError *error)
{
MonoDynamicTable *table;
guint32 *values;
+ mono_error_init (error);
+
table = &assembly->tables [MONO_TABLE_MANIFESTRESOURCE];
table->rows++;
alloc_table (table, table->rows);
values = table->values + table->next_idx * MONO_MANIFEST_SIZE;
values [MONO_MANIFEST_OFFSET] = rsrc->offset;
values [MONO_MANIFEST_FLAGS] = rsrc->attrs;
- values [MONO_MANIFEST_NAME] = string_heap_insert_mstring (&assembly->sheap, rsrc->name);
+ values [MONO_MANIFEST_NAME] = string_heap_insert_mstring (&assembly->sheap, rsrc->name, error);
+ return_val_if_nok (error, FALSE);
values [MONO_MANIFEST_IMPLEMENTATION] = implementation;
table->next_idx++;
+ return TRUE;
}
-static void
-assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc)
+static gboolean
+assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, MonoError *error)
{
- MonoError error;
MonoDynamicTable *table;
guint32 *values;
char blob_size [6];
char *name, *sname;
guint32 idx, offset;
+ mono_error_init (error);
+
if (rsrc->filename) {
- name = mono_string_to_utf8_checked (rsrc->filename, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ name = mono_string_to_utf8_checked (rsrc->filename, error);
+ return_val_if_nok (error, FALSE);
sname = g_path_get_basename (name);
table = &assembly->tables [MONO_TABLE_FILE];
* the main module, but that needs to reference the FILE table
* which isn't emitted yet.
*/
- return;
+ return TRUE;
else
idx = 0;
}
- assembly_add_resource_manifest (mb, assembly, rsrc, idx);
+ return assembly_add_resource_manifest (mb, assembly, rsrc, idx, error);
}
-static void
-set_version_from_string (MonoString *version, guint32 *values)
+static gboolean
+set_version_from_string (MonoString *version, guint32 *values, MonoError *error)
{
- MonoError error;
gchar *ver, *p, *str;
guint32 i;
+ mono_error_init (error);
+
values [MONO_ASSEMBLY_MAJOR_VERSION] = 0;
values [MONO_ASSEMBLY_MINOR_VERSION] = 0;
values [MONO_ASSEMBLY_REV_NUMBER] = 0;
values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
if (!version)
- return;
- ver = str = mono_string_to_utf8_checked (version, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ return TRUE;
+ ver = str = mono_string_to_utf8_checked (version, error);
+ return_val_if_nok (error, FALSE);
for (i = 0; i < 4; ++i) {
values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
switch (*p) {
ver = p;
}
g_free (str);
+ return TRUE;
}
static guint32
return token;
}
-static void
+static gboolean
mono_image_emit_manifest (MonoReflectionModuleBuilder *moduleb, MonoError *error)
{
MonoDynamicTable *table;
alloc_table (table, 1);
values = table->values + MONO_ASSEMBLY_SIZE;
values [MONO_ASSEMBLY_HASH_ALG] = assemblyb->algid? assemblyb->algid: ASSEMBLY_HASH_SHA1;
- values [MONO_ASSEMBLY_NAME] = string_heap_insert_mstring (&assembly->sheap, assemblyb->name);
+ values [MONO_ASSEMBLY_NAME] = string_heap_insert_mstring (&assembly->sheap, assemblyb->name, error);
+ return_val_if_nok (error, FALSE);
if (assemblyb->culture) {
- values [MONO_ASSEMBLY_CULTURE] = string_heap_insert_mstring (&assembly->sheap, assemblyb->culture);
+ values [MONO_ASSEMBLY_CULTURE] = string_heap_insert_mstring (&assembly->sheap, assemblyb->culture, error);
+ return_val_if_nok (error, FALSE);
} else {
values [MONO_ASSEMBLY_CULTURE] = string_heap_insert (&assembly->sheap, "");
}
values [MONO_ASSEMBLY_PUBLIC_KEY] = load_public_key (assemblyb->public_key, assembly);
values [MONO_ASSEMBLY_FLAGS] = assemblyb->flags;
- set_version_from_string (assemblyb->version, values);
+ if (!set_version_from_string (assemblyb->version, values, error))
+ return FALSE;
/* Emit FILE + EXPORTED_TYPE table */
module_index = 0;
MonoReflectionModuleBuilder *file_module =
mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
if (file_module != moduleb) {
- mono_image_fill_file_table (domain, (MonoReflectionModule*)file_module, assembly);
+ if (!mono_image_fill_file_table (domain, (MonoReflectionModule*)file_module, assembly, error))
+ return FALSE;
module_index ++;
if (file_module->types) {
for (j = 0; j < file_module->num_types; ++j) {
MonoReflectionTypeBuilder *tb = mono_array_get (file_module->types, MonoReflectionTypeBuilder*, j);
mono_image_fill_export_table (domain, tb, module_index, 0, assembly, error);
- return_if_nok (error);
+ return_val_if_nok (error, FALSE);
}
}
}
for (i = 0; i < mono_array_length (assemblyb->loaded_modules); ++i) {
MonoReflectionModule *file_module =
mono_array_get (assemblyb->loaded_modules, MonoReflectionModule*, i);
- mono_image_fill_file_table (domain, file_module, assembly);
+ if (!mono_image_fill_file_table (domain, file_module, assembly, error))
+ return FALSE;
module_index ++;
mono_image_fill_export_table_from_module (domain, file_module, module_index, assembly);
}
int len = mono_array_length (file_module->resources);
for (j = 0; j < len; ++j) {
MonoReflectionResource* res = (MonoReflectionResource*)mono_array_addr (file_module->resources, MonoReflectionResource, j);
- assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS));
+ if (!assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS), error))
+ return FALSE;
}
}
}
- }
+ }
+ return TRUE;
}
#ifndef DISABLE_REFLECTION_EMIT_SAVE
table = &assembly->tables [MONO_TABLE_MODULE];
alloc_table (table, 1);
- mono_image_fill_module_table (domain, moduleb, assembly);
+ mono_image_fill_module_table (domain, moduleb, assembly, error);
+ if (!is_ok (error))
+ goto leave;
/* Collect all types into a list sorted by their table_idx */
mono_ptr_array_init (types, moduleb->num_types, MONO_ROOT_SOURCE_REFLECTION, "dynamic module types list");
*/
for (i = 0; i < mono_ptr_array_size (types); ++i) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
- string_heap_insert_mstring (&assembly->sheap, tb->nspace);
+ string_heap_insert_mstring (&assembly->sheap, tb->nspace, error);
+ if (!is_ok (error))
+ goto leave_types;
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
- string_heap_insert_mstring (&assembly->sheap, tb->name);
+ string_heap_insert_mstring (&assembly->sheap, tb->name, error);
+ if (!is_ok (error))
+ goto leave_types;
}
for (i = 0; i < mono_ptr_array_size (types); ++i) {
assembly->assembly.corlib_internal = assemblyb->corlib_internal;
assemblyb->assembly.assembly = (MonoAssembly*)assembly;
assembly->assembly.basedir = mono_string_to_utf8_checked (assemblyb->dir, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (mono_error_set_pending_exception (&error))
+ return;
if (assemblyb->culture) {
assembly->assembly.aname.culture = mono_string_to_utf8_checked (assemblyb->culture, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (mono_error_set_pending_exception (&error))
+ return;
} else
assembly->assembly.aname.culture = g_strdup ("");
if (assemblyb->version) {
char *vstr = mono_string_to_utf8_checked (assemblyb->version, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (mono_error_set_pending_exception (&error))
+ return;
char **version = g_strsplit (vstr, ".", 4);
char **parts = version;
assembly->assembly.aname.major = atoi (*parts++);
assembly->domain = domain;
char *assembly_name = mono_string_to_utf8_checked (assemblyb->name, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (mono_error_set_pending_exception (&error))
+ return;
image = create_dynamic_mono_image (assembly, assembly_name, g_strdup ("RefEmit_YouForgotToDefineAModule"));
image->initial_image = TRUE;
assembly->assembly.aname.name = image->image.name;
if (mb->is_main && assemblyb->resources) {
int len = mono_array_length (assemblyb->resources);
- for (i = 0; i < len; ++i)
- assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (assemblyb->resources, MonoReflectionResource, i));
+ for (i = 0; i < len; ++i) {
+ if (!assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (assemblyb->resources, MonoReflectionResource, i), error))
+ return FALSE;
+ }
}
if (mb->resources) {
int len = mono_array_length (mb->resources);
- for (i = 0; i < len; ++i)
- assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i));
+ for (i = 0; i < len; ++i) {
+ if (!assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i), error))
+ return FALSE;
+ }
}
if (!build_compressed_metadata (assembly, error))
projects / mono.git / commitdiff