* 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>
ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
+/* Lazy class loading functions */
+static GENERATE_GET_CLASS_WITH_CACHE (system_version, System, Version)
+static GENERATE_GET_CLASS_WITH_CACHE (assembly_name, System.Reflection, AssemblyName)
+static GENERATE_GET_CLASS_WITH_CACHE (constructor_info, System.Reflection, ConstructorInfo)
+static GENERATE_GET_CLASS_WITH_CACHE (property_info, System.Reflection, PropertyInfo)
+static GENERATE_GET_CLASS_WITH_CACHE (event_info, System.Reflection, EventInfo)
+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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
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 */
mono_gc_bzero_atomic (mono_array_addr_with_size_fast (arr, sz, idx), length * sz);
}
+ICALL_EXPORT MonoArray*
+ves_icall_System_Array_Clone (MonoArray *arr)
+{
+ MonoError error;
+ MonoArray *result = mono_array_clone_checked (arr, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
ICALL_EXPORT gboolean
ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
{
ICALL_EXPORT void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
{
+ MonoError error;
MonoClass *klass;
MonoVTable *vtable;
if (klass->generic_container)
return;
- vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE);
+ vtable = mono_class_vtable_full (mono_domain_get (), klass, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
/* This will call the type constructor */
- mono_runtime_class_init (vtable);
+ if (!mono_runtime_class_init_full (vtable, &error))
+ mono_error_set_pending_exception (&error);
}
ICALL_EXPORT void
return;
}
/*It's fine to raise the exception here*/
- mono_runtime_class_init (mono_class_vtable_full (mono_domain_get (), module_klass, TRUE));
+ MonoVTable * vtable = mono_class_vtable_full (mono_domain_get (), module_klass, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
+ if (!mono_runtime_class_init_full (vtable, &error))
+ mono_error_set_pending_exception (&error);
}
}
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;
}
}
if (values) {
int i;
- mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count));
+ MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return 0;
+ mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr);
for (i = 0; i < count; ++i)
mono_array_setref (*fields, i, values [i]);
} else {
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;
}
if (values) {
int i;
- mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count));
+ MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+ mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr);
for (i = 0; i < count; ++i)
mono_array_setref_fast (*fields, i, values [i]);
return FALSE;
#endif
ret = mono_type_get_object_checked (mono_object_domain (obj), &obj->vtable->klass->byval_arg, &error);
- mono_error_raise_exception (&error);
-
+ mono_error_set_pending_exception (&error);
return ret;
}
-ICALL_EXPORT void
-mono_type_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)
{
MonoError error;
gint32 result = mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return result;
}
MonoError error;
gint32 result = mono_image_create_method_token (
mb->dynamic_image, (MonoObject *) method, opt_param_types, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return result;
}
{
MonoError error;
mono_image_create_pefile (mb, file, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
}
ICALL_EXPORT void
ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
{
MonoError error;
- if (!mono_image_build_metadata (mb, &error))
- mono_error_raise_exception (&error);
+ mono_image_build_metadata (mb, &error);
+ mono_error_set_pending_exception (&error);
}
ICALL_EXPORT void
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;
+}
+
+/**
+ * ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class:
+ * @tb: a TypeBuilder object
+ *
+ * (icall)
+ * Creates the generic class after all generic parameters have been added.
+ */
+ICALL_EXPORT void
+ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class (MonoReflectionTypeBuilder *tb)
+{
+ MonoError error;
+ (void) mono_reflection_create_generic_class (tb, &error);
+ mono_error_set_pending_exception (&error);
+}
+
+#ifndef DISABLE_REFLECTION_EMIT
+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;
+}
+#endif
+
static gboolean
-get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
+get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
MonoMethod **dest = (MonoMethod **)data;
if (!managed)
return FALSE;
- if (m == *dest) {
- *dest = NULL;
- return FALSE;
- }
if (!(*dest)) {
+ if (!strcmp (m->klass->name_space, "System.Reflection"))
+ return FALSE;
*dest = m;
return TRUE;
}
}
static gboolean
-get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
+get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
MonoMethod **dest = (MonoMethod **)data;
if (!managed)
return FALSE;
+ if (m->wrapper_type != MONO_WRAPPER_NONE)
+ return FALSE;
+
+ if (m == *dest) {
+ *dest = NULL;
+ return FALSE;
+ }
+
+ if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection"))
+ return FALSE;
+
if (!(*dest)) {
- if (!strcmp (m->klass->name_space, "System.Reflection"))
- return FALSE;
*dest = m;
return TRUE;
}
}
static gboolean
-get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
+get_caller_no_system_or_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
{
MonoMethod **dest = (MonoMethod **)data;
if (m->wrapper_type != MONO_WRAPPER_NONE)
return FALSE;
- if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection"))
- return FALSE;
-
if (m == *dest) {
*dest = NULL;
return FALSE;
}
+
+ if (m->klass->image == mono_defaults.corlib && ((!strcmp (m->klass->name_space, "System.Reflection"))
+ || (!strcmp (m->klass->name_space, "System"))))
+ return FALSE;
+
if (!(*dest)) {
*dest = m;
return TRUE;
}
static MonoReflectionType *
-type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase)
+type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoError *error)
{
- MonoError error;
- MonoReflectionType *ret;
MonoMethod *m, *dest;
MonoType *type = NULL;
MonoAssembly *assembly = NULL;
gboolean type_resolve = FALSE;
+ MonoImage *rootimage = NULL;
+
+ mono_error_init (error);
/*
* We must compute the calling assembly as type loading must happen under a metadata context.
*/
m = mono_method_get_last_managed ();
dest = m;
-
- mono_stack_walk_no_il (get_caller_no_reflection, &dest);
- if (!dest)
- dest = m;
+ if (m && m->klass->image != mono_defaults.corlib) {
+ /* Happens with inlining */
+ } else {
+ /* Ugly hack: type_from_parsed_name is called from
+ * System.Type.internal_from_name, which is called most
+ * directly from System.Type.GetType(string,bool,bool) but
+ * also indirectly from places such as
+ * System.Type.GetType(string,func,func) (via
+ * System.TypeNameParser.GetType and System.TypeSpec.Resolve)
+ * so we need to skip over all of those to find the true caller.
+ *
+ * It would be nice if we had stack marks.
+ */
+ mono_stack_walk_no_il (get_caller_no_system_or_reflection, &dest);
+ if (!dest)
+ dest = m;
+ }
/*
* FIXME: mono_method_get_last_managed() sometimes returns NULL, thus
if (dest) {
assembly = dest->klass->image->assembly;
type_resolve = TRUE;
+ rootimage = assembly->image;
} else {
g_warning (G_STRLOC);
}
if (info->assembly.name)
assembly = mono_assembly_load (&info->assembly, assembly ? assembly->basedir : NULL, NULL);
-
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 (rootimage, 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);
-
+ // XXXX - aleksey -
+ // Say we're looking for System.Generic.Dict<int, Local>
+ // we FAIL the get type above, because S.G.Dict isn't in assembly->image. So we drop down here.
+ // but then we FAIL AGAIN because now we pass null as the image and the rootimage and everything
+ // is messed up when we go to construct the Local as the type arg...
+ //
+ // By contrast, if we started with Mine<System.Generic.Dict<int, Local>> we'd go in with assembly->image
+ // as the root and then even the detour into generics would still not screw us when we went to load Local.
+ if (!info->assembly.name && !type) {
+ /* try mscorlib */
+ type = mono_reflection_get_type_checked (rootimage, 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 (rootimage, assembly->image, info, ignoreCase, &type_resolve, error);
+ return_val_if_nok (error, NULL);
}
if (!type)
return NULL;
- ret = mono_type_get_object_checked (mono_domain_get (), type, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
-
- return ret;
-}
-
-#ifdef UNUSED
-MonoReflectionType *
-mono_type_get (const char *str)
-{
- char *copy = g_strdup (str);
- MonoTypeNameParse info;
- MonoReflectionType *type;
- gboolean parsedOk;
-
- parsedOk = mono_reflection_parse_type(copy, &info);
- if (!parsedOk) {
- mono_reflection_free_type_info (&info);
- g_free(copy);
- return NULL;
- }
-
- type = type_from_parsed_name (&info, FALSE);
-
- mono_reflection_free_type_info (&info);
- g_free(copy);
-
- return type;
+ return mono_type_get_object_checked (mono_domain_get (), type, error);
}
-#endif
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)
{
- char *str = mono_string_to_utf8 (name);
+ MonoError error;
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);
- g_free (str);
- if (throwOnError) {
- mono_set_pending_exception (mono_get_exception_argument("typeName", "failed parse"));
- }
- return NULL;
+ if (throwOnError)
+ mono_error_set_argument (&error, "typeName", "failed parse: %s", str);
+ goto leave;
}
- type = type_from_parsed_name (&info, ignoreCase);
+ type = type_from_parsed_name (&info, ignoreCase, &error);
mono_reflection_free_type_info (&info);
- g_free (str);
- if (type == NULL){
- MonoException *e = NULL;
-
- if (throwOnError)
- e = mono_get_exception_type_load (name, NULL);
+ if (!is_ok (&error))
+ goto leave;
- mono_loader_clear_error ();
- if (e) {
- mono_set_pending_exception (e);
- return NULL;
+ 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
+ mono_error_cleanup (&error);
+ return NULL;
+ }
+
return type;
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_type_from_handle (MonoType *handle)
+ves_icall_System_Type_internal_from_handle (MonoType *handle)
{
MonoError error;
MonoReflectionType *ret;
MonoDomain *domain = mono_domain_get ();
ret = mono_type_get_object_checked (domain, handle, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return 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;
ICALL_EXPORT MonoReflectionMarshalAsAttribute*
ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionField *field)
{
+ MonoError error;
MonoClass *klass = field->field->parent;
MonoMarshalType *info;
MonoType *ftype;
if (info->fields [i].field == field->field) {
if (!info->fields [i].mspec)
return NULL;
- else
- return mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
+ else {
+ MonoReflectionMarshalAsAttribute* obj;
+ obj = mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec, &error);
+ if (!mono_error_ok (&error))
+ mono_error_set_pending_exception (&error);
+ return obj;
+ }
}
}
}
MonoReflectionField *result = mono_field_get_object_checked (mono_domain_get (), klass, handle, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return result;
}
{
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_set_pending_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*
ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
{
+ MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoReflectionMarshalAsAttribute* res = NULL;
MonoMarshalSpec **mspecs;
mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
mono_method_get_marshal_info (method, mspecs);
- if (mspecs [0])
- res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0]);
+ if (mspecs [0]) {
+ res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0], &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ }
for (i = mono_method_signature (method)->param_count; i >= 0; i--)
if (mspecs [i])
parent = declaring? field->field->parent: field->klass;
ret = mono_type_get_object_checked (mono_object_domain (field), &parent->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
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)) {
}
if (type->attrs & FIELD_ATTRIBUTE_STATIC) {
- MonoVTable *vtable = mono_class_vtable_full (mono_object_domain (field), cf->parent, TRUE);
- if (!vtable->initialized)
- mono_runtime_class_init (vtable);
+ MonoVTable *vtable = mono_class_vtable_full (mono_object_domain (field), cf->parent, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
+ if (!vtable->initialized) {
+ if (!mono_runtime_class_init_full (vtable, &error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
+ }
mono_field_static_set_value (vtable, cf, v);
} else {
mono_field_set_value (obj, cf, v);
return NULL;
}
v = ((gchar *) o) + sizeof (MonoObject);
- mono_get_constant_value_from_blob (domain, def_type, def_value, v);
+ mono_get_constant_value_from_blob (domain, def_type, def_value, v, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
break;
}
case MONO_TYPE_STRING:
case MONO_TYPE_CLASS:
- mono_get_constant_value_from_blob (domain, def_type, def_value, &o);
+ mono_get_constant_value_from_blob (domain, def_type, def_value, &o, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
break;
default:
g_assert_not_reached ();
} 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;
if ((req_info & PInfo_ReflectedType) != 0) {
rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
MONO_STRUCT_SETREF (info, parent, rt);
}
if ((req_info & PInfo_DeclaringType) != 0) {
rt = mono_type_get_object_checked (domain, &pproperty->parent->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
MONO_STRUCT_SETREF (info, declaring_type, rt);
}
(((pproperty->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
pproperty->get->klass == property->klass)) {
rm = mono_method_get_object_checked (domain, pproperty->get, property->klass, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
} else {
rm = NULL;
}
(((pproperty->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
pproperty->set->klass == property->klass)) {
rm = mono_method_get_object_checked (domain, pproperty->set, property->klass, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
} else {
rm = NULL;
}
}
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 = mono_object_domain (event);
rt = mono_type_get_object_checked (domain, &event->klass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
MONO_STRUCT_SETREF (info, reflected_type, rt);
rt = mono_type_get_object_checked (domain, &event->event->parent->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
MONO_STRUCT_SETREF (info, declaring_type, rt);
if (event->event->add) {
rm = mono_method_get_object_checked (domain, event->event->add, NULL, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
} else {
rm = NULL;
}
if (event->event->remove) {
rm = mono_method_get_object_checked (domain, event->event->remove, NULL, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
} else {
rm = NULL;
}
if (event->event->raise) {
rm = mono_method_get_object_checked (domain, event->event->raise, NULL, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
} else {
rm = NULL;
}
int i, n = 0;
while (event->event->other [n])
n++;
- MONO_STRUCT_SETREF (info, other_methods, mono_array_new (domain, mono_defaults.method_info_class, n));
+ MonoArray *info_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ MONO_STRUCT_SETREF (info, other_methods, info_arr);
for (i = 0; i < n; i++) {
rm = mono_method_get_object_checked (domain, event->event->other [i], NULL, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
mono_array_setref (info->other_methods, i, rm);
}
}
}
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);
len = g_hash_table_size (iface_hash);
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);
+ if (!data.domain->empty_types) {
+ 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);
+ 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);
if (!mono_error_ok (&error))
goto fail;
}
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);
MonoDomain *domain;
MonoError error;
- mono_class_init_or_throw (klass);
- mono_class_init_or_throw (iclass);
+ mono_class_init_checked (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ mono_class_init_checked (iclass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
mono_class_setup_vtable (klass);
len = mono_class_num_methods (iclass);
domain = mono_object_domain (type);
- mono_gc_wbarrier_generic_store (targets, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
- mono_gc_wbarrier_generic_store (methods, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
+ MonoArray *targets_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ mono_gc_wbarrier_generic_store (targets, (MonoObject*) targets_arr);
+ MonoArray *methods_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ mono_gc_wbarrier_generic_store (methods, (MonoObject*) methods_arr);
iter = NULL;
while ((method = mono_class_get_methods (iclass, &iter))) {
member = mono_method_get_object_checked (domain, method, iclass, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
mono_array_setref (*methods, i, member);
member = mono_method_get_object_checked (domain, klass->vtable [i + ioffset], klass, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return;
mono_array_setref (*targets, i, member);
i ++;
}
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);
- mono_class_init_or_throw (klass);
+
+ mono_class_init_checked (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
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;
if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY) {
ret = mono_type_get_object_checked (mono_object_domain (type), &type->type->data.klass->byval_arg, &error);
- mono_error_raise_exception (&error);
-
+ mono_error_set_pending_exception (&error);
return ret;
}
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
// GetElementType should only return a type for:
// Array Pointer PassedByRef
else
return NULL;
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_get_type_parent (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
return NULL;
ret = mono_type_get_object_checked (mono_object_domain (type), &klass->parent->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return 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);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
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;
MonoClass *klass = mono_class_from_mono_type (type->type);
result = mono_module_get_object_checked (mono_object_domain (type), klass->image, &error);
- if (!mono_error_ok (&error))
- mono_error_set_pending_exception (&error);
+ mono_error_set_pending_exception (&error);
return result;
}
ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionType *type)
{
MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (type->type);
MonoReflectionAssembly *result = mono_assembly_get_object_checked (domain, klass->image->assembly, &error);
- if (!result)
- mono_error_set_pending_exception (&error);
+ mono_error_set_pending_exception (&error);
return result;
}
ICALL_EXPORT MonoReflectionType*
-ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
+ves_icall_RuntimeType_get_DeclaringType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
return NULL;
ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return 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 gint32
-ves_icall_MonoType_GetArrayRank (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionType *type)
{
MonoClass *klass;
}
static MonoArray*
-create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count)
+create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count, MonoError *error)
{
- MonoArray *res;
- res = mono_array_new (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count);
- return res;
+ return mono_array_new_checked (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count, error);
}
ICALL_EXPORT MonoArray*
-ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
+ves_icall_RuntimeType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
{
MonoError error;
MonoReflectionType *rt;
if (klass->generic_container) {
MonoGenericContainer *container = klass->generic_container;
- res = create_type_array (domain, runtimeTypeArray, container->type_argc);
+ res = create_type_array (domain, runtimeTypeArray, container->type_argc, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < container->type_argc; ++i) {
pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i));
rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, i, rt);
}
} else if (klass->generic_class) {
MonoGenericInst *inst = klass->generic_class->context.class_inst;
- res = create_type_array (domain, runtimeTypeArray, inst->type_argc);
+ res = create_type_array (domain, runtimeTypeArray, inst->type_argc, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < inst->type_argc; ++i) {
rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, i, rt);
}
}
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;
return (MonoReflectionType *)tb;
else {
ret = mono_type_get_object_checked (mono_object_domain (type), &generic_class->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
}
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;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
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);
}
ret = mono_type_get_object_checked (mono_object_domain (type), geninst, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT gboolean
-ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionType *type)
{
MonoClass *klass;
}
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 (domain, mono_defaults.monotype_class, count);
+ 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++) {
rt = mono_type_get_object_checked (domain, ¶m_info->constraints [i]->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, i, rt);
}
}
ICALL_EXPORT MonoBoolean
-ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
+ves_icall_RuntimeTypeHandle_IsGenericVariable (MonoReflectionType *type)
{
return is_generic_parameter (type->type);
}
}
ICALL_EXPORT MonoReflectionMethod*
-ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
+ves_icall_RuntimeType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
MonoReflectionMethod* generic)
{
MonoDomain *domain;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if (method->token == generic->method->token) {
ret = mono_method_get_object_checked (domain, method, klass, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
}
}
}
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;
if (inst) {
count = inst->type_argc;
- res = mono_array_new (domain, mono_defaults.systemtype_class, count);
+ res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < count; i++) {
rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, i, rt);
}
}
count = mono_method_signature (method->method)->generic_param_count;
- res = mono_array_new (domain, mono_defaults.systemtype_class, count);
+ res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < count; i++) {
MonoGenericContainer *container = mono_method_get_generic_container (method->method);
MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, i, rt);
}
*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, FALSE)) {
+ if (!mono_class_vtable_full (mono_object_domain (method), m->klass, &error)) {
+ mono_error_cleanup (&error); /* FIXME does this make sense? */
mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_class_get_exception_for_failure (m->klass));
return NULL;
}
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);
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
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);
}
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);
if (field) {
+ g_free (str);
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ } else
result = (MonoObject *)*((gpointer *)((char *)this_arg + field->offset));
- out_args = mono_array_new (domain, mono_defaults.object_class, 1);
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
mono_array_setref (out_args, 0, result);
- g_free (str);
return NULL;
}
k = k->parent;
}
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);
if (field) {
+ g_free (str);
MonoClass *field_klass = mono_class_from_mono_type (field->type);
MonoObject *val = (MonoObject *)mono_array_get (params, gpointer, 2);
mono_gc_wbarrier_set_field (this_arg, (char*)this_arg + field->offset, val);
}
- out_args = mono_array_new (domain, mono_defaults.object_class, 0);
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, 0, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
- g_free (str);
return NULL;
}
outarg_count++;
}
- out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count);
-
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, outarg_count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
/* handle constructors only for objects already allocated */
if (!strcmp (method->method->name, ".ctor"))
g_assert (this_arg);
/* 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) {
break;
}
case MONO_TYPE_U2:
- case MONO_TYPE_I2: {
+ case MONO_TYPE_I2:
+ case MONO_TYPE_CHAR: {
guint16 *p = (guint16 *)mem;
*p = value;
break;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
etype = mono_class_enum_basetype (enumc);
res = mono_object_new_checked (domain, enumc, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
write_enum_value ((char *)res + sizeof (MonoObject), etype->type, value);
return res;
enumc = mono_class_from_mono_type (mono_class_enum_basetype (eobj->vtable->klass));
res = mono_object_new_checked (mono_object_domain (eobj), enumc, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
dst = (char *)res + sizeof (MonoObject);
src = (char *)eobj + sizeof (MonoObject);
size = mono_class_value_size (enumc, NULL);
MonoClass *klass;
klass = mono_class_from_mono_type (type->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
etype = mono_class_enum_basetype (klass);
if (!etype) {
}
ret = mono_type_get_object_checked (mono_object_domain (type), etype, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
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);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+
if (!enumc->enumtype) {
mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
base_type = mono_class_enum_basetype (enumc)->type;
nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0;
- *names = mono_array_new (domain, mono_defaults.string_class, nvalues);
- *values = mono_array_new (domain, mono_defaults.uint64_class, nvalues);
+ *names = mono_array_new_checked (domain, mono_defaults.string_class, nvalues, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+ *values = mono_array_new_checked (domain, mono_defaults.uint64_class, nvalues, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
iter = NULL;
while ((field = mono_class_get_fields (enumc, &iter))) {
};
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;
MonoPtrArray tmp_array;
domain = ((MonoObject *)type)->vtable->domain;
- if (type->type->byref)
- return mono_array_new (domain, mono_defaults.field_info_class, 0);
+ if (type->type->byref) {
+ MonoArray *result = mono_array_new_checked (domain, mono_defaults.field_info_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
klass = startklass = mono_class_from_mono_type (type->type);
refklass = mono_class_from_mono_type (reftype->type);
mono_ptr_array_init (tmp_array, 2, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection fields list");
handle_parent:
- if (klass->exception_type != MONO_EXCEPTION_NONE) {
+ if (mono_class_has_failure (klass)) {
mono_ptr_array_destroy (tmp_array);
mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
return NULL;
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;
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
- res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array));
+ res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array), &error);
+ if (!is_ok (&error))
+ goto fail;
for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
return res;
fail:
mono_ptr_array_destroy (tmp_array);
- mono_error_raise_exception (&error);
- g_assert_not_reached ();
+ mono_error_set_pending_exception (&error);
+ return NULL;
}
static gboolean
/* An optimization for calls made from Delegate:CreateDelegate () */
if (klass->delegate && name && !strcmp (name, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) {
method = mono_get_delegate_invoke (klass);
- if (mono_loader_get_last_error ())
- goto loader_error;
+ g_assert (method);
g_ptr_array_add (array, method);
return array;
mono_class_setup_methods (klass);
mono_class_setup_vtable (klass);
- if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
+ if (mono_class_has_failure (klass))
goto loader_error;
if (is_generic_parameter (&klass->byval_arg))
handle_parent:
mono_class_setup_methods (klass);
mono_class_setup_vtable (klass);
- if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
+ if (mono_class_has_failure (klass))
goto loader_error;
iter = NULL;
g_free (method_slots);
g_ptr_array_free (array, TRUE);
- if (klass->exception_type != MONO_EXCEPTION_NONE) {
+ if (mono_class_has_failure (klass)) {
*ex = mono_class_get_exception_for_failure (klass);
} else {
- *ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
- mono_loader_clear_error ();
+ *ex = mono_get_exception_execution_engine ("Unknown error");
}
return NULL;
}
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;
klass = mono_class_from_mono_type (type->type);
refklass = mono_class_from_mono_type (reftype->type);
domain = ((MonoObject *)type)->vtable->domain;
- array_vtable = mono_class_vtable_full (domain, MethodInfo_array, TRUE);
+ array_vtable = mono_class_vtable_full (domain, MethodInfo_array, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (type->type->byref) {
res = mono_array_new_specific_checked (array_vtable, 0, &error);
mono_error_set_pending_exception (&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;
- static MonoClass *System_Reflection_ConstructorInfo;
MonoClass *startklass, *klass, *refklass;
- MonoArray *res;
+ MonoArray *res = NULL;
MonoMethod *method;
MonoObject *member;
int i, match;
MonoPtrArray tmp_array;
MonoError error;
+ domain = ((MonoObject *)type)->vtable->domain;
+ if (type->type->byref) {
+ res = mono_array_new_cached (domain, mono_defaults.method_info_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
+ }
+
mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection constructors list"); /*FIXME, guestimating*/
- domain = ((MonoObject *)type)->vtable->domain;
- if (type->type->byref)
- return mono_array_new_cached (domain, mono_defaults.method_info_class, 0);
+
klass = startklass = mono_class_from_mono_type (type->type);
refklass = mono_class_from_mono_type (reftype->type);
- if (!System_Reflection_ConstructorInfo)
- System_Reflection_ConstructorInfo = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
-
mono_class_setup_methods (klass);
- if (klass->exception_type != MONO_EXCEPTION_NONE) {
+ if (mono_class_has_failure (klass)) {
mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
- return NULL;
+ goto leave;
}
iter = NULL;
if (!match)
continue;
member = (MonoObject*)mono_method_get_object_checked (domain, method, refklass, &error);
- if (!mono_error_ok (&error)) {
- mono_error_set_pending_exception (&error);
- return NULL;
- }
+ if (mono_error_set_pending_exception (&error))
+ goto leave;
mono_ptr_array_append (tmp_array, member);
}
- res = mono_array_new_cached (domain, System_Reflection_ConstructorInfo, mono_ptr_array_size (tmp_array));
+ res = mono_array_new_cached (domain, mono_class_get_constructor_info_class (), mono_ptr_array_size (tmp_array), &error);
+ if (mono_error_set_pending_exception (&error))
+ goto leave;
for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
+leave:
mono_ptr_array_destroy (tmp_array);
return res;
}
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)
{
- MonoException *ex;
+ MonoError error;
MonoDomain *domain;
- static MonoClass *System_Reflection_PropertyInfo;
MonoClass *startklass, *klass;
MonoArray *res;
MonoMethod *method;
GHashTable *properties = NULL;
MonoPtrArray tmp_array;
- mono_ptr_array_init (tmp_array, 8, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection properties list"); /*This the average for ASP.NET types*/
+ mono_error_init (&error);
+
+ domain = ((MonoObject *)type)->vtable->domain;
+ if (type->type->byref) {
+ res = mono_array_new_cached (domain, mono_class_get_property_info_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
+ }
- if (!System_Reflection_PropertyInfo)
- System_Reflection_PropertyInfo = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection", "PropertyInfo");
+ mono_ptr_array_init (tmp_array, 8, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection properties list"); /*This the average for ASP.NET types*/
- domain = ((MonoObject *)type)->vtable->domain;
- if (type->type->byref)
- return mono_array_new_cached (domain, System_Reflection_PropertyInfo, 0);
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;
}
handle_parent:
mono_class_setup_methods (klass);
mono_class_setup_vtable (klass);
- if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
+ if (mono_class_has_failure (klass))
goto loader_error;
iter = NULL;
if (g_hash_table_lookup (properties, prop))
continue;
- mono_ptr_array_append (tmp_array, mono_property_get_object (domain, startklass, prop));
+ MonoReflectionProperty *pr = mono_property_get_object_checked (domain, startklass, prop, &error);
+ if (!pr)
+ goto failure;
+ mono_ptr_array_append (tmp_array, pr);
g_hash_table_insert (properties, prop, prop);
}
g_hash_table_destroy (properties);
g_free (propname);
- res = mono_array_new_cached (domain, System_Reflection_PropertyInfo, mono_ptr_array_size (tmp_array));
+ res = mono_array_new_cached (domain, mono_class_get_property_info_class (), mono_ptr_array_size (tmp_array), &error);
+ if (!is_ok (&error))
+ goto failure;
for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
return res;
+
+
loader_error:
+ if (mono_class_has_failure (klass)) {
+ mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
+ }
+
+failure:
if (properties)
g_hash_table_destroy (properties);
if (name)
g_free (propname);
mono_ptr_array_destroy (tmp_array);
- if (klass->exception_type != MONO_EXCEPTION_NONE) {
- ex = mono_class_get_exception_for_failure (klass);
- } else {
- ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
- mono_loader_clear_error ();
- }
- mono_set_pending_exception (ex);
+ mono_error_set_pending_exception (&error);
+
return NULL;
}
}
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)
{
- MonoException *ex;
+ MonoError error;
MonoDomain *domain;
- static MonoClass *System_Reflection_EventInfo;
MonoClass *startklass, *klass;
MonoArray *res;
MonoMethod *method;
GHashTable *events = NULL;
MonoPtrArray tmp_array;
- mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection events list");
+ mono_error_init (&error);
+
+ domain = mono_object_domain (type);
+ if (type->type->byref) {
+ res = mono_array_new_cached (domain, mono_class_get_event_info_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
+ }
- if (!System_Reflection_EventInfo)
- System_Reflection_EventInfo = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection", "EventInfo");
+ mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection events list");
- domain = mono_object_domain (type);
- if (type->type->byref)
- return mono_array_new_cached (domain, System_Reflection_EventInfo, 0);
klass = startklass = mono_class_from_mono_type (type->type);
events = g_hash_table_new (event_hash, (GEqualFunc)event_equal);
handle_parent:
mono_class_setup_methods (klass);
mono_class_setup_vtable (klass);
- if (klass->exception_type != MONO_EXCEPTION_NONE || mono_loader_get_last_error ())
+ if (mono_class_has_failure (klass))
goto loader_error;
iter = NULL;
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;
}
if (g_hash_table_lookup (events, event))
continue;
- mono_ptr_array_append (tmp_array, mono_event_get_object (domain, startklass, event));
+ MonoReflectionEvent *ev_obj;
+ ev_obj = mono_event_get_object_checked (domain, startklass, event, &error);
+ if (!ev_obj)
+ goto failure;
+ mono_ptr_array_append (tmp_array, ev_obj);
g_hash_table_insert (events, event, event);
}
g_hash_table_destroy (events);
- res = mono_array_new_cached (domain, System_Reflection_EventInfo, mono_ptr_array_size (tmp_array));
+ res = mono_array_new_cached (domain, mono_class_get_event_info_class (), mono_ptr_array_size (tmp_array), &error);
+ if (!is_ok (&error))
+ goto failure;
for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
return res;
loader_error:
- mono_ptr_array_destroy (tmp_array);
- if (klass->exception_type != MONO_EXCEPTION_NONE) {
- ex = mono_class_get_exception_for_failure (klass);
- } else {
- ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
- mono_loader_clear_error ();
+ if (mono_class_has_failure (klass)) {
+ mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
}
- mono_set_pending_exception (ex);
+
+failure:
+
+ if (events != NULL)
+ g_hash_table_destroy (events);
+ if (utf8_name != NULL)
+ g_free (utf8_name);
+
+ mono_ptr_array_destroy (tmp_array);
+
+ mono_error_set_pending_exception (&error);
return NULL;
}
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;
MonoDomain *domain;
MonoClass *klass;
- MonoArray *res;
+ MonoArray *res = NULL;
int i, match;
MonoClass *nested;
gpointer iter;
char *str = NULL;
MonoPtrArray tmp_array;
+ mono_error_init (&error);
+
domain = ((MonoObject *)type)->vtable->domain;
- if (type->type->byref)
- return mono_array_new (domain, mono_defaults.monotype_class, 0);
+ if (type->type->byref) {
+ MonoArray *result = mono_array_new_cached (domain, mono_defaults.runtimetype_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
klass = mono_class_from_mono_type (type->type);
/*
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);
}
}
rt = mono_type_get_object_checked (domain, &nested->byval_arg, &error);
- mono_error_raise_exception (&error);
+ if (!is_ok (&error))
+ goto leave;
mono_ptr_array_append (tmp_array, (MonoObject*) rt);
}
- res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array));
+ res = mono_array_new_cached (domain, mono_defaults.runtimetype_class, mono_ptr_array_size (tmp_array), &error);
+ if (!is_ok (&error))
+ goto leave;
for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
+leave:
mono_ptr_array_destroy (tmp_array);
- if (!str)
- g_free (str);
+ g_free (str);
+ mono_error_set_pending_exception (&error);
return res;
}
/* 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);
}
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, 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, &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, 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, 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) {
if (throwOnError)
e = mono_get_exception_type_load (name, NULL);
- if (mono_loader_get_last_error () && mono_defaults.generic_ilist_class)
- e = mono_loader_error_prepare_exception (mono_loader_get_last_error ());
-
- mono_loader_clear_error ();
-
if (e != NULL)
mono_set_pending_exception (e);
return NULL;
- } else if (mono_loader_get_last_error ()) {
- if (throwOnError) {
- mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
- return NULL;
- }
- mono_loader_clear_error ();
}
if (type->type == MONO_TYPE_CLASS) {
MonoClass *klass = mono_type_get_class (type);
/* need to report exceptions ? */
- if (throwOnError && klass->exception_type) {
+ if (throwOnError && mono_class_has_failure (klass)) {
/* report SecurityException (or others) that occured when loading the assembly */
MonoException *exc = mono_class_get_exception_for_failure (klass);
- mono_loader_clear_error ();
mono_set_pending_exception (exc);
return NULL;
}
/* 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;
}
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);
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
{
+ MonoError error;
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
- MonoArray *result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows);
+ MonoArray *result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, table->rows, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
int i;
const char *val;
}
static MonoObject*
-create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
+create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision, MonoError *error)
{
- static MonoClass *System_Version = NULL;
static MonoMethod *create_version = NULL;
- MonoError error;
MonoObject *result;
gpointer args [4];
+
+ mono_error_init (error);
- if (!System_Version) {
- System_Version = mono_class_from_name (mono_defaults.corlib, "System", "Version");
- g_assert (System_Version);
- }
if (!create_version) {
MonoMethodDesc *desc = mono_method_desc_new (":.ctor(int,int,int,int)", FALSE);
- create_version = mono_method_desc_search_in_class (desc, System_Version);
+ create_version = mono_method_desc_search_in_class (desc, mono_class_get_system_version_class ());
g_assert (create_version);
mono_method_desc_free (desc);
}
args [1] = &minor;
args [2] = &build;
args [3] = &revision;
- result = mono_object_new_checked (domain, System_Version, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ result = mono_object_new_checked (domain, mono_class_get_system_version_class (), error);
+ return_val_if_nok (error, NULL);
- mono_runtime_invoke_checked (create_version, result, args, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ mono_runtime_invoke_checked (create_version, result, args, error);
+ return_val_if_nok (error, NULL);
return result;
}
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
{
- static MonoClass *System_Reflection_AssemblyName;
MonoError error;
MonoArray *result;
MonoDomain *domain = mono_object_domain (assembly);
MonoTableInfo *t;
MonoObject *o;
- if (!System_Reflection_AssemblyName)
- System_Reflection_AssemblyName = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection", "AssemblyName");
-
t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF];
count = t->rows;
- result = mono_array_new (domain, System_Reflection_AssemblyName, count);
+ result = mono_array_new_checked (domain, mono_class_get_assembly_name_class (), count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
if (count > 0 && !create_culture) {
MonoMethodDesc *desc = mono_method_desc_new (
}
for (i = 0; i < count; i++) {
+ MonoObject *version;
MonoReflectionAssemblyName *aname;
guint32 cols [MONO_ASSEMBLYREF_SIZE];
mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
aname = (MonoReflectionAssemblyName *) mono_object_new_checked (
- domain, System_Reflection_AssemblyName, &error);
- mono_error_raise_exception (&error);
+ domain, mono_class_get_assembly_name_class (), &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
aname->versioncompat = 1; /* SameMachine (default) */
aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
- MONO_OBJECT_SETREF (aname, version, create_version (domain, aname->major, aname->minor, aname->build, aname->revision));
+
+ version = create_version (domain, aname->major, aname->minor, aname->build, aname->revision, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, version, version);
if (create_culture) {
gpointer args [2];
args [1] = &assembly_ref;
o = mono_runtime_invoke_checked (create_culture, NULL, args, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
MONO_OBJECT_SETREF (aname, cultureInfo, o);
}
if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) {
/* public key token isn't copied - the class library will
automatically generate it from the public key if required */
- MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
- memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
+ MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, publicKey, pkey);
+ memcpy (mono_array_addr (pkey, guint8, 0), pkey_ptr, pkey_len);
} else {
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
- memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len);
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
+ memcpy (mono_array_addr (keyToken, guint8, 0), pkey_ptr, pkey_len);
}
} else {
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
}
/* note: this function doesn't return the codebase on purpose (i.e. it can
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]);
MonoReflectionModule *rm = mono_module_get_object_checked (mono_domain_get (), module, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) rm);
return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
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]);
ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
{
+ MonoError error;
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
MonoArray *result = NULL;
int i, count;
/* 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) {
count ++;
}
- result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, count);
+ result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
count = 0;
for (i = 0; i < table->rows; ++i) {
if (modules [i])
real_module_count ++;
- klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
- res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
+ klass = mono_class_get_module_class ();
+ res = mono_array_new_checked (domain, klass, 1 + real_module_count + file_count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
MonoReflectionModule *image_obj = mono_module_get_object_checked (domain, image, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
mono_array_setref (res, 0, image_obj);
j = 1;
for (i = 0; i < module_count; ++i)
if (modules [i]) {
MonoReflectionModule *rm = mono_module_get_object_checked (domain, modules[i], &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, j, rm);
++j;
}
mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE);
if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA) {
MonoReflectionModule *rm = mono_module_file_get_object_checked (domain, image, i, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, j, rm);
}
else {
return NULL;
}
MonoReflectionModule *rm = mono_module_get_object_checked (domain, m, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_setref (res, j, rm);
}
}
m = ((MonoMethodInflated*)m)->declaring;
res = mono_method_get_object_checked (mono_domain_get (), m, NULL, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return res;
}
}
mono_class_setup_methods (method->klass);
- if (method->klass->exception_type)
+ if (mono_class_has_failure (method->klass))
return NULL;
for (i = 0; i < method->klass->method.count; ++i) {
if (method->klass->methods [i] == method) {
}
}
mono_class_setup_methods (klass);
- if (klass->exception_type)
+ if (mono_class_has_failure (klass))
return NULL;
g_assert (offset >= 0 && offset < klass->method.count);
return klass->methods [offset];
} else
klass = method->klass;
res = mono_method_get_object_checked (mono_domain_get (), method, klass, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return res;
}
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)
+vell_icall_RuntimeType_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_set_pending_exception (&error);
return mono_security_core_clr_class_level (klass);
}
}
static void
-fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
+fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token, MonoError *error)
{
static MonoMethod *create_culture = NULL;
- MonoError error;
MonoObject *obj;
gpointer args [2];
guint32 pkey_len;
gchar *codebase;
MonoBoolean assembly_ref = 0;
+ mono_error_init (error);
+
MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
aname->major = name->major;
aname->minor = name->minor;
aname->versioncompat = 1; /* SameMachine (default) */
aname->processor_architecture = name->arch;
- if (by_default_version)
- MONO_OBJECT_SETREF (aname, version, create_version (domain, name->major, name->minor, name->build, name->revision));
+ if (by_default_version) {
+ MonoObject *version;
+
+ version = create_version (domain, name->major, name->minor, name->build, name->revision, error);
+ return_if_nok (error);
+
+ MONO_OBJECT_SETREF (aname, version, version);
+ }
codebase = NULL;
if (absolute != NULL && *absolute != '\0') {
args [0] = mono_string_new (domain, name->culture);
args [1] = &assembly_ref;
- obj = mono_runtime_invoke_checked (create_culture, NULL, args, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ obj = mono_runtime_invoke_checked (create_culture, NULL, args, error);
+ return_if_nok (error);
MONO_OBJECT_SETREF (aname, cultureInfo, obj);
}
pkey_ptr = (char*)name->public_key;
pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
- MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
+ MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, error);
+ return_if_nok (error);
+ MONO_OBJECT_SETREF (aname, publicKey, pkey);
memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
} else if (default_publickey) {
- MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, 0));
+ MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error);
+ return_if_nok (error);
+ MONO_OBJECT_SETREF (aname, publicKey, pkey);
aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
}
int i, j;
char *p;
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8));
- p = mono_array_addr (aname->keyToken, char, 0);
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 8, error);
+ return_if_nok (error);
+
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
+ p = mono_array_addr (keyToken, char, 0);
for (i = 0, j = 0; i < 8; i++) {
*p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4;
p++;
}
} else if (default_token) {
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error);
+ return_if_nok (error);
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
}
}
ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
{
+ MonoError error;
gchar *absolute;
MonoAssembly *mass = assembly->assembly;
if (g_path_is_absolute (mass->image->name)) {
- fill_reflection_assembly_name (mono_object_domain (assembly),
- aname, &mass->aname, mass->image->name, TRUE,
- TRUE, TRUE);
+ fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, mass->image->name, TRUE, TRUE, TRUE, &error);
+ mono_error_set_pending_exception (&error);
return;
}
absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
- fill_reflection_assembly_name (mono_object_domain (assembly),
- aname, &mass->aname, absolute, TRUE, TRUE,
- TRUE);
+ fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, absolute, TRUE, TRUE, TRUE, &error);
+ mono_error_set_pending_exception (&error);
g_free (absolute);
}
ICALL_EXPORT void
ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
{
+ MonoError error;
char *filename;
MonoImageOpenStatus status = MONO_IMAGE_OK;
gboolean res;
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);
return;
}
- fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename,
- TRUE, FALSE, TRUE);
+ fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, TRUE, FALSE, TRUE, &error);
+ mono_error_set_pending_exception (&error);
- g_free (filename);
mono_image_close (image);
+ g_free (filename);
}
ICALL_EXPORT MonoBoolean
}
static MonoArray*
-mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly)
+mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly, MonoError *error)
{
- MonoError error;
MonoReflectionType *rt;
MonoArray *res;
MonoClass *klass;
MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
int i, count;
+ mono_error_init (error);
+
/* we start the count from 1 because we skip the special type <Module> */
if (exportedOnly) {
count = 0;
} else {
count = tdef->rows - 1;
}
- res = mono_array_new (domain, mono_defaults.monotype_class, count);
- *exceptions = mono_array_new (domain, mono_defaults.exception_class, count);
+ 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);
count = 0;
for (i = 1; i < tdef->rows; ++i) {
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 */
- g_assert (mono_error_ok (&error));
+ klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, error);
if (klass) {
- rt = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ rt = mono_type_get_object_checked (domain, &klass->byval_arg, error);
+ return_val_if_nok (error, NULL);
mono_array_setref (res, count, rt);
} else {
- MonoException *ex = mono_error_convert_to_exception (&error);
+ MonoException *ex = mono_error_convert_to_exception (error);
mono_array_setref (*exceptions, count, ex);
}
count++;
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
{
+ MonoError error;
MonoArray *res = NULL;
MonoArray *exceptions = NULL;
MonoImage *image = NULL;
g_assert (!assembly_is_dynamic (assembly->assembly));
image = assembly->assembly->image;
table = &image->tables [MONO_TABLE_FILE];
- res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
+ res = mono_module_get_types (domain, image, &exceptions, exportedOnly, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
/* Append data from all modules in the assembly */
for (i = 0; i < table->rows; ++i) {
MonoImage *loaded_image = mono_assembly_load_module (image->assembly, i + 1);
if (loaded_image) {
MonoArray *ex2;
- MonoArray *res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
+ MonoArray *res2;
+
+ res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+
/* Append the new types to the end of the array */
if (mono_array_length (res2) > 0) {
guint32 len1, len2;
len1 = mono_array_length (res);
len2 = mono_array_length (res2);
- res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
+ 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 (domain, mono_defaults.monotype_class, len1 + len2);
+ 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);
mono_array_memcpy_refs (ex3, len1, ex2, 0, len2);
exceptions = ex3;
if (t) {
klass = mono_type_get_class (t->type);
- if ((klass != NULL) && klass->exception_type) {
+ if ((klass != NULL) && mono_class_has_failure (klass)) {
/* keep the class in the list */
list = g_list_append (list, klass);
/* and replace Type with NULL */
MonoArray *exl = NULL;
int j, length = g_list_length (list) + ex_count;
- mono_loader_clear_error ();
-
- exl = mono_array_new (domain, mono_defaults.exception_class, length);
+ exl = mono_array_new_checked (domain, mono_defaults.exception_class, length, &error);
+ if (mono_error_set_pending_exception (&error)) {
+ g_list_free (list);
+ return NULL;
+ }
/* Types for which mono_class_get_checked () succeeded */
for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
MonoException *exc = mono_class_get_exception_for_failure ((MonoClass *)tmp->data);
g_list_free (list);
list = NULL;
- exc = mono_get_exception_reflection_type_load (res, exl);
- mono_loader_clear_error ();
+ exc = mono_get_exception_reflection_type_load_checked (res, exl, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
mono_set_pending_exception (exc);
return NULL;
}
ICALL_EXPORT gboolean
ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
{
+ MonoError error;
MonoAssemblyName aname;
MonoDomain *domain = mono_object_domain (name);
char *val;
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);
return FALSE;
}
- fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined,
- FALSE, is_token_defined);
+ fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined, FALSE, is_token_defined, &error);
+ mono_error_set_pending_exception (&error);
mono_assembly_name_free (&aname);
g_free ((guint8*) aname.public_key);
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
+ MonoError error;
MonoArray *exceptions;
int i;
- if (!module->image)
- return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0);
- else {
- MonoArray *res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE);
+ if (!module->image) {
+ 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 {
+ MonoArray *res;
+
+ res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
for (i = 0; i < mono_array_length (exceptions); ++i) {
MonoException *ex = mono_array_get (exceptions, MonoException *, i);
if (ex) {
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;
}
/* 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*
}
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)) {
MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
if (t) {
ret = (MonoObject*) mono_type_get_object_checked (mono_domain_get (), t, &merror);
- mono_error_raise_exception (&merror);
+ mono_error_set_pending_exception (&merror);
return ret;
}
MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
if (m) {
ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
- mono_error_raise_exception (&merror);
+ mono_error_set_pending_exception (&merror);
return ret;
} else
MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
if (f) {
ret =(MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
- mono_error_raise_exception (&merror);
+ mono_error_set_pending_exception (&merror);
return ret;
}
else
MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
if (m) {
ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
- mono_error_raise_exception (&merror);
+ mono_error_set_pending_exception (&merror);
return ret;
} else
MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
if (f) {
ret = (MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
- mono_error_raise_exception (&merror);
+ mono_error_set_pending_exception (&merror);
return ret;
}
else
}
ICALL_EXPORT MonoArray*
-ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error)
{
+ MonoError error;
int table = mono_metadata_token_table (token);
int idx = mono_metadata_token_index (token);
MonoTableInfo *tables = image->tables;
const char *ptr;
MonoArray *res;
- *error = ResolveTokenError_OutOfRange;
+ *resolve_error = ResolveTokenError_OutOfRange;
/* FIXME: Support other tables ? */
if (table != MONO_TABLE_STANDALONESIG)
ptr = mono_metadata_blob_heap (image, sig);
len = mono_metadata_decode_blob_size (ptr, &ptr);
- res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, len);
+ res = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
memcpy (mono_array_addr (res, guint8, 0), ptr, len);
return res;
}
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;
g_free (str);
ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->this_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
case '*':
g_free (str);
ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
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 *
-ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
+ves_icall_RuntimeType_make_array_type (MonoReflectionType *type, int rank)
{
MonoError error;
MonoReflectionType *ret;
MonoClass *klass, *aklass;
klass = mono_class_from_mono_type (type->type);
- check_for_invalid_type (klass);
+ check_for_invalid_type (klass, &error);
+ mono_error_set_pending_exception (&error);
if (rank == 0) //single dimentional array
aklass = mono_array_class_get (klass, 1);
aklass = mono_bounded_array_class_get (klass, rank, TRUE);
ret = mono_type_get_object_checked (mono_object_domain (type), &aklass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT MonoReflectionType *
-ves_icall_Type_make_byref_type (MonoReflectionType *type)
+ves_icall_RuntimeType_make_byref_type (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ check_for_invalid_type (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
ret = mono_type_get_object_checked (mono_object_domain (type), &klass->this_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT MonoReflectionType *
-ves_icall_Type_MakePointerType (MonoReflectionType *type)
+ves_icall_RuntimeType_MakePointerType (MonoReflectionType *type)
{
MonoError error;
MonoReflectionType *ret;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ check_for_invalid_type (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
pklass = mono_ptr_class_get (type->type);
ret = mono_type_get_object_checked (mono_object_domain (type), &pklass->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
gpointer func;
MonoMethod *method = info->method;
- mono_class_init_or_throw (delegate_class);
+ mono_class_init_checked (delegate_class, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
- 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);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
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 (),
- mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE));
+ gpointer trampoline = mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ 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;
}
g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class));
ret = (MonoMulticastDelegate*) mono_object_new_checked (mono_object_domain (delegate), mono_object_class (delegate), &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
ret->delegate.invoke_impl = mono_runtime_create_delegate_trampoline (mono_object_class (delegate));
return ret;
MonoReflectionMethod *ret = NULL;
MonoError error;
ret = mono_method_get_object_checked (mono_domain_get (), mono_object_get_virtual_method (delegate->target, delegate->method), mono_object_class (delegate->target), &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
MonoClass *klass;
res = mono_object_new_checked (domain, mono_defaults.transparent_proxy_class, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
tp = (MonoTransparentProxy*) res;
MONO_OBJECT_SETREF (tp, rp, rp);
// mono_remote_class_vtable cannot handle errors well, so force any loading error to occur early
mono_class_setup_vtable (klass);
- if (klass->exception_type) {
+ if (mono_class_has_failure (klass)) {
mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
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 (mono_error_set_pending_exception (&error))
+ return NULL;
+ tp->remote_class = mono_remote_class (domain, class_name, klass, &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;
}
{
MonoError error;
MonoReflectionType *ret = mono_type_get_object_checked (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
if (GetComputerName (buf, (PDWORD) &len)) {
MonoError error;
result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
}
g_free (buf);
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
#endif
+ICALL_EXPORT MonoArray *
+ves_icall_System_Environment_GetCoomandLineArgs (void)
+{
+ MonoError error;
+ MonoArray *result = mono_runtime_get_main_args_checked (&error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
{
#ifdef HOST_WIN32
+ MonoError error;
MonoArray *names;
MonoDomain *domain;
MonoString *str;
}
domain = mono_domain_get ();
- names = mono_array_new (domain, mono_defaults.string_class, n);
+ names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
if (env_strings) {
n = 0;
g_assert(equal_str);
MonoError error;
str = mono_string_new_utf16_checked (domain, env_string, equal_str-env_string, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
mono_array_setref (names, n, str);
n++;
}
return names;
#else
+ MonoError error;
MonoArray *names;
MonoDomain *domain;
MonoString *str;
++ n;
domain = mono_domain_get ();
- names = mono_array_new (domain, mono_defaults.string_class, n);
+ names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
n = 0;
for (e = environ; *e != 0; ++ e) {
#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);
++ len;
MonoError error;
MonoString *res = mono_string_new_utf16_checked (mono_domain_get (), path, len, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return res;
}
#else
} while (*dname);
dname = ptr;
- result = mono_array_new (domain, mono_defaults.string_class, ndrives);
+ result = mono_array_new_checked (domain, mono_defaults.string_class, ndrives, &error);
+ if (mono_error_set_pending_exception (&error))
+ goto leave;
+
ndrives = 0;
do {
len = 0;
u16 = dname;
while (*u16) { u16++; len ++; }
drivestr = mono_string_new_utf16_checked (domain, dname, len, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ goto leave;
+
mono_array_setref (result, ndrives++, drivestr);
while (*dname++);
} while (*dname);
+leave:
if (ptr != buf)
g_free (ptr);
ICALL_EXPORT MonoString *
ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path)
{
+ MonoError error;
gunichar2 volume_name [MAX_PATH + 1];
if (GetVolumeInformation (mono_string_chars (path), NULL, 0, NULL, NULL, NULL, volume_name, MAX_PATH + 1) == FALSE)
return NULL;
- return mono_string_from_utf16 (volume_name);
+ MonoString *result = mono_string_from_utf16_checked (volume_name, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
ICALL_EXPORT MonoString *
#endif
}
+ICALL_EXPORT
+gint32
+ves_icall_System_Environment_get_TickCount (void)
+{
+ /* this will overflow after ~24 days */
+ return (gint32) (mono_msec_boottime () & 0xffffffff);
+}
+
ICALL_EXPORT gint32
ves_icall_System_Runtime_Versioning_VersioningHelper_GetRuntimeId (void)
{
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
method = rmethod->method;
klass = mono_class_from_mono_type (rtype->type);
- mono_class_init_or_throw (klass);
+ mono_class_init_checked (klass, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
if (MONO_CLASS_IS_INTERFACE (klass))
return NULL;
return NULL;
ret = mono_method_get_object_checked (mono_domain_get (), res, NULL, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
ICALL_EXPORT void
ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
{
+ MonoError error;
MonoClass *klass;
MonoVTable* vtable;
klass = mono_class_from_mono_type (type->type);
- vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE);
+ vtable = mono_class_vtable_full (mono_domain_get (), klass, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return;
+ }
mono_vtable_set_is_remote (vtable, enable);
}
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
if (MONO_CLASS_IS_INTERFACE (klass) || (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) {
mono_set_pending_exception (mono_get_exception_argument ("type", "Type cannot be instantiated"));
if (klass->rank >= 1) {
g_assert (klass->rank == 1);
- return (MonoObject *) mono_array_new (domain, klass->element_class, 0);
+ ret = (MonoObject *) mono_array_new_checked (domain, klass->element_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return ret;
} else {
+ MonoVTable *vtable = mono_class_vtable_full (domain, klass, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
/* Bypass remoting object creation check */
- ret = mono_object_new_alloc_specific_checked (mono_class_vtable_full (domain, klass, TRUE), &error);
+ ret = mono_object_new_alloc_specific_checked (vtable, &error);
mono_error_set_pending_exception (&error);
return ret;
#endif
ICALL_EXPORT gpointer
-ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
+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 *
return mcpath;
}
+/* this is an icall */
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
config_file_path = mono_portability_find_file (config_file_name, TRUE);
if (!config_file_path)
config_file_path = config_file_name;
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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
if (mono_class_is_nullable (klass))
/* No arguments -> null */
return NULL;
result = mono_object_new_checked (domain, klass, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return result;
}
*/
MonoGenericContext *parent_inst = NULL;
if (mono_class_is_open_constructed_type (mono_class_get_type (parent))) {
- MonoError error;
parent = mono_class_inflate_generic_class_checked (parent, generic_inst, &error);
if (!mono_error_ok (&error)) {
mono_error_set_pending_exception (&error);
return m;
ret = mono_method_get_object_checked (mono_domain_get (), result, NULL, &error);
- mono_error_raise_exception (&error);
+ mono_error_set_pending_exception (&error);
return ret;
}
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_set_pending_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);
+ if (mono_error_set_pending_exception (&error))
+ return;
- while ((m = mono_class_get_methods (klass, &iter)))
- prelink_method (m);
+ while ((m = mono_class_get_methods (klass, &iter))) {
+ prelink_method (m, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ }
}
/* 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++;
}
if (!count)
return NULL;
- res = mono_array_new (mono_domain_get (), mono_defaults.systemtype_class, count);
+ res = mono_array_new_checked (mono_domain_get (), mono_defaults.systemtype_class, count, error);
+ return_val_if_nok (error, NULL);
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_set_pending_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_set_pending_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);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
- 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);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ }
res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
if (!mono_error_ok (&error)) {
return NULL;
}
- if (mono_loader_get_last_error ()) {
- mono_set_pending_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
- return NULL;
- } else {
- return res;
- }
+ return res;
+}
+
+ICALL_EXPORT MonoArray*
+ves_icall_MonoCustomAttrs_GetCustomAttributesDataInternal (MonoObject *obj)
+{
+ MonoError error;
+ MonoArray *result;
+ result = mono_reflection_get_custom_attrs_data_checked (obj, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
+
ICALL_EXPORT MonoString*
ves_icall_Mono_Runtime_GetDisplayName (void)
{
message = mono_string_new (mono_domain_get (), "Error looking up error string");
} else {
message = mono_string_new_utf16_checked (mono_domain_get (), buf, ret, &error);
- mono_error_raise_exception (&error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
}
return message;
}
-ICALL_EXPORT int
-ves_icall_System_StackFrame_GetILOffsetFromFile (MonoString *path, guint32 method_token, guint32 method_index, int native_offset)
+ICALL_EXPORT gpointer
+ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
+{
+ return GetCurrentProcess ();
+}
+
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_GetExitCodeProcess (gpointer handle, gint32 *exitcode)
+{
+ return GetExitCodeProcess (handle, (guint32*) exitcode);
+}
+
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_CloseProcess (gpointer handle)
+{
+#if defined(TARGET_WIN32) || defined(HOST_WIN32)
+ return CloseHandle (handle);
+#else
+ return CloseProcess (handle);
+#endif
+}
+
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint32 exitcode)
+{
+ return TerminateProcess (handle, exitcode);
+}
+
+ICALL_EXPORT gint32
+ves_icall_Microsoft_Win32_NativeMethods_WaitForInputIdle (gpointer handle, gint32 milliseconds)
{
- guint32 il_offset;
- char *path_str = mono_string_to_utf8 (path);
+ return WaitForInputIdle (handle, milliseconds);
+}
+
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max)
+{
+ return GetProcessWorkingSetSize (handle, min, max);
+}
+
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max)
+{
+ return SetProcessWorkingSetSize (handle, min, max);
+}
+
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_GetProcessTimes (gpointer handle, gint64 *creationtime, gint64 *exittime, gint64 *kerneltime, gint64 *usertime)
+{
+ return GetProcessTimes (handle, (LPFILETIME) creationtime, (LPFILETIME) exittime, (LPFILETIME) kerneltime, (LPFILETIME) usertime);
+}
- if (!mono_seq_point_data_get_il_offset (path_str, method_token, method_index, native_offset, &il_offset))
- il_offset = -1;
+ICALL_EXPORT gint32
+ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcessId (void)
+{
+ return mono_process_current_pid ();
+}
- g_free (path_str);
+ICALL_EXPORT gint32
+ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle)
+{
+ return GetPriorityClass (handle);
+}
- return il_offset;
+ICALL_EXPORT MonoBoolean
+ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass)
+{
+ return SetPriorityClass (handle, priorityClass);
}
#ifndef DISABLE_ICALL_TABLES
mono_os_mutex_destroy (&icall_mutex);
}
+/**
+ * mono_add_internal_call:
+ * @name: method specification to surface to the managed world
+ * @method: pointer to a C method to invoke when the method is called
+ *
+ * This method surfaces the C function pointed by @method as a method
+ * that has been surfaced in managed code with the method specified in
+ * @name as an internal call.
+ *
+ * Internal calls are surfaced to all app domains loaded and they are
+ * accessibly by a type with the specified name.
+ *
+ * You must provide a fully qualified type name, that is namespaces
+ * and type name, followed by a colon and the method name, with an
+ * optional signature to bind.
+ *
+ * For example, the following are all valid declarations:
+ *
+ * "MyApp.Services.ScriptService:Accelerate"
+ * "MyApp.Services.ScriptService:Slowdown(int,bool)"
+ *
+ * You use method parameters in cases where there might be more than
+ * one surface method to managed code. That way you can register different
+ * internal calls for different method overloads.
+ *
+ * The internal calls are invoked with no marshalling. This means that .NET
+ * types like System.String are exposed as `MonoString *` parameters. This is
+ * different than the way that strings are surfaced in P/Invoke.
+ *
+ * For more information on how the parameters are marshalled, see the
+ * <a href="http://www.mono-project.com/docs/advanced/embedding/">Mono Embedding</a>
+ * page.
+ *
+ * See the <a href="mono-api-methods.html#method-desc">Method Description</a>
+ * reference for more information on the format of method descriptions.
+ */
void
mono_add_internal_call (const char *name, gconstpointer method)
{