return ret;
}
-ICALL_EXPORT void
-ves_icall_MonoType_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
-{
- mtype->type = &obj->vtable->klass->byval_arg;
- g_assert (mtype->type->type);
-}
-
ICALL_EXPORT gint32
ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance)
{
MonoBoolean ignoreCase)
{
MonoError error;
- char *str = mono_string_to_utf8 (name);
MonoTypeNameParse info;
- MonoReflectionType *type;
+ MonoReflectionType *type = NULL;
gboolean parsedOk;
+ char *str = mono_string_to_utf8_checked (name, &error);
+ if (!is_ok (&error))
+ goto leave;
+
parsedOk = mono_reflection_parse_type (str, &info);
/* mono_reflection_parse_type() mangles the string */
if (!parsedOk) {
mono_reflection_free_type_info (&info);
- if (throwOnError) {
- mono_error_init (&error);
+ if (throwOnError)
mono_error_set_argument (&error, "typeName", "failed parse: %s", str);
- mono_error_set_pending_exception (&error);
- }
- g_free (str);
- return NULL;
+ goto leave;
}
type = type_from_parsed_name (&info, ignoreCase, &error);
mono_reflection_free_type_info (&info);
- g_free (str);
- if (!mono_error_ok (&error)) {
+ if (!is_ok (&error))
+ goto leave;
+
+ if (type == NULL){
+ if (throwOnError) {
+ mono_error_set_type_load_name (&error, g_strdup (str), NULL, "");
+ goto leave;
+ }
+ }
+
+leave:
+ g_free (str);
+ if (!is_ok (&error)) {
if (throwOnError)
mono_error_set_pending_exception (&error);
else
return NULL;
}
- if (type == NULL){
- MonoException *e = NULL;
-
- if (throwOnError)
- e = mono_get_exception_type_load (name, NULL);
-
- if (e) {
- mono_set_pending_exception (e);
- return NULL;
- }
- }
-
return type;
}
}
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetInterfaces (MonoReflectionType* type)
+ves_icall_RuntimeType_GetInterfaces (MonoReflectionType* type)
{
MonoError error;
MonoClass *klass = mono_class_from_mono_type (type->type);
if (len == 0) {
g_hash_table_destroy (iface_hash);
if (!data.domain->empty_types) {
- data.domain->empty_types = mono_array_new_cached (data.domain, mono_defaults.monotype_class, 0, &error);
+ data.domain->empty_types = mono_array_new_cached (data.domain, mono_defaults.runtimetype_class, 0, &error);
if (!is_ok (&error))
goto fail;
}
return data.domain->empty_types;
}
- data.iface_array = mono_array_new_cached (data.domain, mono_defaults.monotype_class, len, &error);
+ data.iface_array = mono_array_new_cached (data.domain, mono_defaults.runtimetype_class, len, &error);
if (!is_ok (&error))
goto fail;
g_hash_table_foreach (iface_hash, fill_iface_array, &data);
}
ICALL_EXPORT void
-ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
+ves_icall_RuntimeType_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
{
gboolean variance_used;
MonoClass *klass = mono_class_from_mono_type (type->type);
}
ICALL_EXPORT void
-ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
+ves_icall_RuntimeType_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
{
MonoError error;
MonoClass *klass = mono_class_from_mono_type (type->type);
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
+ves_icall_RuntimeType_get_DeclaringType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
}
ICALL_EXPORT MonoString*
-ves_icall_MonoType_get_Name (MonoReflectionType *type)
+ves_icall_RuntimeType_get_Name (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (type->type);
}
ICALL_EXPORT MonoString*
-ves_icall_MonoType_get_Namespace (MonoReflectionType *type)
+ves_icall_RuntimeType_get_Namespace (MonoReflectionType *type)
{
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (type->type);
}
ICALL_EXPORT MonoArray*
-ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
+ves_icall_RuntimeType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
{
MonoError error;
MonoReflectionType *rt;
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
+ves_icall_RuntimeType_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
{
MonoError error;
MonoReflectionType *ret;
}
ICALL_EXPORT gint32
-ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
+ves_icall_RuntimeType_GetGenericParameterPosition (MonoReflectionType *type)
{
if (!IS_MONOTYPE (type))
return -1;
}
ICALL_EXPORT GenericParameterAttributes
-ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
+ves_icall_RuntimeType_GetGenericParameterAttributes (MonoReflectionType *type)
{
g_assert (IS_MONOTYPE (type));
g_assert (is_generic_parameter (type->type));
}
ICALL_EXPORT MonoArray *
-ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
+ves_icall_RuntimeType_GetGenericParameterConstraints (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *rt;
for (count = 0, ptr = param_info->constraints; ptr && *ptr; ptr++, count++)
;
- res = mono_array_new_checked (domain, mono_defaults.monotype_class, count, &error);
+ res = mono_array_new_checked (domain, mono_defaults.runtimetype_class, count, &error);
if (mono_error_set_pending_exception (&error))
return NULL;
for (i = 0; i < count; i++) {
}
ICALL_EXPORT MonoReflectionMethod*
-ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
+ves_icall_RuntimeType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
MonoReflectionMethod* generic)
{
MonoDomain *domain;
}
ICALL_EXPORT MonoReflectionMethod *
-ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type)
+ves_icall_RuntimeType_get_DeclaringMethod (MonoReflectionType *ref_type)
{
MonoMethod *method;
MonoType *type = ref_type->type;
return (MonoObject*)arr;
}
}
- return mono_runtime_invoke_array (m, obj, params, NULL);
+ MonoObject *result = mono_runtime_invoke_array_checked (m, obj, params, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
#ifndef DISABLE_REMOTING
}
name = mono_array_get (params, MonoString *, 1);
- str = mono_string_to_utf8 (name);
+ str = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
do {
MonoClassField* field = mono_class_get_field_from_name (k, str);
}
name = mono_array_get (params, MonoString *, 1);
- str = mono_string_to_utf8 (name);
+ str = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
do {
MonoClassField* field = mono_class_get_field_from_name (k, str);
/* This can be called only on MBR objects, so no need to unbox for valuetypes. */
g_assert (!method->method->klass->valuetype);
- result = mono_runtime_invoke_array (method->method, this_arg, params, NULL);
+ result = mono_runtime_invoke_array_checked (method->method, this_arg, params, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0, j = 0; i < mono_array_length (params); i++) {
if (sig->params [i]->byref) {
};
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
+ves_icall_RuntimeType_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
{
MonoError error;
MonoDomain *domain;
if (name != NULL) {
if (utf8_name == NULL) {
- utf8_name = mono_string_to_utf8 (name);
+ utf8_name = mono_string_to_utf8_checked (name, &error);
+ if (!is_ok (&error))
+ goto fail;
compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
}
}
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
+ves_icall_RuntimeType_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
static MonoClass *MethodInfo_array;
MonoError error;
return res;
}
- if (name)
- mname = mono_string_to_utf8 (name);
+ if (name) {
+ mname = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ }
method_array = mono_class_get_methods_by_name (klass, mname, bflags, ignore_case, FALSE, &ex);
g_free ((char*)mname);
}
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
+ves_icall_RuntimeType_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
MonoClass *startklass, *klass, *refklass;
}
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
+ves_icall_RuntimeType_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
MonoError error;
MonoDomain *domain;
klass = startklass = mono_class_from_mono_type (type->type);
if (name != NULL) {
- propname = mono_string_to_utf8 (name);
+ propname = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
}
}
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
+ves_icall_RuntimeType_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
{
MonoError error;
MonoDomain *domain;
if (name != NULL) {
if (utf8_name == NULL) {
- utf8_name = mono_string_to_utf8 (name);
+ utf8_name = mono_string_to_utf8_checked (name, &error);
+ if (!is_ok (&error))
+ goto failure;
compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
}
}
ICALL_EXPORT MonoArray*
-ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags)
+ves_icall_RuntimeType_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
MonoError error;
MonoReflectionType *rt;
domain = ((MonoObject *)type)->vtable->domain;
if (type->type->byref) {
- MonoArray *result = mono_array_new_cached (domain, mono_defaults.monotype_class, 0, &error);
+ MonoArray *result = mono_array_new_cached (domain, mono_defaults.runtimetype_class, 0, &error);
mono_error_set_pending_exception (&error);
return result;
}
if (name != NULL) {
if (str == NULL) {
- str = mono_string_to_utf8 (name);
+ str = mono_string_to_utf8_checked (name, &error);
+ if (!is_ok (&error))
+ goto leave;
mono_identifier_unescape_type_name_chars (str);
}
mono_ptr_array_append (tmp_array, (MonoObject*) rt);
}
- res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array), &error);
+ res = mono_array_new_cached (domain, mono_defaults.runtimetype_class, mono_ptr_array_size (tmp_array), &error);
if (!is_ok (&error))
goto leave;
/* On MS.NET, this does not fire a TypeResolve event */
type_resolve = TRUE;
- str = mono_string_to_utf8 (name);
+ str = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
/*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
if (!mono_reflection_parse_type (str, &info)) {
g_free (str);
MonoImageOpenStatus status;
MonoReflectionAssembly* result = NULL;
- name = mono_string_to_utf8 (mname);
+ name = mono_string_to_utf8_checked (mname, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
res = mono_assembly_load_with_partial_name (name, &status);
g_free (name);
ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
{
MonoError error;
- char *n = mono_string_to_utf8 (name);
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
guint32 i;
guint32 cols [MONO_MANIFEST_SIZE];
const char *val;
MonoImage *module;
+ char *n = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
for (i = 0; i < table->rows; ++i) {
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
const char *val;
char *n;
- n = mono_string_to_utf8 (name);
+ n = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
for (i = 0; i < table->rows; ++i) {
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
/* check hash if needed */
if (name) {
- n = mono_string_to_utf8 (name);
+ n = mono_string_to_utf8_checked (name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
for (i = 0; i < table->rows; ++i) {
val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
if (strcmp (val, n) == 0) {
}
ICALL_EXPORT int
-vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *rfield)
+vell_icall_RuntimeType_get_core_clr_security_level (MonoReflectionType *rfield)
{
MonoError error;
MonoClass *klass = mono_class_from_mono_type (rfield->type);
MonoAssemblyName name;
char *dirname;
- filename = mono_string_to_utf8 (fname);
+ filename = mono_string_to_utf8_checked (fname, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
dirname = g_path_get_dirname (filename);
replace_shadow_path (mono_domain_get (), dirname, &filename);
} else {
count = tdef->rows - 1;
}
- res = mono_array_new_checked (domain, mono_defaults.monotype_class, count, error);
+ res = mono_array_new_checked (domain, mono_defaults.runtimetype_class, count, error);
return_val_if_nok (error, NULL);
*exceptions = mono_array_new_checked (domain, mono_defaults.exception_class, count, error);
return_val_if_nok (error, NULL);
len1 = mono_array_length (res);
len2 = mono_array_length (res2);
- res3 = mono_array_new_checked (domain, mono_defaults.monotype_class, len1 + len2, &error);
+ res3 = mono_array_new_checked (domain, mono_defaults.runtimetype_class, len1 + len2, &error);
if (mono_error_set_pending_exception (&error))
return NULL;
mono_array_memcpy_refs (res3, 0, res, 0, len1);
mono_array_memcpy_refs (res3, len1, res2, 0, len2);
res = res3;
- ex3 = mono_array_new_checked (domain, mono_defaults.monotype_class, len1 + len2, &error);
+ ex3 = mono_array_new_checked (domain, mono_defaults.runtimetype_class, len1 + len2, &error);
if (mono_error_set_pending_exception (&error))
return NULL;
mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1);
gboolean is_token_defined;
aname.public_key = NULL;
- val = mono_string_to_utf8 (assname);
+ val = mono_string_to_utf8_checked (assname, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+
if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) {
g_free ((guint8*) aname.public_key);
g_free (val);
int i;
if (!module->image) {
- MonoArray *arr = mono_array_new_checked (mono_object_domain (module), mono_defaults.monotype_class, 0, &error);
+ MonoArray *arr = mono_array_new_checked (mono_object_domain (module), mono_defaults.runtimetype_class, 0, &error);
mono_error_set_pending_exception (&error);
return arr;
} else {
/* FIXME: What to do if the index points into the middle of a string ? */
- return mono_ldstr (mono_domain_get (), image, index);
+ MonoString *result = mono_ldstr_checked (mono_domain_get (), image, index, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoClassField*
MonoReflectionType *ret;
MonoClass *klass;
int isbyref = 0, rank;
- char *str = mono_string_to_utf8 (smodifiers);
char *p;
+ char *str = mono_string_to_utf8_checked (smodifiers, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
klass = mono_class_from_mono_type (tb->type.type);
p = str;
}
ICALL_EXPORT MonoReflectionType *
-ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
+ves_icall_RuntimeType_make_array_type (MonoReflectionType *type, int rank)
{
MonoError error;
MonoReflectionType *ret;
}
ICALL_EXPORT MonoReflectionType *
-ves_icall_Type_make_byref_type (MonoReflectionType *type)
+ves_icall_RuntimeType_make_byref_type (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
}
ICALL_EXPORT MonoReflectionType *
-ves_icall_Type_MakePointerType (MonoReflectionType *type)
+ves_icall_RuntimeType_MakePointerType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
if (method_is_dynamic (method)) {
/* Creating a trampoline would leak memory */
- func = mono_compile_method (method);
+ func = mono_compile_method_checked (method, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
} else {
if (target && method->flags & METHOD_ATTRIBUTE_VIRTUAL && method->klass != mono_object_class (target))
method = mono_object_get_virtual_method (target, method);
func = mono_create_ftnptr (mono_domain_get (), trampoline);
}
- mono_delegate_ctor_with_method (delegate, target, func, method);
-
+ mono_delegate_ctor_with_method (delegate, target, func, method, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
return delegate;
}
}
tp->custom_type_info = (mono_object_isinst_checked (this_obj, mono_defaults.iremotingtypeinfo_class, &error) != NULL);
- if (!is_ok (&error)) {
- mono_error_set_pending_exception (&error);
+ if (mono_error_set_pending_exception (&error))
return NULL;
- }
tp->remote_class = mono_remote_class (domain, class_name, klass, &error);
- if (!is_ok (&error)) {
- mono_error_set_pending_exception (&error);
+ if (mono_error_set_pending_exception (&error))
return NULL;
- }
- res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp);
+ res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
return res;
}
ICALL_EXPORT MonoString *
ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
{
+ MonoError error;
const gchar *value;
gchar *utf8_name;
if (name == NULL)
return NULL;
- utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
+ utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
value = g_getenv (utf8_name);
g_free (utf8_name);
#endif
}
-/*
- * If your platform lacks setenv/unsetenv, you must upgrade your glib.
- */
-#if !GLIB_CHECK_VERSION(2,4,0)
-#define g_setenv(a,b,c) setenv(a,b,c)
-#define g_unsetenv(a) unsetenv(a)
-#endif
-
ICALL_EXPORT void
ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
{
g_free (utf16_name);
g_free (utf16_value);
#else
- utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
+ utf8_name = mono_string_to_utf8_checked (name, &error); /* FIXME: this should be ascii */
+ if (mono_error_set_pending_exception (&error))
+ return;
if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
g_unsetenv (utf8_name);
MonoReflectionMethod *method,
MonoArray *out_args)
{
- mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args);
+ MonoError error;
+ mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args, &error);
+ mono_error_set_pending_exception (&error);
}
#ifndef DISABLE_REMOTING
ICALL_EXPORT gpointer
ves_icall_RuntimeMethodHandle_GetFunctionPointer (MonoMethod *method)
{
- return mono_compile_method (method);
+ MonoError error;
+ gpointer result = mono_compile_method_checked (method, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoString *
static MonoString *
get_bundled_app_config (void)
{
+ MonoError error;
const gchar *app_config;
MonoDomain *domain;
MonoString *file;
return NULL;
// Retrieve config file and remove the extension
- config_file_name = mono_string_to_utf8 (file);
+ config_file_name = mono_string_to_utf8_checked (file, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
config_file_path = mono_portability_find_file (config_file_name, TRUE);
if (!config_file_path)
config_file_path = config_file_name;
projects / mono.git / blobdiff