{
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);
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);
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);
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);
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) {
* determined at assembly save time.
*/
/*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
- name = mono_string_to_utf8 (ab->name);
+ 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);
}
}
/* 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;
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);
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) {
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);
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;
*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;
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:
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)
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))
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