#ifndef DISABLE_REFLECTION_EMIT
static guint32 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec);
-static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_open_instance);
-static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb);
+static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_open_instance, MonoError *error);
+static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb, MonoError *error);
static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper);
static void ensure_runtime_vtable (MonoClass *klass);
static gpointer resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context);
-static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method);
+static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method, MonoError *error);
static guint32 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context);
static gpointer register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
-static void reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb);
-static void reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb);
+static gboolean reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb, MonoError *error);
+static gboolean reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb, MonoError *error);
static guint32 create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb);
#endif
}
#ifndef DISABLE_REFLECTION_EMIT
-static void
-reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb)
+static gboolean
+reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb, MonoError *error)
{
- MonoError error;
MONO_REQ_GC_UNSAFE_MODE;
+ mono_error_init (error);
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
rmb->ilgen = mb->ilgen;
- rmb->rtype = mono_reflection_type_resolve_user_types ((MonoReflectionType*)mb->rtype, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ rmb->rtype = mono_reflection_type_resolve_user_types ((MonoReflectionType*)mb->rtype, error);
+ return_val_if_nok (error, FALSE);
rmb->parameters = mb->parameters;
rmb->generic_params = mb->generic_params;
rmb->generic_container = mb->generic_container;
rmb->dllentry = mb->dllentry;
rmb->dll = mb->dll;
}
+
+ return TRUE;
}
-static void
-reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb)
+static gboolean
+reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
+ mono_error_init (error);
+
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
rmb->ilgen = mb->ilgen;
- rmb->rtype = mono_type_get_object_checked (mono_domain_get (), &mono_defaults.void_class->byval_arg, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ rmb->rtype = mono_type_get_object_checked (mono_domain_get (), &mono_defaults.void_class->byval_arg, error);
+ return_val_if_nok (error, FALSE);
rmb->parameters = mb->parameters;
rmb->generic_params = NULL;
rmb->generic_container = NULL;
rmb->mhandle = mb->mhandle;
rmb->nrefs = 0;
rmb->refs = NULL;
+
+ return TRUE;
}
static void
}
#ifndef DISABLE_REFLECTION_EMIT
-static void
-mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
+static gboolean
+mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
-
MonoDynamicTable *table;
guint32 *values;
ReflectionMethodBuilder rmb;
int i;
- reflection_methodbuilder_from_method_builder (&rmb, mb);
+ mono_error_init (error);
+
+ if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error) ||
+ !mono_image_basic_method (&rmb, assembly, error))
+ return FALSE;
- mono_image_basic_method (&rmb, assembly, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
mb->table_idx = *rmb.table_idx;
if (mb->dll) { /* It's a P/Invoke method */
}
}
+ return TRUE;
}
static gboolean
ReflectionMethodBuilder rmb;
- reflection_methodbuilder_from_ctor_builder (&rmb, mb);
+ if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
+ return FALSE;
if (!mono_image_basic_method (&rmb, assembly, error))
return FALSE;
g_ptr_array_add (assembly->gen_params, entry);
}
-static void
-write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry)
+static gboolean
+write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
- MonoError error;
-
MonoDynamicTable *table;
MonoGenericParam *param;
guint32 *values;
guint32 table_idx;
+ mono_error_init (error);
+
table = &assembly->tables [MONO_TABLE_GENERICPARAM];
table_idx = table->next_idx ++;
values = table->values + table_idx * MONO_GENERICPARAM_SIZE;
values [MONO_GENERICPARAM_NUMBER] = mono_generic_param_num (param);
values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, mono_generic_param_info (param)->name);
- if (!mono_image_add_cattrs (assembly, table_idx, MONO_CUSTOM_ATTR_GENERICPAR, entry->gparam->cattrs, &error))
- goto fail;
+ if (!mono_image_add_cattrs (assembly, table_idx, MONO_CUSTOM_ATTR_GENERICPAR, entry->gparam->cattrs, error))
+ return FALSE;
encode_constraints (entry->gparam, table_idx, assembly);
- return;
-fail:
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ return TRUE;
}
static guint32
}
static guint32
-mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method)
+mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method, MonoError *error)
{
guint32 token, parent, sig;
ReflectionMethodBuilder rmb;
- char *name;
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)method->type;
+ mono_error_init (error);
token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
if (token)
return token;
- name = mono_string_to_utf8 (method->name);
- reflection_methodbuilder_from_method_builder (&rmb, method);
+ if (!reflection_methodbuilder_from_method_builder (&rmb, method, error))
+ return 0;
/*
* A methodref signature can't contain an unmanaged calling convention.
else
parent = mono_image_typedef_or_ref (assembly, mono_reflection_type_get_handle ((MonoReflectionType*)rmb.type));
- token = mono_image_add_memberef_row (assembly, parent, name, sig);
+ char *name = mono_string_to_utf8 (method->name);
+ token = mono_image_add_memberef_row (assembly, parent, name, sig);
g_free (name);
+
g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
+
return token;
}
}
static guint32
-mono_image_get_methodspec_token_for_generic_method_definition (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
+mono_image_get_methodspec_token_for_generic_method_definition (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, MonoError *error)
{
MonoDynamicTable *table;
guint32 *values;
guint32 token, mtoken = 0;
+ mono_error_init (error);
token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->methodspec, mb));
if (token)
return token;
table = &assembly->tables [MONO_TABLE_METHODSPEC];
- mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
+ mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb, error);
+ if (!mono_error_ok (error))
+ return 0;
+
switch (mono_metadata_token_table (mtoken)) {
case MONO_TABLE_MEMBERREF:
mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
}
static guint32
-mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec)
+mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec, MonoError *error)
{
guint32 token;
+ mono_error_init (error);
+
if (mb->generic_params && create_methodspec)
- return mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb);
+ return mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb, error);
token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, mb));
if (token)
return token;
- token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
+ token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb, error);
+ if (!mono_error_ok (error))
+ return 0;
mono_g_hash_table_insert (assembly->handleref_managed, mb, GUINT_TO_POINTER(token));
return token;
}
static guint32
-mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *mb)
+mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *mb, MonoError *error)
{
guint32 token, parent, sig;
ReflectionMethodBuilder rmb;
char *name;
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
+ mono_error_init (error);
+
token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, mb));
if (token)
return token;
- reflection_methodbuilder_from_ctor_builder (&rmb, mb);
+ if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
+ return 0;
if (tb->generic_params)
parent = create_generic_typespec (assembly, tb);
}
static guint32
-mono_image_get_ctor_on_inst_token (MonoDynamicImage *assembly, MonoReflectionCtorOnTypeBuilderInst *c, gboolean create_methodspec)
+mono_image_get_ctor_on_inst_token (MonoDynamicImage *assembly, MonoReflectionCtorOnTypeBuilderInst *c, gboolean create_methodspec, MonoError *error)
{
guint32 sig, token;
MonoClass *klass;
MonoGenericClass *gclass;
MonoType *type;
+ mono_error_init (error);
+
/* A ctor cannot be a generic method, so we can ignore create_methodspec */
token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, c));
gclass = type->data.generic_class;
g_assert (gclass->is_dynamic);
- reflection_methodbuilder_from_ctor_builder (&rmb, cb);
+ if (!reflection_methodbuilder_from_ctor_builder (&rmb, cb, error))
+ return 0;
name = mono_string_to_utf8 (rmb.name);
}
static guint32
-mono_image_get_method_on_inst_token (MonoDynamicImage *assembly, MonoReflectionMethodOnTypeBuilderInst *m, gboolean create_methodspec)
+mono_image_get_method_on_inst_token (MonoDynamicImage *assembly, MonoReflectionMethodOnTypeBuilderInst *m, gboolean create_methodspec, MonoError *error)
{
guint32 sig, token = 0;
MonoType *type;
MonoClass *klass;
+ mono_error_init (error);
+
if (m->method_args) {
MonoMethod *inflated;
gclass = type->data.generic_class;
g_assert (gclass->is_dynamic);
- reflection_methodbuilder_from_method_builder (&rmb, mb);
+ if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error))
+ return 0;
name = mono_string_to_utf8 (rmb.name);
* Insert into the metadata tables all the info about the TypeBuilder tb.
* Data in the tables is inserted in a predefined order, since some tables need to be sorted.
*/
-static void
-mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, MonoDynamicImage *assembly)
+static gboolean
+mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, MonoDynamicImage *assembly, MonoError *error)
{
- MonoError error;
MonoDynamicTable *table;
guint *values;
int i, is_object = 0, is_system = 0;
char *n;
+ mono_error_init (error);
+
table = &assembly->tables [MONO_TABLE_TYPEDEF];
values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
values [MONO_TYPEDEF_FLAGS] = tb->attrs;
table->rows += mono_array_length (tb->ctors);
alloc_table (table, table->rows);
for (i = 0; i < mono_array_length (tb->ctors); ++i) {
- mono_image_get_ctor_info (domain,
- mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i),
- assembly, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (!mono_image_get_ctor_info (domain,
+ mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i),
+ assembly, error))
+ return FALSE;
}
}
table = &assembly->tables [MONO_TABLE_METHOD];
table->rows += tb->num_methods;
alloc_table (table, table->rows);
- for (i = 0; i < tb->num_methods; ++i)
- mono_image_get_method_info (
- mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), assembly);
+ for (i = 0; i < tb->num_methods; ++i) {
+ if (!mono_image_get_method_info (
+ mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), assembly, error))
+ return FALSE;
+ }
}
/* Do the same with properties etc.. */
ntable->next_idx++;
}
}
+
+ return TRUE;
}
#endif
* and the metadata tables are comnpressed from the guint32 array representation,
* to the compressed on-disk format.
*/
-static void
-build_compressed_metadata (MonoDynamicImage *assembly)
+static gboolean
+build_compressed_metadata (MonoDynamicImage *assembly, MonoError *error)
{
MonoDynamicTable *table;
int i;
unsigned char *p;
struct StreamDesc stream_desc [5];
+ mono_error_init (error);
+
qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
- for (i = 0; i < assembly->gen_params->len; i++){
+ for (i = 0; i < assembly->gen_params->len; i++) {
GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (assembly->gen_params, i);
- write_generic_param_entry (assembly, entry);
+ if (!write_generic_param_entry (assembly, entry, error))
+ return FALSE;
}
stream_desc [0].name = "#~";
memcpy (meta->raw_metadata + assembly->guid.offset, assembly->guid.data, assembly->guid.index);
assembly->meta_size = assembly->guid.offset + assembly->guid.index;
+
+ return TRUE;
}
/*
table = &assembly->tables [MONO_TABLE_METHOD];
table->rows += mono_array_length (moduleb->global_methods);
alloc_table (table, table->rows);
- for (i = 0; i < mono_array_length (moduleb->global_methods); ++i)
- mono_image_get_method_info (
- mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i), assembly);
+ for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
+ if (!mono_image_get_method_info (
+ mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i), assembly, error))
+ goto leave;
+ }
}
if (moduleb->global_fields) {
table = &assembly->tables [MONO_TABLE_FIELD];
for (i = 0; i < mono_ptr_array_size (types); ++i) {
MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
- mono_image_get_type_info (domain, type, assembly);
+ if (!mono_image_get_type_info (domain, type, assembly, error))
+ goto leave_types;
}
/*
guint32 parent, sig_token;
int nopt_args, nparams, ngparams, i;
- reflection_methodbuilder_from_method_builder (&rmb, mb);
+ if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error))
+ goto fail;
+
rmb.opt_types = opt_param_types;
nopt_args = mono_array_length (opt_param_types);
if (tb->module->dynamic_image == assembly && !tb->generic_params && !mb->generic_params)
token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
- else
- token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance);
+ else {
+ token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance, error);
+ if (!mono_error_ok (error))
+ return 0;
+ }
/*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
} else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
if (tb->module->dynamic_image == assembly && !tb->generic_params)
token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
- else
- token = mono_image_get_ctorbuilder_token (assembly, mb);
+ else {
+ token = mono_image_get_ctorbuilder_token (assembly, mb, error);
+ if (!mono_error_ok (error))
+ return 0;
+ }
/*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
} else if (strcmp (klass->name, "FieldBuilder") == 0) {
MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
token = mono_image_get_field_on_inst_token (assembly, f);
} else if (strcmp (klass->name, "ConstructorOnTypeBuilderInst") == 0) {
MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj;
- token = mono_image_get_ctor_on_inst_token (assembly, c, create_open_instance);
+ token = mono_image_get_ctor_on_inst_token (assembly, c, create_open_instance, error);
+ if (!mono_error_ok (error))
+ return 0;
} else if (strcmp (klass->name, "MethodOnTypeBuilderInst") == 0) {
MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
- token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance);
+ token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance, error);
+ if (!mono_error_ok (error))
+ return 0;
} else if (is_sre_array (klass) || is_sre_byref (klass) || is_sre_pointer (klass)) {
MonoReflectionType *type = (MonoReflectionType *)obj;
token = mono_metadata_token_from_dor (
* This function creates the PE-COFF header, the image sections, the CLI header * etc. all the data is written in
* assembly->pefile where it can be easily retrieved later in chunks.
*/
-void
-mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file)
+gboolean
+mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file, MonoError *error)
{
- MonoError error;
MonoMSDOSHeader *msdos;
MonoDotNetHeader *header;
MonoSectionTable *section;
0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
+ mono_error_init (error);
+
assemblyb = mb->assemblyb;
mono_image_basic_init (assemblyb);
((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->pe_kind = assemblyb->pe_kind;
((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->machine = assemblyb->machine;
- if (!mono_image_build_metadata (mb, &error))
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ if (!mono_image_build_metadata (mb, error))
+ return FALSE;
if (mb->is_main && assemblyb->resources) {
assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i));
}
- build_compressed_metadata (assembly);
+ if (!build_compressed_metadata (assembly, error))
+ return FALSE;
if (mb->is_main)
assembly_add_win32_resources (assembly, assemblyb);
g_hash_table_foreach (assembly->blob_cache, (GHFunc)g_free, NULL);
g_hash_table_destroy (assembly->blob_cache);
assembly->blob_cache = NULL;
+
+ return TRUE;
}
#else /* DISABLE_REFLECTION_EMIT_SAVE */
-void
-mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file)
+gboolean
+mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file, MonoError *error)
{
g_assert_not_reached ();
}
MonoReflectionModule *
mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *ab, MonoString *fileName)
{
+ MonoError error;
+ MonoReflectionModule *result = NULL;
char *name;
MonoImage *image;
MonoImageOpenStatus status;
mono_raise_exception (mono_get_exception_file_not_found (fileName));
}
- return mono_module_get_object (mono_domain_get (), image);
+ result = mono_module_get_object_checked (mono_domain_get (), image, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+ return result;
}
#endif /* DISABLE_REFLECTION_EMIT */
mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
{
MonoError error;
+ MonoReflectionAssembly *result;
+ result = mono_assembly_get_object_checked (domain, assembly, &error);
+ if (!result)
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+/*
+ * mono_assembly_get_object:
+ * @domain: an app domain
+ * @assembly: an assembly
+ *
+ * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
+ */
+MonoReflectionAssembly*
+mono_assembly_get_object_checked (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
+{
static MonoClass *assembly_type;
MonoReflectionAssembly *res;
+ mono_error_init (error);
+
CHECK_OBJECT (MonoReflectionAssembly *, assembly, NULL);
if (!assembly_type) {
MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoAssembly");
g_assert (klass);
assembly_type = klass;
}
- res = (MonoReflectionAssembly *)mono_object_new_checked (domain, assembly_type, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ res = (MonoReflectionAssembly *)mono_object_new_checked (domain, assembly_type, error);
+ if (!res)
+ return NULL;
res->assembly = assembly;
CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
mono_module_get_object (MonoDomain *domain, MonoImage *image)
{
MonoError error;
+ MonoReflectionModule *result;
+ result = mono_module_get_object_checked (domain, image, &error);
+ mono_error_raise_exception (&error);
+ return result;
+}
+
+MonoReflectionModule*
+mono_module_get_object_checked (MonoDomain *domain, MonoImage *image, MonoError *error)
+{
static MonoClass *module_type;
MonoReflectionModule *res;
char* basename;
+ mono_error_init (error);
CHECK_OBJECT (MonoReflectionModule *, image, NULL);
if (!module_type) {
MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoModule");
g_assert (klass);
module_type = klass;
}
- res = (MonoReflectionModule *)mono_object_new_checked (domain, module_type, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ res = (MonoReflectionModule *)mono_object_new_checked (domain, module_type, error);
+ if (!res)
+ return NULL;
res->image = image;
- MONO_OBJECT_SETREF (res, assembly, (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly));
+ MonoReflectionAssembly *assm_obj = mono_assembly_get_object_checked (domain, image->assembly, error);
+ if (!assm_obj)
+ return NULL;
+ MONO_OBJECT_SETREF (res, assembly, assm_obj);
MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, image->name));
basename = g_path_get_basename (image->name);
CACHE_OBJECT (MonoReflectionModule *, image, res, NULL);
}
-MonoReflectionModule*
+MonoReflectionModule*
mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
{
MonoError error;
+ MonoReflectionModule *result;
+ result = mono_module_file_get_object_checked (domain, image, table_index, &error);
+ mono_error_raise_exception (&error);
+ return result;
+}
+
+MonoReflectionModule*
+mono_module_file_get_object_checked (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error)
+{
static MonoClass *module_type;
MonoReflectionModule *res;
MonoTableInfo *table;
guint32 i, name_idx;
const char *val;
+ mono_error_init (error);
+
if (!module_type) {
MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoModule");
if (klass == NULL)
g_assert (klass);
module_type = klass;
}
- res = (MonoReflectionModule *)mono_object_new_checked (domain, module_type, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ res = (MonoReflectionModule *)mono_object_new_checked (domain, module_type, error);
+ if (!res)
+ return NULL;
table = &image->tables [MONO_TABLE_FILE];
g_assert (table_index < table->rows);
mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
res->image = NULL;
- MONO_OBJECT_SETREF (res, assembly, (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly));
+ MonoReflectionAssembly *assm_obj = mono_assembly_get_object_checked (domain, image->assembly, error);
+ if (!assm_obj)
+ return NULL;
+ MONO_OBJECT_SETREF (res, assembly, assm_obj);
name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
/* Check whenever the row has a corresponding row in the moduleref table */
if (!verify_safe_for_managed_space (type)) {
mono_domain_unlock (domain);
mono_loader_unlock ();
- mono_raise_exception (mono_get_exception_invalid_operation ("This type cannot be propagated to managed space"));
+ mono_error_set_generic_error (error, "System", "InvalidOperationException", "This type cannot be propagated to managed space");
+ return NULL;
}
if (mono_class_get_ref_info (klass) && !klass->wastypebuilder) {
return type;
}
+/**
+ * mono_reflection_get_type_internal:
+ *
+ * Returns: may return NULL on success, sets error on failure.
+ */
static MonoType*
-mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase)
+mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
{
- MonoError error;
MonoClass *klass;
GList *mod;
int modval;
gboolean bounded = FALSE;
+ mono_error_init (error);
if (!image)
image = mono_defaults.corlib;
rootimage = mono_defaults.corlib;
if (ignorecase) {
- MonoError error;
- klass = mono_class_from_name_case_checked (image, info->name_space, info->name, &error);
- g_assert (mono_error_ok (&error)); /* FIXME Don't swallow the error */
+ klass = mono_class_from_name_case_checked (image, info->name_space, info->name, error);
+ g_assert (mono_error_ok (error)); /* FIXME Don't swallow the error */
} else {
klass = mono_class_from_name (image, info->name_space, info->name);
}
if (!klass)
return NULL;
+
for (mod = info->nested; mod; mod = mod->next) {
gpointer iter = NULL;
MonoClass *parent;
}
}
- the_type = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ the_type = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
+ if (!the_type)
+ return NULL;
instance = mono_reflection_bind_generic_parameters (
the_type, info->type_arguments->len, type_args);
}
static MonoType*
-mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase)
+mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
{
MonoReflectionAssemblyBuilder *abuilder;
MonoType *type;
int i;
+ mono_error_init (error);
g_assert (assembly_is_dynamic (assembly));
- abuilder = (MonoReflectionAssemblyBuilder*)mono_assembly_get_object (((MonoDynamicAssembly*)assembly)->domain, assembly);
+ abuilder = (MonoReflectionAssemblyBuilder*)mono_assembly_get_object_checked (((MonoDynamicAssembly*)assembly)->domain, assembly, error);
+ if (!abuilder)
+ return NULL;
/* Enumerate all modules */
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_internal (rootimage, &mb->dynamic_image->image, info, ignorecase);
+ type = mono_reflection_get_type_internal (rootimage, &mb->dynamic_image->image, info, ignorecase, error);
if (type)
break;
+ if (!mono_error_ok (error))
+ return NULL;
}
}
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_internal (rootimage, mod->image, info, ignorecase);
+ type = mono_reflection_get_type_internal (rootimage, mod->image, info, ignorecase, error);
if (type)
break;
+ if (!mono_error_ok (error))
+ return NULL;
}
}
MonoType*
mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve)
{
+ MonoError error;
MonoType *type;
MonoReflectionAssembly *assembly;
GString *fullName;
GList *mod;
if (image && image_is_dynamic (image))
- type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase);
- else
- type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
+ type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase, &error);
+ else {
+ type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, &error);
+ }
+ if (!mono_error_ok(&error))
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+
if (type)
return type;
if (!mono_domain_has_type_resolve (mono_domain_get ()))
assembly = mono_domain_try_type_resolve ( mono_domain_get (), fullName->str, NULL);
if (assembly) {
if (assembly_is_dynamic (assembly->assembly))
- type = mono_reflection_get_type_internal_dynamic (rootimage, assembly->assembly, info, ignorecase);
+ type = mono_reflection_get_type_internal_dynamic (rootimage, assembly->assembly,
+ info, ignorecase, &error);
else
type = mono_reflection_get_type_internal (rootimage, assembly->assembly->image,
- info, ignorecase);
+ info, ignorecase, &error);
}
g_string_free (fullName, TRUE);
+ if (!mono_error_ok (&error))
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
return type;
}
retval = mono_object_new_checked (mono_domain_get (), klass, &error);
mono_error_raise_exception (&error); /* FIXME don't raise here */
unboxed = mono_object_unbox (retval);
- mono_runtime_invoke (ctor, unboxed, params, NULL);
+
+ mono_runtime_invoke_checked (ctor, unboxed, params, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
return retval;
}
retval = mono_object_new_checked (mono_domain_get (), klass, &error);
mono_error_raise_exception (&error); /* FIXME don't raise here */
unboxed = mono_object_unbox (retval);
- mono_runtime_invoke (ctor, unboxed, params, NULL);
+
+ mono_runtime_invoke_checked (ctor, unboxed, params, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
return retval;
}
if (len == 0) {
attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
if (!mono_error_ok (error)) return NULL;
- mono_runtime_invoke (method, attr, NULL, NULL);
+
+ mono_runtime_invoke_checked (method, attr, NULL, error);
+ if (!mono_error_ok (error))
+ return NULL;
+
return attr;
}
attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
if (!mono_error_ok (error)) goto fail;
- mono_runtime_invoke (method, attr, params, &exc);
+ mono_runtime_try_invoke (method, attr, params, &exc, error);
+ if (!mono_error_ok (error))
+ goto fail;
if (exc)
goto fail;
+
num_named = read16 (named);
named += 2;
for (j = 0; j < num_named; j++) {
mono_error_raise_exception (&error); /* FIXME don't raise here */
params [0] = mono_method_get_object_checked (domain, cattr->ctor, NULL, &error);
mono_error_raise_exception (&error); /* FIXME don't raise here */
- params [1] = mono_assembly_get_object (domain, image->assembly);
+ params [1] = mono_assembly_get_object_checked (domain, image->assembly, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
params [2] = (gpointer)&cattr->data;
params [3] = &cattr->data_size;
- mono_runtime_invoke (ctor, attr, params, NULL);
+
+ mono_runtime_invoke_checked (ctor, attr, params, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+
return attr;
}
mono_reflection_type_get_underlying_system_type (MonoReflectionType* t)
{
static MonoMethod *method_get_underlying_system_type = NULL;
+ MonoError error;
+ MonoReflectionType *rt;
MonoMethod *usertype_method;
if (!method_get_underlying_system_type)
method_get_underlying_system_type = mono_class_get_method_from_name (mono_defaults.systemtype_class, "get_UnderlyingSystemType", 0);
+
usertype_method = mono_object_get_virtual_method ((MonoObject *) t, method_get_underlying_system_type);
- return (MonoReflectionType *) mono_runtime_invoke (usertype_method, t, NULL, NULL);
+
+ rt = (MonoReflectionType *) mono_runtime_invoke_checked (usertype_method, t, NULL, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+ return rt;
}
static MonoMethod*
ctorbuilder_to_mono_method (MonoClass *klass, MonoReflectionCtorBuilder* mb)
{
+ MonoError error;
ReflectionMethodBuilder rmb;
MonoMethodSignature *sig;
sig = ctor_builder_to_signature (klass->image, mb);
mono_loader_unlock ();
- reflection_methodbuilder_from_ctor_builder (&rmb, mb);
+ if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, &error))
+ mono_error_raise_exception (&error); /* FIXME don't raise here*/
mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
static MonoMethod*
methodbuilder_to_mono_method (MonoClass *klass, MonoReflectionMethodBuilder* mb)
{
+ MonoError error;
ReflectionMethodBuilder rmb;
MonoMethodSignature *sig;
sig = method_builder_to_signature (klass->image, mb);
mono_loader_unlock ();
- reflection_methodbuilder_from_method_builder (&rmb, mb);
+ if (!reflection_methodbuilder_from_method_builder (&rmb, mb, &error))
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, &error);
mono_error_raise_exception (&error); /* FIXME don't raise here */
- res = mono_runtime_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc);
- if (exc)
+ res = mono_runtime_try_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc, &error);
+
+ if (exc || !mono_error_ok (&error)) {
+ mono_error_cleanup (&error);
return FALSE;
- else
+ } else
return *(MonoBoolean*)mono_object_unbox (res);
}