static MonoMethod * inflate_method (MonoReflectionType *type, MonoObject *obj, MonoError *error);
static guint32 create_typespec (MonoDynamicImage *assembly, MonoType *type);
-static void init_type_builder_generics (MonoObject *type);
+static void init_type_builder_generics (MonoObject *type, MonoError *error);
#define RESOLVE_TYPE(type, error) do { \
type = (MonoObject *)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type, error); \
static inline void
dynamic_image_lock (MonoDynamicImage *image)
{
- MONO_PREPARE_BLOCKING;
+ MONO_ENTER_GC_SAFE;
mono_image_lock ((MonoImage*)image);
- MONO_FINISH_BLOCKING;
+ MONO_EXIT_GC_SAFE;
}
static inline void
{
MONO_REQ_GC_UNSAFE_MODE;
- char *name = mono_string_to_utf8 (str);
+ MonoError error;
+ char *name = mono_string_to_utf8_checked (str, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
guint32 idx;
idx = string_heap_insert (sh, name);
g_free (name);
} else {
code = mb->code;
if (code == NULL){
- char *name = mono_string_to_utf8 (mb->name);
+ MonoError inner_error;
+ char *name = mono_string_to_utf8_checked (mb->name, &inner_error);
+ if (!is_ok (&inner_error)) {
+ name = g_strdup ("");
+ mono_error_cleanup (&inner_error);
+ }
char *str = g_strdup_printf ("Method %s does not have any IL associated", name);
mono_error_set_argument (error, NULL, "a method does not have any IL associated");
g_free (str);
MonoType *type;
MonoClass *klass;
- init_type_builder_generics (fb->type);
+ init_type_builder_generics (fb->type, error);
+ return_val_if_nok (error, 0);
type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
return_val_if_nok (error, 0);
break;
case MONO_NATIVE_CUSTOM:
if (minfo->guid) {
- str = mono_string_to_utf8 (minfo->guid);
+ str = mono_string_to_utf8_checked (minfo->guid, error);
+ if (!is_ok (error)) {
+ sigbuffer_free (&buf);
+ return 0;
+ }
len = strlen (str);
sigbuffer_add_value (&buf, len);
sigbuffer_add_mem (&buf, str, len);
return 0;
}
str = type_get_fully_qualified_name (marshaltype);
- } else
- str = mono_string_to_utf8 (minfo->marshaltype);
+ } else {
+ str = mono_string_to_utf8_checked (minfo->marshaltype, error);
+ if (!is_ok (error)) {
+ sigbuffer_free (&buf);
+ return 0;
+ }
+ }
len = strlen (str);
sigbuffer_add_value (&buf, len);
sigbuffer_add_mem (&buf, str, len);
sigbuffer_add_value (&buf, 0);
}
if (minfo->mcookie) {
- str = mono_string_to_utf8 (minfo->mcookie);
+ str = mono_string_to_utf8_checked (minfo->mcookie, error);
+ if (!is_ok (error)) {
+ sigbuffer_free (&buf);
+ return 0;
+ }
len = strlen (str);
sigbuffer_add_value (&buf, len);
sigbuffer_add_mem (&buf, str, len);
parent = mono_image_typedef_or_ref (assembly, t);
}
- char *name = mono_string_to_utf8 (method->name);
+ char *name = mono_string_to_utf8_checked (method->name, error);
+ return_val_if_nok (error, 0);
token = mono_image_add_memberef_row (assembly, parent, name, sig);
g_free (name);
parent = mono_image_typedef_or_ref (assembly, type);
}
- name = mono_string_to_utf8 (rmb.name);
+ name = mono_string_to_utf8_checked (rmb.name, error);
+ return_val_if_nok (error, 0);
sig = method_builder_encode_signature (assembly, &rmb, error);
return_val_if_nok (error, 0);
guint32 sig_token = field_encode_signature (assembly, fb, error);
return_val_if_nok (error, 0);
- name = mono_string_to_utf8 (fb->name);
+ name = mono_string_to_utf8_checked (fb->name, error);
+ return_val_if_nok (error, 0);
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig_token);
g_free (name);
} else if (is_sr_mono_field (mono_object_class (f->fb))) {
sig = method_builder_encode_signature (assembly, &rmb, error);
return_val_if_nok (error, 0);
- name = mono_string_to_utf8 (rmb.name);
+ name = mono_string_to_utf8_checked (rmb.name, error);
+ return_val_if_nok (error, 0);
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
g_free (name);
mono_error_init (error);
- init_type_builder_generics ((MonoObject*)m->inst);
+ init_type_builder_generics ((MonoObject*)m->inst, error);
+ return_val_if_nok (error, NULL);
method = inflate_method (m->inst, (MonoObject*)m->mb, error);
return_val_if_nok (error, NULL);
sig = method_builder_encode_signature (assembly, &rmb, error);
return_val_if_nok (error, 0);
- name = mono_string_to_utf8 (rmb.name);
+ name = mono_string_to_utf8_checked (rmb.name, error);
+ return_val_if_nok (error, 0);
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
g_free (name);
g_assert (tb->generic_params);
klass = mono_class_from_mono_type (type);
- if (tb->generic_container)
- mono_reflection_create_generic_class (tb);
+ if (tb->generic_container) {
+ if (!mono_reflection_create_generic_class (tb, error))
+ goto fail;
+ }
sigbuffer_add_value (&buf, MONO_TYPE_GENERICINST);
g_assert (klass->generic_container);
}
static void
-init_type_builder_generics (MonoObject *type)
+init_type_builder_generics (MonoObject *type, MonoError *error)
{
MonoReflectionTypeBuilder *tb;
+ mono_error_init (error);
+
if (!is_sre_type_builder(mono_object_class (type)))
return;
tb = (MonoReflectionTypeBuilder *)type;
if (tb && tb->generic_container)
- mono_reflection_create_generic_class (tb);
+ mono_reflection_create_generic_class (tb, error);
}
static guint32
mono_class_from_mono_type (typeb);
/*FIXME this is one more layer of ugliness due how types are created.*/
- init_type_builder_generics (fb->type);
+ init_type_builder_generics (fb->type, error);
+ return_val_if_nok (error, 0);
/* fb->type does not include the custom modifiers */
/* FIXME: We should do this in one place when a fieldbuilder is created */
table = &assembly->tables [MONO_TABLE_MEMBERREF];
- name = mono_string_to_utf8 (fb->name);
+ name = mono_string_to_utf8_checked (fb->name, error);
+ return_val_if_nok (error, 0);
if (assembly->save) {
alloc_table (table, table->rows + 1);
goto fail;
}
- name = mono_string_to_utf8 (m->name);
+ name = mono_string_to_utf8_checked (m->name, error);
+ if (!is_ok (error))
+ goto fail;
for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
am = (ArrayMethod *)tmp->data;
if (strcmp (name, am->name) == 0 &&
table = &assembly->tables [MONO_TABLE_TYPEDEF];
values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
values [MONO_TYPEDEF_FLAGS] = tb->attrs;
- n = mono_string_to_utf8 (tb->name);
+ n = mono_string_to_utf8_checked (tb->name, error);
+ return_val_if_nok (error, FALSE);
if (strcmp (n, "Object") == 0)
is_object++;
values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, n);
g_free (n);
- n = mono_string_to_utf8 (tb->nspace);
+ n = mono_string_to_utf8_checked (tb->nspace, error);
+ return_val_if_nok (error, FALSE);
if (strcmp (n, "System") == 0)
is_system++;
values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, n);
static void
mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly)
{
+ MonoError error;
MonoDynamicTable *table;
guint32 *values;
char blob_size [6];
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 (((MonoReflectionModuleBuilder*)module)->assemblyb->dir);
+ dir = mono_string_to_utf8_checked (((MonoReflectionModuleBuilder*)module)->assemblyb->dir, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
} else {
dir = NULL;
static void
assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc)
{
+ MonoError error;
MonoDynamicTable *table;
guint32 *values;
char blob_size [6];
guint32 idx, offset;
if (rsrc->filename) {
- name = mono_string_to_utf8 (rsrc->filename);
+ name = mono_string_to_utf8_checked (rsrc->filename, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
sname = g_path_get_basename (name);
table = &assembly->tables [MONO_TABLE_FILE];
static void
set_version_from_string (MonoString *version, guint32 *values)
{
+ MonoError error;
gchar *ver, *p, *str;
guint32 i;
values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
if (!version)
return;
- ver = str = mono_string_to_utf8 (version);
+ ver = str = mono_string_to_utf8_checked (version, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
for (i = 0; i < 4; ++i) {
values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
switch (*p) {
parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
parent |= MONO_MEMBERREF_PARENT_METHODDEF;
- char *name = mono_string_to_utf8 (rmb.name);
+ char *name = mono_string_to_utf8_checked (rmb.name, error);
+ if (!is_ok (error)) goto fail;
token = mono_image_get_varargs_method_token (
assembly, parent, name, sig_token);
g_free (name);
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
if (create_open_instance && tb->generic_params) {
MonoType *type;
- init_type_builder_generics (obj);
+ init_type_builder_generics (obj, error);
+ return_val_if_nok (error, 0);
type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
return_val_if_nok (error, 0);
token = mono_image_typedef_or_ref_full (assembly, type, TRUE);
return_val_if_nok (error, 0);
token = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, type));
}
- } else if (strcmp (klass->name, "MonoType") == 0) {
+ } else if (strcmp (klass->name, "RuntimeType") == 0) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
return_val_if_nok (error, 0);
MonoClass *mc = mono_class_from_mono_type (type);
void
mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
{
+ MonoError error;
MonoDynamicAssembly *assembly;
MonoDynamicImage *image;
MonoDomain *domain = mono_object_domain (assemblyb);
assembly->assembly.dynamic = TRUE;
assembly->assembly.corlib_internal = assemblyb->corlib_internal;
assemblyb->assembly.assembly = (MonoAssembly*)assembly;
- assembly->assembly.basedir = mono_string_to_utf8 (assemblyb->dir);
- if (assemblyb->culture)
- assembly->assembly.aname.culture = mono_string_to_utf8 (assemblyb->culture);
- else
+ assembly->assembly.basedir = mono_string_to_utf8_checked (assemblyb->dir, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+ 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 */
+ } else
assembly->assembly.aname.culture = g_strdup ("");
if (assemblyb->version) {
- char *vstr = mono_string_to_utf8 (assemblyb->version);
+ char *vstr = mono_string_to_utf8_checked (assemblyb->version, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
char **version = g_strsplit (vstr, ".", 4);
char **parts = version;
assembly->assembly.aname.major = atoi (*parts++);
assembly->save = assemblyb->access != 1;
assembly->domain = domain;
- image = create_dynamic_mono_image (assembly, mono_string_to_utf8 (assemblyb->name), g_strdup ("RefEmit_YouForgotToDefineAModule"));
+ char *assembly_name = mono_string_to_utf8_checked (assemblyb->name, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+ image = create_dynamic_mono_image (assembly, assembly_name, g_strdup ("RefEmit_YouForgotToDefineAModule"));
image->initial_image = TRUE;
assembly->assembly.aname.name = image->image.name;
assembly->assembly.image = &image->image;
mono_error_init (error);
- name = mono_string_to_utf8 (fileName);
+ name = mono_string_to_utf8_checked (fileName, error);
+ return_val_if_nok (error, NULL);
image = mono_image_open (name, &status);
if (!image) {
CACHE_OBJECT (MonoReflectionModuleBuilder *, module, res, NULL);
}
-void
-mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
+static gboolean
+image_module_basic_init (MonoReflectionModuleBuilder *moduleb, MonoError *error)
{
MonoDynamicImage *image = moduleb->dynamic_image;
MonoReflectionAssemblyBuilder *ab = moduleb->assemblyb;
+ mono_error_init (error);
if (!image) {
- MonoError error;
int module_count;
MonoImage **new_modules;
MonoImage *ass;
* determined at assembly save time.
*/
/*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
- name = mono_string_to_utf8 (ab->name);
- fqname = mono_string_to_utf8_checked (moduleb->module.fqname, &error);
- if (!mono_error_ok (&error)) {
+ name = mono_string_to_utf8_checked (ab->name, error);
+ return_val_if_nok (error, FALSE);
+ fqname = mono_string_to_utf8_checked (moduleb->module.fqname, error);
+ if (!is_ok (error)) {
g_free (name);
- mono_error_raise_exception (&error);
+ return FALSE;
}
image = create_dynamic_mono_image (ab->dynamic_assembly, name, fqname);
ass->modules = new_modules;
ass->module_count ++;
}
+ return TRUE;
+}
+
+void
+mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
+{
+ MonoError error;
+ (void) image_module_basic_init (moduleb, &error);
+ mono_error_set_pending_exception (&error);
}
void
MonoError error;
MonoReflectionModule *result;
result = mono_module_get_object_checked (domain, image, &error);
- mono_error_raise_exception (&error);
+ mono_error_cleanup (&error);
return result;
}
MonoError error;
MonoReflectionModule *result;
result = mono_module_file_get_object_checked (domain, image, table_index, &error);
- mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoReflectionType *ret = mono_type_get_object_checked (domain, type, &error);
- mono_error_raise_exception (&error);
+ mono_error_cleanup (&error);
return ret;
}
}
}
/* This is stored in vtables/JITted code so it has to be pinned */
- res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.monotype_class, error);
+ res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.runtimetype_class, error);
if (!mono_error_ok (error))
return NULL;
MonoError error;
MonoReflectionMethod *ret = NULL;
ret = mono_method_get_object_checked (domain, method, refclass, &error);
- mono_error_raise_exception (&error);
+ mono_error_cleanup (&error);
return ret;
}
MonoError error;
MonoReflectionField *result;
result = mono_field_get_object_checked (domain, klass, field, &error);
- mono_error_raise_exception (&error);
+ mono_error_cleanup (&error);
return result;
}
MonoError error;
MonoReflectionProperty *result;
result = mono_property_get_object_checked (domain, klass, property, &error);
- mono_error_raise_exception (&error);
+ mono_error_cleanup (&error);
return result;
}
MonoError error;
MonoReflectionEvent *result;
result = mono_event_get_object_checked (domain, klass, event, &error);
- mono_error_raise_exception (&error);
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoReflectionMethodBody *result = mono_method_body_get_object_checked (domain, method, &error);
- mono_error_cleanup (&error); /* FIXME better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
ret->init_locals = header->init_locals;
ret->max_stack = header->max_stack;
ret->local_var_sig_token = local_var_sig_token;
- MONO_OBJECT_SETREF (ret, il, mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size));
+ MonoArray *il_arr = mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_OBJECT_SETREF (ret, il, il_arr);
memcpy (mono_array_addr (ret->il, guint8, 0), header->code, header->code_size);
/* Locals */
- MONO_OBJECT_SETREF (ret, locals, mono_array_new_cached (domain, mono_class_get_local_variable_info_class (), header->num_locals));
+ MonoArray *locals_arr = mono_array_new_cached (domain, mono_class_get_local_variable_info_class (), header->num_locals, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_OBJECT_SETREF (ret, locals, locals_arr);
for (i = 0; i < header->num_locals; ++i) {
MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new_checked (domain, mono_class_get_local_variable_info_class (), error);
if (!is_ok (error))
}
/* Exceptions */
- MONO_OBJECT_SETREF (ret, clauses, mono_array_new_cached (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses));
+ MonoArray *exn_clauses = mono_array_new_cached (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses, error);
+ if (!is_ok (error))
+ goto fail;
+ MONO_OBJECT_SETREF (ret, clauses, exn_clauses);
for (i = 0; i < header->num_clauses; ++i) {
MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new_checked (domain, mono_class_get_exception_handling_clause_class (), error);
if (!is_ok (error))
retval = &object;
}
- if (!mono_get_constant_value_from_blob (domain, basetype->type, blob, retval))
+ if (!mono_get_constant_value_from_blob (domain, basetype->type, blob, retval, error))
return object;
else
return NULL;
type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
+ /* ignore the error and try again */
mono_error_cleanup (error);
+ mono_error_init (error);
image = mono_defaults.corlib;
type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
}
} else if (strcmp (klass->name, "TypeBuilder") == 0) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
- } else if (strcmp (klass->name, "MonoType") == 0) {
+ } else if (strcmp (klass->name, "RuntimeType") == 0) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
return_val_if_nok (error, 0);
MonoClass *mc = mono_class_from_mono_type (type);
return token;
}
+/*
+ * Load the type with name @n on behalf of image @image. On failure sets @error and returns NULL.
+ * The @is_enum flag only affects the error message that's displayed on failure.
+ */
+static MonoType*
+cattr_type_from_name (char *n, MonoImage *image, gboolean is_enum, MonoError *error)
+{
+ MonoError inner_error;
+ MonoType *t = mono_reflection_type_from_name_checked (n, image, &inner_error);
+ if (!t) {
+ mono_error_set_type_load_name (error, g_strdup(n), NULL,
+ "Could not load %s %s while decoding custom attribute: %s",
+ is_enum ? "enum type": "type",
+ n,
+ mono_error_get_message (&inner_error));
+ mono_error_cleanup (&inner_error);
+ return NULL;
+ }
+ return t;
+}
+
static MonoClass*
load_cattr_enum_type (MonoImage *image, const char *p, const char **end, MonoError *error)
{
n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
- t = mono_reflection_type_from_name_checked (n, image, error);
- if (!t) {
- char *msg = g_strdup (mono_error_get_message (error));
- mono_error_cleanup (error);
- /* We don't free n, it's consumed by mono_error */
- mono_error_set_type_load_name (error, n, NULL, "Could not load enum type %s while decoding custom attribute: %s", n, msg);
- g_free (msg);
- return NULL;
- }
+ t = cattr_type_from_name (n, image, TRUE, error);
g_free (n);
+ return_val_if_nok (error, NULL);
p += slen;
*end = p;
return mono_class_from_mono_type (t);
}
slen = mono_metadata_decode_value (p, &p);
*end = p + slen;
- return mono_string_new_len (mono_domain_get (), p, slen);
+ return mono_string_new_len_checked (mono_domain_get (), p, slen, error);
case MONO_TYPE_CLASS: {
MonoReflectionType *rt;
char *n;
slen = mono_metadata_decode_value (p, &p);
n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
- t = mono_reflection_type_from_name_checked (n, image, error);
- if (!t) {
- char *msg = g_strdup (mono_error_get_message (error));
- mono_error_cleanup (error);
- /* We don't free n, it's consumed by mono_error */
- mono_error_set_type_load_name (error, n, NULL, "Could not load type %s while decoding custom attribute: %msg", n, msg);
- g_free (msg);
- return NULL;
- }
+ t = cattr_type_from_name (n, image, FALSE, error);
g_free (n);
+ return_val_if_nok (error, NULL);
*end = p + slen;
rt = mono_type_get_object_checked (mono_domain_get (), t, error);
slen = mono_metadata_decode_value (p, &p);
n = (char *)g_memdup (p, slen + 1);
n [slen] = 0;
- t = mono_reflection_type_from_name_checked (n, image, error);
- if (!t) {
- char *msg = g_strdup (mono_error_get_message (error));
- mono_error_cleanup (error);
- /* We don't free n, it's consumed by mono_error */
- mono_error_set_type_load_name (error, n, NULL, "Could not load type %s while decoding custom attribute: %s", n, msg);
- g_free (msg);
- return NULL;
- }
+ t = cattr_type_from_name (n, image, FALSE, error);
g_free (n);
+ return_val_if_nok (error, NULL);
p += slen;
subc = mono_class_from_mono_type (t);
} else if (subt >= MONO_TYPE_BOOLEAN && subt <= MONO_TYPE_R8) {
*end = p;
return NULL;
}
- arr = mono_array_new (mono_domain_get(), tklass, alen);
+ arr = mono_array_new_checked (mono_domain_get(), tklass, alen, error);
+ return_val_if_nok (error, NULL);
basetype = tklass->byval_arg.type;
if (basetype == MONO_TYPE_VALUETYPE && tklass->enumtype)
basetype = mono_class_enum_basetype (tklass)->type;
void *params_buf [32];
void **params = NULL;
MonoMethodSignature *sig;
- MonoObject *exc = NULL;
mono_error_init (error);
attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
if (!mono_error_ok (error)) goto fail;
+ MonoObject *exc = NULL;
mono_runtime_try_invoke (method, attr, params, &exc, error);
if (!mono_error_ok (error))
goto fail;
- if (exc)
+ if (exc) {
+ mono_error_set_exception_instance (error, (MonoException*)exc);
goto fail;
+ }
num_named = read16 (named);
named += 2;
}
- mono_property_set_value (prop, attr, pparams, NULL);
+ mono_property_set_value_checked (prop, attr, pparams, error);
if (!type_is_reference (prop_type))
g_free (pparams [0]);
+ if (!is_ok (error)) {
+ g_free (name);
+ goto fail;
+ }
}
g_free (name);
}
free_param_data (method->signature, params);
if (params != params_buf)
mono_gc_free_fixed (params);
- if (exc)
- mono_raise_exception ((MonoException*)exc);
return NULL;
}
if (len < 2 || read16 (p) != 0x0001) /* Prolog */
return;
- typedargs = mono_array_new (domain, mono_get_object_class (), mono_method_signature (method)->param_count);
-
+ typedargs = mono_array_new_checked (domain, mono_get_object_class (), mono_method_signature (method)->param_count, error);
+ return_if_nok (error);
+
/* skip prolog */
p += 2;
for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
named = p;
num_named = read16 (named);
- namedargs = mono_array_new (domain, mono_get_object_class (), num_named);
+ namedargs = mono_array_new_checked (domain, mono_get_object_class (), num_named, error);
+ return_if_nok (error);
named += 2;
attrklass = method->klass;
*named_arg_info = NULL;
}
-void
-mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *ref_method, MonoReflectionAssembly *assembly, gpointer data, guint32 len, MonoArray **ctor_args, MonoArray **named_args)
+static gboolean
+reflection_resolve_custom_attribute_data (MonoReflectionMethod *ref_method, MonoReflectionAssembly *assembly, gpointer data, guint32 len, MonoArray **ctor_args, MonoArray **named_args, MonoError *error)
{
MonoDomain *domain;
MonoArray *typedargs, *namedargs;
MonoImage *image;
MonoMethod *method;
CattrNamedArg *arginfo = NULL;
- MonoError error;
int i;
- mono_error_init (&error);
+ mono_error_init (error);
*ctor_args = NULL;
*named_args = NULL;
if (len == 0)
- return;
+ return TRUE;
image = assembly->assembly->image;
method = ref_method->method;
domain = mono_object_domain (ref_method);
- if (!mono_class_init (method->klass))
- mono_raise_exception (mono_class_get_exception_for_failure (method->klass));
+ if (!mono_class_init (method->klass)) {
+ mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (method->klass));
+ goto leave;
+ }
- mono_reflection_create_custom_attr_data_args (image, method, (const guchar *)data, len, &typedargs, &namedargs, &arginfo, &error);
- if (!mono_error_ok (&error))
+ mono_reflection_create_custom_attr_data_args (image, method, (const guchar *)data, len, &typedargs, &namedargs, &arginfo, error);
+ if (!is_ok (error))
goto leave;
if (!typedargs || !namedargs)
MonoObject *obj = mono_array_get (typedargs, MonoObject*, i);
MonoObject *typedarg;
- typedarg = create_cattr_typed_arg (mono_method_signature (method)->params [i], obj, &error);
- if (!is_ok (&error))
+ typedarg = create_cattr_typed_arg (mono_method_signature (method)->params [i], obj, error);
+ if (!is_ok (error))
goto leave;
mono_array_setref (typedargs, i, typedarg);
}
MonoObject *typedarg, *namedarg, *minfo;
if (arginfo [i].prop) {
- minfo = (MonoObject*)mono_property_get_object_checked (domain, NULL, arginfo [i].prop, &error);
+ minfo = (MonoObject*)mono_property_get_object_checked (domain, NULL, arginfo [i].prop, error);
if (!minfo)
goto leave;
} else {
- minfo = (MonoObject*)mono_field_get_object_checked (domain, NULL, arginfo [i].field, &error);
- if (!mono_error_ok (&error))
+ minfo = (MonoObject*)mono_field_get_object_checked (domain, NULL, arginfo [i].field, error);
+ if (!is_ok (error))
goto leave;
}
- typedarg = create_cattr_typed_arg (arginfo [i].type, obj, &error);
- if (!is_ok (&error))
+ typedarg = create_cattr_typed_arg (arginfo [i].type, obj, error);
+ if (!is_ok (error))
goto leave;
- namedarg = create_cattr_named_arg (minfo, typedarg, &error);
- if (!is_ok (&error))
+ namedarg = create_cattr_named_arg (minfo, typedarg, error);
+ if (!is_ok (error))
goto leave;
mono_array_setref (namedargs, i, namedarg);
*ctor_args = typedargs;
*named_args = namedargs;
+
leave:
g_free (arginfo);
- mono_error_raise_exception (&error);
+ return mono_error_ok (error);
+}
+void
+ves_icall_System_Reflection_CustomAttributeData_ResolveArgumentsInternal (MonoReflectionMethod *ref_method, MonoReflectionAssembly *assembly, gpointer data, guint32 len, MonoArray **ctor_args, MonoArray **named_args)
+{
+ MonoError error;
+ (void) reflection_resolve_custom_attribute_data (ref_method, assembly, data, len, ctor_args, named_args, &error);
+ mono_error_set_pending_exception (&error);
}
static MonoObject*
n ++;
}
- result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, n);
+ result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, n, error);
+ return_val_if_nok (error, NULL);
n = 0;
for (i = 0; i < cinfo->num_attrs; ++i) {
if (!cinfo->attrs [i].ctor) {
int i;
mono_error_init (error);
- result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs, error);
+ return_val_if_nok (error, NULL);
for (i = 0; i < cinfo->num_attrs; ++i) {
attr = create_custom_attr_data (cinfo->image, &cinfo->attrs [i], error);
return_val_if_nok (error, NULL);
{
MonoError error;
MonoCustomAttrInfo *result = mono_custom_attrs_from_index_checked (image, idx, &error);
- mono_error_cleanup (&error); /* FIXME a better public API that doesn't swallow the error. */
+ mono_error_cleanup (&error);
return result;
}
/**
{
MonoError error;
MonoCustomAttrInfo *result = mono_custom_attrs_from_class_checked (klass, &error);
- mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoCustomAttrInfo *result = mono_custom_attrs_from_assembly_checked (assembly, &error);
- mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoCustomAttrInfo * result = mono_custom_attrs_from_property_checked (klass, property, &error);
- mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoCustomAttrInfo * result = mono_custom_attrs_from_event_checked (klass, event, &error);
- mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoCustomAttrInfo * result = mono_custom_attrs_from_field_checked (klass, field, &error);
- mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoCustomAttrInfo *result = mono_custom_attrs_from_param_checked (method, param, &error);
- mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
{
MonoError error;
MonoObject *res = mono_custom_attrs_get_attr_checked (ainfo, attr_klass, &error);
- g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/
+ mono_error_assert_ok (&error); /*FIXME proper error handling*/
return res;
}
mono_error_init (error);
klass = obj->vtable->klass;
- if (klass == mono_defaults.monotype_class) {
+ if (klass == mono_defaults.runtimetype_class) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
return_val_if_nok (error, NULL);
klass = mono_class_from_mono_type (type);
if (!result)
return NULL;
} else {
- result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, 0);
+ result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, 0, error);
}
return result;
MonoError error;
MonoArray* result;
result = mono_reflection_get_custom_attrs_data_checked (obj, &error);
- mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
if (!cinfo->cached)
mono_custom_attrs_free (cinfo);
return_val_if_nok (error, NULL);
- } else
- result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, 0);
+ } else
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.customattribute_data_class, 0, error);
return result;
}
MonoClass *klass = mono_object_class (prop);
if (strcmp (klass->name, "PropertyBuilder") == 0) {
MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
- *name = mono_string_to_utf8 (pb->name);
+ *name = mono_string_to_utf8_checked (pb->name, error);
+ return_if_nok (error);
*type = mono_reflection_type_get_handle ((MonoReflectionType*)pb->type, error);
} else {
MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
MonoClass *klass = mono_object_class (field);
if (strcmp (klass->name, "FieldBuilder") == 0) {
MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
- *name = mono_string_to_utf8 (fb->name);
+ *name = mono_string_to_utf8_checked (fb->name, error);
+ return_if_nok (error);
*type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
} else {
MonoReflectionField *f = (MonoReflectionField *)field;
}
static void
-init_type_builder_generics (MonoObject *type)
+init_type_builder_generics (MonoObject *type, MonoError *error)
{
+ mono_error_init (error);
}
#endif /* !DISABLE_REFLECTION_EMIT */
*p++ = 0xFF;
break;
}
- str = mono_string_to_utf8 ((MonoString*)arg);
+ str = mono_string_to_utf8_checked ((MonoString*)arg, error);
+ return_if_nok (error);
slen = strlen (str);
if ((p-buffer) + 10 + slen >= *buflen) {
char *newbuf;
{
MonoError error;
MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error);
- mono_error_cleanup (&error); /* FIXME better API that doesn't swallow the error */
+ mono_error_cleanup (&error);
return result;
}
g_assert (p - buffer <= buflen);
buflen = p - buffer;
- result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
+ if (!is_ok (error))
+ goto leave;
p = mono_array_addr (result, char, 0);
memcpy (p, buffer, buflen);
leave:
{
}
-/*
+/**
* mono_reflection_create_generic_class:
* @tb: a TypeBuilder object
+ * @error: set on error
*
* Creates the generic class after all generic parameters have been added.
+ * On success returns TRUE, on failure returns FALSE and sets @error.
+ *
*/
-void
-mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
+gboolean
+mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb, MonoError *error)
{
- MonoError error;
+
MonoClass *klass;
int count, i;
+ mono_error_init (error);
+
klass = mono_class_from_mono_type (tb->type.type);
count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
if (klass->generic_container || (count == 0))
- return;
+ return TRUE;
g_assert (tb->generic_container && (tb->generic_container->owner.klass == klass));
for (i = 0; i < count; i++) {
MonoReflectionGenericParam *gparam = (MonoReflectionGenericParam *)mono_array_get (tb->generic_params, gpointer, i);
- MonoType *param_type = mono_reflection_type_get_handle ((MonoReflectionType*)gparam, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoType *param_type = mono_reflection_type_get_handle ((MonoReflectionType*)gparam, error);
+ return_val_if_nok (error, FALSE);
MonoGenericParamFull *param = (MonoGenericParamFull *) param_type->data.generic_param;
klass->generic_container->type_params [i] = *param;
/*Make sure we are a diferent type instance */
}
klass->generic_container->context.class_inst = mono_get_shared_generic_inst (klass->generic_container);
+ return TRUE;
}
/**
res->data.custom_data.custom_name =
type_get_fully_qualified_name (marshaltyperef);
}
- if (minfo->mcookie)
- res->data.custom_data.cookie = mono_string_to_utf8 (minfo->mcookie);
+ if (minfo->mcookie) {
+ res->data.custom_data.cookie = mono_string_to_utf8_checked (minfo->mcookie, error);
+ if (!is_ok (error)) {
+ image_g_free (image, res);
+ return NULL;
+ }
+ }
break;
default:
static MonoMethod*
reflection_methodbuilder_to_mono_method (MonoClass *klass,
ReflectionMethodBuilder *rmb,
- MonoMethodSignature *sig)
+ MonoMethodSignature *sig,
+ MonoError *error)
{
- MonoError error;
MonoMethod *m;
MonoMethodWrapper *wrapperm;
MonoMarshalSpec **specs;
gboolean dynamic;
int i;
- mono_error_init (&error);
+ mono_error_init (error);
/*
* Methods created using a MethodBuilder should have their memory allocated
* inside the image mempool, while dynamic methods should have their memory
method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
- method_aux->dllentry = rmb->dllentry ? mono_string_to_utf8_image (image, rmb->dllentry, &error) : image_strdup (image, m->name);
- g_assert (mono_error_ok (&error));
- method_aux->dll = mono_string_to_utf8_image (image, rmb->dll, &error);
- g_assert (mono_error_ok (&error));
+ method_aux->dllentry = rmb->dllentry ? mono_string_to_utf8_image (image, rmb->dllentry, error) : image_strdup (image, m->name);
+ mono_error_assert_ok (error);
+ method_aux->dll = mono_string_to_utf8_image (image, rmb->dll, error);
+ mono_error_assert_ok (error);
((MonoMethodPInvoke*)m)->piflags = (rmb->native_cc << 8) | (rmb->charset ? (rmb->charset - 1) * 2 : 0) | rmb->extra_flags;
mono_array_get (rmb->ilgen->locals, MonoReflectionLocalBuilder*, i);
header->locals [i] = image_g_new0 (image, MonoType, 1);
- MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)lb->type, &error);
- mono_error_assert_ok (&error);
+ MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)lb->type, error);
+ mono_error_assert_ok (error);
memcpy (header->locals [i], type, MONO_SIZEOF_TYPE);
}
header->num_clauses = num_clauses;
if (num_clauses) {
header->clauses = method_encode_clauses (image, (MonoDynamicImage*)klass->image,
- rmb->ilgen, num_clauses, &error);
- mono_error_assert_ok (&error);
+ rmb->ilgen, num_clauses, error);
+ mono_error_assert_ok (error);
}
wrapperm->header = header;
for (i = 0; i < count; i++) {
MonoReflectionGenericParam *gp =
mono_array_get (rmb->generic_params, MonoReflectionGenericParam*, i);
- MonoType *gp_type = mono_reflection_type_get_handle ((MonoReflectionType*)gp, &error);
- mono_error_assert_ok (&error);
+ MonoType *gp_type = mono_reflection_type_get_handle ((MonoReflectionType*)gp, error);
+ mono_error_assert_ok (error);
MonoGenericParamFull *param = (MonoGenericParamFull *) gp_type->data.generic_param;
container->type_params [i] = *param;
}
}
if (pb->name) {
- method_aux->param_names [i] = mono_string_to_utf8_image (image, pb->name, &error);
- g_assert (mono_error_ok (&error));
+ method_aux->param_names [i] = mono_string_to_utf8_image (image, pb->name, error);
+ mono_error_assert_ok (error);
}
if (pb->cattrs) {
if (!method_aux->param_cattr)
if (specs == NULL)
specs = image_g_new0 (image, MonoMarshalSpec*, sig->param_count + 1);
specs [pb->position] =
- mono_marshal_spec_from_builder (image, klass->image->assembly, pb->marshal_info, &error);
- if (!is_ok (&error)) {
+ mono_marshal_spec_from_builder (image, klass->image->assembly, pb->marshal_info, error);
+ if (!is_ok (error)) {
mono_loader_unlock ();
image_g_free (image, specs);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ /* FIXME: if image is NULL, this leaks all the other stuff we alloc'd in this function */
+ return NULL;
}
}
}
if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
return NULL;
- mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
+ mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
+ return_val_if_nok (error, NULL);
mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
/* If we are in a generic class, we might be called multiple times from inflate_method */
if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error))
return NULL;
- mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
+ mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
+ return_val_if_nok (error, NULL);
mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
/* If we are in a generic class, we might be called multiple times from inflate_method */
}
/* FIXME: fix the CreateGenericParameters protocol to avoid the two stage setup of TypeBuilders */
- if (tb && tb->generic_container)
- mono_reflection_create_generic_class (tb);
+ if (tb && tb->generic_container) {
+ if (!mono_reflection_create_generic_class (tb, error)) {
+ mono_loader_unlock ();
+ return NULL;
+ }
+ }
MonoType *t = mono_reflection_type_get_handle (type, error);
if (!is_ok (error)) {
return mono_generic_class_get_class (gclass);
}
-MonoReflectionMethod*
-mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types)
+static MonoReflectionMethod*
+reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types, MonoError *error)
{
- MonoError error;
MonoClass *klass;
MonoMethod *method, *inflated;
MonoMethodInflated *imethod;
MonoType **type_argv;
int count, i;
+ mono_error_init (error);
+
/*FIXME but this no longer should happen*/
if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
#ifndef DISABLE_REFLECTION_EMIT
MonoClass *klass;
mb = (MonoReflectionMethodBuilder *) rmethod;
- tb = mono_reflection_type_get_handle ((MonoReflectionType*)mb->type, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ tb = mono_reflection_type_get_handle ((MonoReflectionType*)mb->type, error);
+ return_val_if_nok (error, NULL);
klass = mono_class_from_mono_type (tb);
- method = methodbuilder_to_mono_method (klass, mb, &error);
- if (!method)
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ method = methodbuilder_to_mono_method (klass, mb, error);
+ return_val_if_nok (error, NULL);
#else
g_assert_not_reached ();
method = NULL;
type_argv = g_new0 (MonoType *, count);
for (i = 0; i < count; i++) {
MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (types, gpointer, i);
- type_argv [i] = mono_reflection_type_get_handle (garg, &error);
- if (!is_ok (&error)) {
+ type_argv [i] = mono_reflection_type_get_handle (garg, error);
+ if (!is_ok (error)) {
g_free (type_argv);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ return NULL;
}
}
ginst = mono_metadata_get_generic_inst (count, type_argv);
tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL;
tmp_context.method_inst = ginst;
- inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, &error);
- g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
+ inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, error);
+ mono_error_assert_ok (error);
imethod = (MonoMethodInflated *) inflated;
/*FIXME but I think this is no longer necessary*/
mono_image_unlock ((MonoImage*)image);
}
- if (!mono_verifier_is_method_valid_generic_instantiation (inflated))
- mono_raise_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments"));
+ if (!mono_verifier_is_method_valid_generic_instantiation (inflated)) {
+ mono_error_set_argument (error, "typeArguments", "Invalid generic arguments");
+ return NULL;
+ }
- MonoReflectionMethod *ret = mono_method_get_object_checked (mono_object_domain (rmethod), inflated, NULL, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoReflectionMethod *ret = mono_method_get_object_checked (mono_object_domain (rmethod), inflated, NULL, error);
return ret;
}
+MonoReflectionMethod*
+mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types)
+{
+ MonoError error;
+ MonoReflectionMethod *result = reflection_bind_generic_method_parameters (rmethod, types, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
+
#ifndef DISABLE_REFLECTION_EMIT
static MonoMethod *
event->parent = klass;
event->attrs = eb->attrs;
- event->name = mono_string_to_utf8 (eb->name);
+ event->name = mono_string_to_utf8_checked (eb->name, error);
+ if (!is_ok (error)) {
+ g_free (event);
+ return NULL;
+ }
if (eb->add_method)
event->add = eb->add_method->mhandle;
if (eb->remove_method)
*/
klass->flags = tb->attrs;
klass->has_cctor = 1;
- klass->has_finalize = 1;
- klass->has_finalize_inited = 1;
mono_class_setup_parent (klass, klass->parent);
/* fool mono_class_setup_supertypes */
}
-MonoArray *
-mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
+static MonoArray *
+reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig, MonoError *error)
{
- MonoError error;
MonoReflectionModuleBuilder *module = sig->module;
MonoDynamicImage *assembly = module != NULL ? module->dynamic_image : NULL;
guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
MonoArray *result;
SigBuffer buf;
- check_array_for_usertypes (sig->arguments, &error);
- mono_error_raise_exception (&error); /* FIXME: don't raise here */
+ mono_error_init (error);
+
+ check_array_for_usertypes (sig->arguments, error);
+ return_val_if_nok (error, NULL);
sigbuffer_init (&buf, 32);
if (assembly != NULL){
for (i = 0; i < na; ++i) {
MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
- encode_reflection_type (assembly, type, &buf, &error);
- if (!is_ok (&error)) goto fail;
+ encode_reflection_type (assembly, type, &buf, error);
+ if (!is_ok (error)) goto fail;
}
}
buflen = buf.p - buf.buf;
- result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
+ if (!is_ok (error)) goto fail;
memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
sigbuffer_free (&buf);
return result;
fail:
sigbuffer_free (&buf);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
return NULL;
}
MonoArray *
-mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
+mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
{
MonoError error;
+ MonoArray *result = reflection_sighelper_get_signature_local (sig, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
+static MonoArray *
+reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig, MonoError *error)
+{
MonoDynamicImage *assembly = sig->module->dynamic_image;
guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
guint32 buflen, i;
MonoArray *result;
SigBuffer buf;
- check_array_for_usertypes (sig->arguments, &error);
- mono_error_raise_exception (&error); /* FIXME: don't raise here */
+ mono_error_init (error);
+
+ check_array_for_usertypes (sig->arguments, error);
+ return_val_if_nok (error, NULL);
sigbuffer_init (&buf, 32);
sigbuffer_add_value (&buf, 0x06);
for (i = 0; i < na; ++i) {
MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
- encode_reflection_type (assembly, type, &buf, &error);
- if (!is_ok (&error))
+ encode_reflection_type (assembly, type, &buf, error);
+ if (!is_ok (error))
goto fail;
}
buflen = buf.p - buf.buf;
- result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
+ if (!is_ok (error)) goto fail;
memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
sigbuffer_free (&buf);
return result;
fail:
sigbuffer_free (&buf);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
return NULL;
}
+MonoArray *
+mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
+{
+ MonoError error;
+ MonoArray *result = reflection_sighelper_get_signature_field (sig, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
typedef struct {
MonoMethod *handle;
MonoDomain *domain;
klass = mono_defaults.object_class;
}
- mb->mhandle = handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
+ mb->mhandle = handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
+ g_free (rmb.refs);
+ return_val_if_nok (error, FALSE);
+
release_data = g_new (DynamicMethodReleaseData, 1);
release_data->handle = handle;
release_data->domain = mono_object_get_domain ((MonoObject*)mb);
}
g_slist_free (mb->referenced_by);
- g_free (rmb.refs);
-
/* ilgen is no longer needed */
mb->ilgen = NULL;
return_val_if_nok (error, NULL);
*handle_class = mono_defaults.string_class;
g_assert (result);
- } else if (strcmp (obj->vtable->klass->name, "MonoType") == 0) {
+ } else if (strcmp (obj->vtable->klass->name, "RuntimeType") == 0) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
return_val_if_nok (error, NULL);
MonoClass *mc = mono_class_from_mono_type (type);
/* Find the method */
- name = mono_string_to_utf8 (m->name);
+ name = mono_string_to_utf8_checked (m->name, error);
+ return_val_if_nok (error, NULL);
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if (!strcmp (method->name, name))
g_assert_not_reached ();
}
-void
-mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
+gboolean
+mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb, MonoError *error)
{
g_assert_not_reached ();
+ return FALSE;
}
void
}
gpointer
-mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
+mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error)
{
+ mono_error_init (error);
return NULL;
}
params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, error);
return_val_if_nok (error, FALSE);
- res = mono_runtime_try_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc, error);
+ MonoError inner_error;
+ res = mono_runtime_try_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc, &inner_error);
- if (exc || !mono_error_ok (error)) {
- mono_error_cleanup (error);
+ if (exc || !is_ok (&inner_error)) {
+ mono_error_cleanup (&inner_error);
return FALSE;
} else
return *(MonoBoolean*)mono_object_unbox (res);
projects / mono.git / blobdiff