* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Copyright 2011-2015 Xamarin Inc (http://www.xamarin.com).
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <mono/metadata/assembly.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/exception.h>
+#include <mono/metadata/exception-internals.h>
#include <mono/metadata/file-io.h>
#include <mono/metadata/console-io.h>
#include <mono/metadata/mono-route.h>
static GENERATE_GET_CLASS_WITH_CACHE (module, System.Reflection, Module)
static MonoArray*
-type_array_from_modifiers (MonoImage *image, MonoType *type, int optional);
+type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error);
static inline MonoBoolean
is_generic_parameter (MonoType *type)
}
static void
-mono_class_init_or_throw (MonoClass *klass)
+mono_class_init_checked (MonoClass *klass, MonoError *error)
{
+ mono_error_init (error);
+
if (!mono_class_init (klass))
- mono_raise_exception (mono_class_get_exception_for_failure (klass));
+ mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (klass));
}
ICALL_EXPORT MonoObject *
ves_icall_System_Array_GetValueImpl (MonoArray *arr, guint32 pos)
{
+ MonoError error;
MonoClass *ac;
gint32 esize;
gpointer *ea;
+ MonoObject *result = NULL;
ac = (MonoClass *)arr->obj.vtable->klass;
esize = mono_array_element_size (ac);
ea = (gpointer*)((char*)arr->vector + (pos * esize));
- if (ac->element_class->valuetype)
- return mono_value_box (arr->obj.vtable->domain, ac->element_class, ea);
- else
- return (MonoObject *)*ea;
+ if (ac->element_class->valuetype) {
+ result = mono_value_box_checked (arr->obj.vtable->domain, ac->element_class, ea, &error);
+ mono_error_set_pending_exception (&error);
+ } else
+ result = (MonoObject *)*ea;
+ return result;
}
ICALL_EXPORT MonoObject *
ICALL_EXPORT void
ves_icall_System_Array_SetValueImpl (MonoArray *arr, MonoObject *value, guint32 pos)
{
+ MonoError error;
MonoClass *ac, *vc, *ec;
gint32 esize, vsize;
gpointer *ea, *va;
gint64 i64 = 0;
gdouble r64 = 0;
+ mono_error_init (&error);
+
if (value)
vc = value->vtable->klass;
else
}
if (!ec->valuetype) {
- if (!mono_object_isinst (value, ec))
+ gboolean castOk = (NULL != mono_object_isinst_checked (value, ec, &error));
+ if (mono_error_set_pending_exception (&error))
+ return;
+ if (!castOk)
INVALID_CAST;
mono_gc_wbarrier_set_arrayref (arr, ea, (MonoObject*)value);
return;
}
- if (mono_object_isinst (value, ec)) {
+ if (mono_object_isinst_checked (value, ec, &error)) {
if (ec->has_references)
mono_value_copy (ea, (char*)value + sizeof (MonoObject), ec);
else
mono_gc_memmove_atomic (ea, (char *)value + sizeof (MonoObject), esize);
return;
}
+ if (mono_error_set_pending_exception (&error))
+ return;
if (!vc->valuetype)
INVALID_CAST;
}
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0))
/* vectors are not the same as one dimensional arrays with no-zero bounds */
}
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint64, 0) != 0))
/* vectors are not the same as one dimensional arrays with no-zero bounds */
ICALL_EXPORT gint32
ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this_obj, MonoArray **fields)
{
+ MonoError error;
MonoClass *klass;
MonoObject **values = NULL;
MonoObject *o;
default:
if (!values)
values = g_newa (MonoObject*, mono_class_num_fields (klass));
- o = mono_field_get_value_object (mono_object_domain (this_obj), field, this_obj);
+ o = mono_field_get_value_object_checked (mono_object_domain (this_obj), field, this_obj, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return 0;
+ }
values [count++] = o;
}
}
ICALL_EXPORT MonoBoolean
ves_icall_System_ValueType_Equals (MonoObject *this_obj, MonoObject *that, MonoArray **fields)
{
+ MonoError error;
MonoClass *klass;
MonoObject **values = NULL;
MonoObject *o;
default:
if (!values)
values = g_newa (MonoObject*, mono_class_num_fields (klass) * 2);
- o = mono_field_get_value_object (mono_object_domain (this_obj), field, this_obj);
+ o = mono_field_get_value_object_checked (mono_object_domain (this_obj), field, this_obj, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return FALSE;
+ }
values [count++] = o;
- o = mono_field_get_value_object (mono_object_domain (this_obj), field, that);
+ o = mono_field_get_value_object_checked (mono_object_domain (this_obj), field, that, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return FALSE;
+ }
values [count++] = o;
}
}
ICALL_EXPORT void
-mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
+ves_icall_MonoType_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
{
mtype->type = &obj->vtable->klass->byval_arg;
g_assert (mtype->type->type);
return obj;
}
+ICALL_EXPORT MonoReflectionModule*
+ves_icall_System_Reflection_Emit_AssemblyBuilder_InternalAddModule (MonoReflectionAssemblyBuilder *ab, MonoString *fileName)
+{
+ MonoError error;
+ MonoReflectionModule *result = mono_image_load_module_dynamic (ab, fileName, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
+ICALL_EXPORT MonoArray*
+ves_icall_System_Reflection_Emit_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
+{
+ MonoError error;
+ MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
static gboolean
get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
if (assembly) {
/* When loading from the current assembly, AppDomain.TypeResolve will not be called yet */
- type = mono_reflection_get_type (assembly->image, info, ignoreCase, &type_resolve);
+ type = mono_reflection_get_type_checked (assembly->image, info, ignoreCase, &type_resolve, error);
+ return_val_if_nok (error, NULL);
}
- if (!info->assembly.name && !type) /* try mscorlib */
- type = mono_reflection_get_type (NULL, info, ignoreCase, &type_resolve);
-
+ if (!info->assembly.name && !type) {
+ /* try mscorlib */
+ type = mono_reflection_get_type_checked (NULL, info, ignoreCase, &type_resolve, error);
+ return_val_if_nok (error, NULL);
+ }
if (assembly && !type && type_resolve) {
type_resolve = FALSE; /* This will invoke TypeResolve if not done in the first 'if' */
- type = mono_reflection_get_type (assembly->image, info, ignoreCase, &type_resolve);
+ type = mono_reflection_get_type_checked (assembly->image, info, ignoreCase, &type_resolve, error);
+ return_val_if_nok (error, NULL);
}
if (!type)
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_type_from_name (MonoString *name,
- MonoBoolean throwOnError,
- MonoBoolean ignoreCase)
+ves_icall_System_Type_internal_from_name (MonoString *name,
+ MonoBoolean throwOnError,
+ MonoBoolean ignoreCase)
{
MonoError error;
char *str = mono_string_to_utf8 (name);
ICALL_EXPORT MonoReflectionType*
-ves_icall_type_from_handle (MonoType *handle)
+ves_icall_System_Type_internal_from_handle (MonoType *handle)
{
MonoError error;
MonoReflectionType *ret;
}
ICALL_EXPORT guint32
-ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
+ves_icall_RuntimeTypeHandle_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
{
MonoClass *klass;
MonoClass *klassc;
}
ICALL_EXPORT guint32
-ves_icall_type_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
+ves_icall_RuntimeTypeHandle_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
{
+ MonoError error;
MonoClass *klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
- return mono_object_isinst (obj, klass) != NULL;
+ mono_class_init_checked (klass, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return FALSE;
+ }
+ guint32 result = (mono_object_isinst_checked (obj, klass, &error) != NULL);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT guint32
-ves_icall_get_attributes (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetAttributes (MonoReflectionType *type)
{
MonoClass *klass = mono_class_from_mono_type (type->type);
return klass->flags;
{
MonoError error;
MonoType *type = mono_field_get_type_checked (field->field, &error);
+ MonoArray *res;
+
if (!mono_error_ok (&error)) {
mono_error_set_pending_exception (&error);
return NULL;
}
- return type_array_from_modifiers (field->field->parent->image, type, optional);
+ res = type_array_from_modifiers (field->field->parent->image, type, optional, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
ICALL_EXPORT int
ICALL_EXPORT MonoArray*
ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
{
+ MonoError error;
MonoDomain *domain = mono_domain_get ();
- return mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL);
+ MonoArray *result = mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionMarshalAsAttribute*
ICALL_EXPORT MonoObject *
ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
{
+ MonoError error;
MonoClass *fklass = field->klass;
MonoClassField *cf = field->field;
MonoDomain *domain = mono_object_domain (field);
return NULL;
}
- if (mono_security_core_clr_enabled ())
- mono_security_core_clr_ensure_reflection_access_field (cf);
+ if (mono_security_core_clr_enabled () &&
+ !mono_security_core_clr_ensure_reflection_access_field (cf, &error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
- return mono_field_get_value_object (domain, cf, obj);
+ MonoObject * result = mono_field_get_value_object_checked (domain, cf, obj, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT void
return;
}
- if (mono_security_core_clr_enabled ())
- mono_security_core_clr_ensure_reflection_access_field (cf);
+ if (mono_security_core_clr_enabled () &&
+ !mono_security_core_clr_ensure_reflection_access_field (cf, &error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
type = mono_field_get_type_checked (cf, &error);
if (!mono_error_ok (&error)) {
} PInfo;
ICALL_EXPORT void
-ves_icall_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
+ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
{
MonoError error;
MonoReflectionType *rt;
}
ICALL_EXPORT void
-ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
+ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
{
MonoError error;
MonoReflectionType *rt;
MonoDomain *domain;
MonoError error;
- mono_class_init_or_throw (klass);
- mono_class_init_or_throw (iclass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
+ mono_class_init_checked (iclass, &error);
+ mono_error_raise_exception (&error);
mono_class_setup_vtable (klass);
ICALL_EXPORT void
ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
{
+ MonoError error;
MonoClass *klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
if (image_is_dynamic (klass->image)) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)type;
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_MonoType_GetElementType (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
}
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
// GetElementType should only return a type for:
// Array Pointer PassedByRef
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_get_type_parent (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
}
ICALL_EXPORT MonoBoolean
-ves_icall_type_ispointer (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsPointer (MonoReflectionType *type)
{
return type->type->type == MONO_TYPE_PTR;
}
ICALL_EXPORT MonoBoolean
-ves_icall_type_isprimitive (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsPrimitive (MonoReflectionType *type)
{
return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
}
ICALL_EXPORT MonoBoolean
-ves_icall_type_isbyref (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsByRef (MonoReflectionType *type)
{
return type->type->byref;
}
ICALL_EXPORT MonoBoolean
-ves_icall_type_iscomobject (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionType *type)
{
+ MonoError error;
MonoClass *klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
return mono_class_is_com_object (klass);
}
+ICALL_EXPORT guint32
+ves_icall_reflection_get_token (MonoObject* obj)
+{
+ MonoError error;
+ guint32 result = mono_reflection_get_token_checked (obj, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
ICALL_EXPORT MonoReflectionModule*
-ves_icall_MonoType_get_Module (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionType *type)
{
MonoError error;
MonoReflectionModule *result = NULL;
}
ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionType *type)
{
MonoError error;
MonoDomain *domain = mono_domain_get ();
}
ICALL_EXPORT gint32
-ves_icall_MonoType_GetArrayRank (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionType *type)
{
MonoClass *klass;
}
ICALL_EXPORT gboolean
-ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition (MonoReflectionType *type)
{
MonoClass *klass;
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
int i, count;
g_assert (IS_MONOTYPE (type));
- mono_class_init_or_throw (mono_class_from_mono_type (type->type));
+ mono_class_init_checked (mono_class_from_mono_type (type->type), &error);
+ mono_error_raise_exception (&error);
count = mono_array_length (type_array);
types = g_new0 (MonoType *, count);
types [i] = t->type;
}
- geninst = mono_reflection_bind_generic_parameters (type, count, types);
+ geninst = mono_reflection_bind_generic_parameters (type, count, types, &error);
g_free (types);
- if (!geninst)
+ if (!geninst) {
+ mono_error_set_pending_exception (&error);
return NULL;
+ }
klass = mono_class_from_mono_type (geninst);
}
ICALL_EXPORT gboolean
-ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionType *type)
{
MonoClass *klass;
}
ICALL_EXPORT MonoBoolean
-ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsGenericVariable (MonoReflectionType *type)
{
return is_generic_parameter (type->type);
}
domain = ((MonoObject *)type)->vtable->domain;
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
*exc = NULL;
- if (mono_security_core_clr_enabled ())
- mono_security_core_clr_ensure_reflection_access_method (m);
+ if (mono_security_core_clr_enabled () &&
+ !mono_security_core_clr_ensure_reflection_access_method (m, &error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (!(m->flags & METHOD_ATTRIBUTE_STATIC)) {
if (!mono_class_vtable_full (mono_object_domain (method), m->klass, &error)) {
}
if (this_arg) {
- if (!mono_object_isinst (this_arg, m->klass)) {
+ if (!mono_object_isinst_checked (this_arg, m->klass, &error)) {
+ if (!is_ok (&error)) {
+ mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_error_convert_to_exception (&error));
+ return NULL;
+ }
char *this_name = mono_type_get_full_name (mono_object_get_class (this_arg));
char *target_name = mono_type_get_full_name (m->klass);
char *msg = g_strdup_printf ("Object of type '%s' doesn't match target type '%s'", this_name, target_name);
ICALL_EXPORT MonoObject *
ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, MonoArray *params, MonoArray **outArgs)
{
+ MonoError error;
MonoDomain *domain = mono_object_domain (method);
MonoMethod *m = method->method;
MonoMethodSignature *sig = mono_method_signature (m);
MonoClassField* field = mono_class_get_field_from_name (k, str);
if (field) {
MonoClass *field_klass = mono_class_from_mono_type (field->type);
- if (field_klass->valuetype)
- result = mono_value_box (domain, field_klass, (char *)this_arg + field->offset);
- else
+ if (field_klass->valuetype) {
+ result = mono_value_box_checked (domain, field_klass, (char *)this_arg + field->offset, &error);
+ mono_error_set_pending_exception (&error);
+ /* fallthru to cleanup */
+ } else
result = (MonoObject *)*((gpointer *)((char *)this_arg + field->offset));
out_args = mono_array_new (domain, mono_defaults.object_class, 1);
domain = mono_object_domain (enumType);
enumc = mono_class_from_mono_type (enumType->type);
- mono_class_init_or_throw (enumc);
+ mono_class_init_checked (enumc, &error);
+ mono_error_raise_exception (&error);
etype = mono_class_enum_basetype (enumc);
MonoClass *klass;
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
etype = mono_class_enum_basetype (klass);
if (!etype) {
ICALL_EXPORT MonoBoolean
ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionType *type, MonoArray **values, MonoArray **names)
{
+ MonoError error;
MonoDomain *domain = mono_object_domain (type);
MonoClass *enumc = mono_class_from_mono_type (type->type);
guint j = 0, nvalues;
guint64 field_value, previous_value = 0;
gboolean sorted = TRUE;
- mono_class_init_or_throw (enumc);
+ mono_class_init_checked (enumc, &error);
+ mono_error_raise_exception (&error);
if (!enumc->enumtype) {
mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
mono_ptr_array_destroy (tmp_array);
- if (!str)
- g_free (str);
+ g_free (str);
return res;
}
}
if (module != NULL) {
- if (module->image)
- type = mono_reflection_get_type (module->image, &info, ignoreCase, &type_resolve);
- else
+ if (module->image) {
+ type = mono_reflection_get_type_checked (module->image, &info, ignoreCase, &type_resolve, &error);
+ if (!is_ok (&error)) {
+ g_free (str);
+ mono_reflection_free_type_info (&info);
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ } else
type = NULL;
}
else
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 (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve);
+ type = mono_reflection_get_type_checked (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve, &error);
+ if (!is_ok (&error)) {
+ g_free (str);
+ mono_reflection_free_type_info (&info);
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (type)
break;
}
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 (mod->image, &info, ignoreCase, &type_resolve);
+ type = mono_reflection_get_type_checked (mod->image, &info, ignoreCase, &type_resolve, &error);
+ if (!is_ok (&error)) {
+ g_free (str);
+ mono_reflection_free_type_info (&info);
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (type)
break;
}
}
}
- else
- type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase, &type_resolve);
+ else {
+ type = mono_reflection_get_type_checked (assembly->assembly->image, &info, ignoreCase, &type_resolve, &error);
+ if (!is_ok (&error)) {
+ g_free (str);
+ mono_reflection_free_type_info (&info);
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ }
g_free (str);
mono_reflection_free_type_info (&info);
if (!type) {
/* g_print ("got it\n"); */
ret = mono_type_get_object_checked (mono_object_domain (assembly), type, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT MonoReflectionMethodBody*
ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
{
- return mono_method_body_get_object (mono_domain_get (), method);
+ MonoError error;
+ MonoReflectionMethodBody *result = mono_method_body_get_object_checked (mono_domain_get (), method, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoReflectionAssembly*
ICALL_EXPORT int
vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *rfield)
{
+ MonoError error;
MonoClass *klass = mono_class_from_mono_type (rfield->type);
- mono_class_init_or_throw (klass);
+
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
return mono_security_core_clr_class_level (klass);
}
if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) {
klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, error);
mono_loader_assert_no_error (); /* Plug any leaks */
- mono_error_assert_ok (error);
if (klass) {
rt = mono_type_get_object_checked (domain, &klass->byval_arg, error);
g_list_free (list);
list = NULL;
- exc = mono_get_exception_reflection_type_load (res, exl);
+ exc = mono_get_exception_reflection_type_load_checked (res, exl, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
mono_loader_clear_error ();
mono_set_pending_exception (exc);
return NULL;
mono_metadata_decode_blob_size (sig, &sig);
return (*sig != 0x6);
} else {
+ MonoError error;
MonoClass *handle_class;
- if (!mono_lookup_dynamic_token_class (image, token, FALSE, &handle_class, NULL))
+ if (!mono_lookup_dynamic_token_class (image, token, FALSE, &handle_class, NULL, &error)) {
+ mono_error_cleanup (&error); /* just probing, ignore error */
return FALSE;
+ }
return mono_defaults.methodhandle_class == handle_class;
}
if (image_is_dynamic (image)) {
if ((table == MONO_TABLE_TYPEDEF) || (table == MONO_TABLE_TYPEREF)) {
- klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
+ mono_error_cleanup (&error);
return klass ? &klass->byval_arg : NULL;
}
init_generic_context_from_args (&context, type_args, method_args);
- klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
+ klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
+ mono_error_cleanup (&error);
return klass ? &klass->byval_arg : NULL;
}
}
if (image_is_dynamic (image)) {
- if (table == MONO_TABLE_METHOD)
- return (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ if (table == MONO_TABLE_METHOD) {
+ method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
+ mono_error_cleanup (&error);
+ return method;
+ }
if ((table == MONO_TABLE_MEMBERREF) && !(mono_memberref_is_method (image, token))) {
*resolve_error = ResolveTokenError_BadTable;
}
init_generic_context_from_args (&context, type_args, method_args);
- return (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
+ method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
+ mono_error_cleanup (&error);
+ return method;
}
if ((index <= 0) || (index > image->tables [table].rows)) {
}
ICALL_EXPORT MonoString*
-ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error)
{
+ MonoError error;
int index = mono_metadata_token_index (token);
- *error = ResolveTokenError_Other;
+ *resolve_error = ResolveTokenError_Other;
/* Validate token */
if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
- *error = ResolveTokenError_BadTable;
+ *resolve_error = ResolveTokenError_BadTable;
return NULL;
}
- if (image_is_dynamic (image))
- return (MonoString *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ if (image_is_dynamic (image)) {
+ MonoString * result = (MonoString *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
+ mono_error_cleanup (&error);
+ return result;
+ }
if ((index <= 0) || (index >= image->heap_us.size)) {
- *error = ResolveTokenError_OutOfRange;
+ *resolve_error = ResolveTokenError_OutOfRange;
return NULL;
}
}
if (image_is_dynamic (image)) {
- if (table == MONO_TABLE_FIELD)
- return (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
+ if (table == MONO_TABLE_FIELD) {
+ field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
+ mono_error_cleanup (&error);
+ return field;
+ }
if (mono_memberref_is_method (image, token)) {
*resolve_error = ResolveTokenError_BadTable;
}
init_generic_context_from_args (&context, type_args, method_args);
- return (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context);
+ field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
+ mono_error_cleanup (&error);
+ return field;
}
if ((index <= 0) || (index > image->tables [table].rows)) {
}
ICALL_EXPORT MonoBoolean
-ves_icall_Type_IsArrayImpl (MonoReflectionType *t)
+ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionType *t)
{
MonoType *type;
MonoBoolean res;
}
static void
-check_for_invalid_type (MonoClass *klass)
+check_for_invalid_type (MonoClass *klass, MonoError *error)
{
char *name;
MonoString *str;
+
+ mono_error_init (error);
+
if (klass->byval_arg.type != MONO_TYPE_TYPEDBYREF)
return;
name = mono_type_get_full_name (klass);
str = mono_string_new (mono_domain_get (), name);
g_free (name);
- mono_raise_exception ((MonoException*)mono_get_exception_type_load (str, NULL));
+ mono_error_set_exception_instance (error, mono_get_exception_type_load (str, NULL));
}
ICALL_EXPORT MonoReflectionType *
MonoClass *klass, *aklass;
klass = mono_class_from_mono_type (type->type);
- check_for_invalid_type (klass);
+ check_for_invalid_type (klass, &error);
+ mono_error_raise_exception (&error);
if (rank == 0) //single dimentional array
aklass = mono_array_class_get (klass, 1);
MonoClass *klass;
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
- check_for_invalid_type (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
+ check_for_invalid_type (klass, &error);
+ mono_error_raise_exception (&error);
ret = mono_type_get_object_checked (mono_object_domain (type), &klass->this_arg, &error);
mono_error_raise_exception (&error);
MonoClass *klass, *pklass;
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
- check_for_invalid_type (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
+ check_for_invalid_type (klass, &error);
+ mono_error_raise_exception (&error);
pklass = mono_ptr_class_get (type->type);
gpointer func;
MonoMethod *method = info->method;
- mono_class_init_or_throw (delegate_class);
+ mono_class_init_checked (delegate_class, &error);
+ mono_error_raise_exception (&error);
- mono_assert (delegate_class->parent == mono_defaults.multicastdelegate_class);
+ if (!(delegate_class->parent == mono_defaults.multicastdelegate_class)) {
+ /* FIXME improve this exception message */
+ mono_error_set_execution_engine (&error, "file %s: line %d (%s): assertion failed: (%s)", __FILE__, __LINE__,
+ __func__,
+ "delegate_class->parent == mono_defaults.multicastdelegate_class");
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (mono_security_core_clr_enabled ()) {
- if (!mono_security_core_clr_ensure_delegate_creation (method, throwOnBindFailure))
+ if (!mono_security_core_clr_ensure_delegate_creation (method, &error)) {
+ if (throwOnBindFailure)
+ mono_error_set_pending_exception (&error);
+ else
+ mono_error_cleanup (&error);
return NULL;
+ }
}
delegate = mono_object_new_checked (mono_object_domain (type), delegate_class, &error);
return NULL;
}
- tp->custom_type_info = (mono_object_isinst (this_obj, mono_defaults.iremotingtypeinfo_class) != NULL);
- tp->remote_class = mono_remote_class (domain, class_name, klass);
+ 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);
+ return NULL;
+ }
+ tp->remote_class = mono_remote_class (domain, class_name, klass, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp);
return res;
method = rmethod->method;
klass = mono_class_from_mono_type (rtype->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
if (MONO_CLASS_IS_INTERFACE (klass))
return NULL;
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
if (MONO_CLASS_IS_INTERFACE (klass) || (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) {
mono_set_pending_exception (mono_get_exception_argument ("type", "Type cannot be instantiated"));
#endif
ICALL_EXPORT gpointer
-ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
+ves_icall_RuntimeMethodHandle_GetFunctionPointer (MonoMethod *method)
{
return mono_compile_method (method);
}
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
if (mono_class_is_nullable (klass))
/* No arguments -> null */
ICALL_EXPORT MonoObject*
mono_TypedReference_ToObject (MonoTypedRef* tref)
{
+ MonoError error;
+ MonoObject *result = NULL;
if (MONO_TYPE_IS_REFERENCE (tref->type)) {
MonoObject** objp = (MonoObject **)tref->value;
return *objp;
}
- return mono_value_box (mono_domain_get (), tref->klass, tref->value);
+ result = mono_value_box_checked (mono_domain_get (), tref->klass, tref->value, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoTypedRef
}
static void
-prelink_method (MonoMethod *method)
+prelink_method (MonoMethod *method, MonoError *error)
{
const char *exc_class, *exc_arg;
+
+ mono_error_init (error);
if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
return;
mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
if (exc_class) {
- mono_raise_exception(
- mono_exception_from_name_msg (mono_defaults.corlib, "System", exc_class, exc_arg ) );
+ mono_error_set_exception_instance (error,
+ mono_exception_from_name_msg (mono_defaults.corlib, "System", exc_class, exc_arg));
+ return;
}
/* create the wrapper, too? */
}
ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
{
- prelink_method (method->method);
+ MonoError error;
+
+ prelink_method (method->method, &error);
+ mono_error_raise_exception (&error);
}
ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType *type)
{
+ MonoError error;
MonoClass *klass = mono_class_from_mono_type (type->type);
MonoMethod* m;
gpointer iter = NULL;
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ mono_error_raise_exception (&error);
- while ((m = mono_class_get_methods (klass, &iter)))
- prelink_method (m);
+ while ((m = mono_class_get_methods (klass, &iter))) {
+ prelink_method (m, &error);
+ mono_error_raise_exception (&error);
+ }
}
/* These parameters are "readonly" in corlib/System/NumberFormatter.cs */
/*
* We return NULL for no modifiers so the corlib code can return Type.EmptyTypes
* and avoid useless allocations.
- *
- * MAY THROW
*/
static MonoArray*
-type_array_from_modifiers (MonoImage *image, MonoType *type, int optional)
+type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error)
{
- MonoError error;
MonoReflectionType *rt;
MonoArray *res;
int i, count = 0;
+
+ mono_error_init (error);
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required))
count++;
count = 0;
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
- MonoClass *klass = mono_class_get_checked (image, type->modifiers [i].token, &error);
- mono_error_raise_exception (&error); /* this is safe, no cleanup needed on callers */
+ MonoClass *klass = mono_class_get_checked (image, type->modifiers [i].token, error);
+ return_val_if_nok (error, NULL);
- rt = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ rt = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
+ return_val_if_nok (error, NULL);
mono_array_setref (res, count, rt);
count++;
}
ICALL_EXPORT MonoArray*
-param_info_get_type_modifiers (MonoReflectionParameter *param, MonoBoolean optional)
+ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameter *param, MonoBoolean optional)
{
+ MonoError error;
MonoType *type = param->ClassImpl->type;
MonoClass *member_class = mono_object_class (param->MemberImpl);
MonoMethod *method = NULL;
MonoImage *image;
int pos;
MonoMethodSignature *sig;
+ MonoArray *res;
if (mono_class_is_reflection_method_or_constructor (member_class)) {
MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
else
type = sig->params [pos];
- return type_array_from_modifiers (image, type, optional);
+ res = type_array_from_modifiers (image, type, optional, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
static MonoType*
}
ICALL_EXPORT MonoArray*
-property_info_get_type_modifiers (MonoReflectionProperty *property, MonoBoolean optional)
+ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionProperty *property, MonoBoolean optional)
{
+ MonoError error;
MonoType *type = get_property_type (property->property);
MonoImage *image = property->klass->image;
+ MonoArray *res;
if (!type)
return NULL;
- return type_array_from_modifiers (image, type, optional);
+ res = type_array_from_modifiers (image, type, optional, &error);
+ mono_error_raise_exception (&error);
+ return res;
}
/*
ICALL_EXPORT MonoObject*
property_info_get_default_value (MonoReflectionProperty *property)
{
+ MonoError error;
MonoType blob_type;
MonoProperty *prop = property->property;
MonoType *type = get_property_type (prop);
def_value = mono_class_get_property_default_value (prop, &def_type);
mono_type_from_blob_type (&blob_type, def_type, type);
- o = mono_get_object_from_blob (domain, &blob_type, def_value);
+ o = mono_get_object_from_blob (domain, &blob_type, def_value, &error);
+ mono_error_set_pending_exception (&error);
return o;
}
ICALL_EXPORT MonoBoolean
custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type)
{
+ MonoError error;
MonoClass *attr_class = mono_class_from_mono_type (attr_type->type);
MonoCustomAttrInfo *cinfo;
gboolean found;
- mono_class_init_or_throw (attr_class);
+ mono_class_init_checked (attr_class, &error);
+ mono_error_raise_exception (&error);
- cinfo = mono_reflection_get_custom_attrs_info (obj);
+ cinfo = mono_reflection_get_custom_attrs_info_checked (obj, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return FALSE;
+ }
if (!cinfo)
return FALSE;
found = mono_custom_attrs_has_attr (cinfo, attr_class);
MonoArray *res;
MonoError error;
- if (attr_class)
- mono_class_init_or_throw (attr_class);
+ if (attr_class) {
+ mono_class_init_checked (attr_class, &error);
+ mono_error_raise_exception (&error);
+ }
res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
if (!mono_error_ok (&error)) {
return message;
}
-ICALL_EXPORT int
-ves_icall_System_StackFrame_GetILOffsetFromFile (MonoString *path, guint32 method_token, guint32 method_index, int native_offset)
-{
- guint32 il_offset;
- char *path_str = mono_string_to_utf8 (path);
-
- if (!mono_seq_point_data_get_il_offset (path_str, method_token, method_index, native_offset, &il_offset))
- il_offset = -1;
-
- g_free (path_str);
-
- return il_offset;
-}
-
ICALL_EXPORT gpointer
ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
{
projects / mono.git / blobdiff