#include <stdarg.h>
#include <string.h>
#include <ctype.h>
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
#if defined (PLATFORM_WIN32)
#include <stdlib.h>
#endif
static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
+static MonoArray*
+type_array_from_modifiers (MonoImage *image, MonoType *type, int optional);
static inline MonoBoolean
is_generic_parameter (MonoType *type)
memcpy (value, ea, esize);
}
+static void
+ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
+{
+ MonoClass *ac;
+ MonoArray *ao;
+ gint32 esize;
+ gpointer *ea;
+
+ MONO_ARCH_SAVE_REGS;
+
+ ao = (MonoArray *)this;
+ ac = (MonoClass *)ao->obj.vtable->klass;
+
+ esize = mono_array_element_size (ac);
+ ea = (gpointer*)((char*)ao->vector + (pos * esize));
+
+ memcpy (ea, value, esize);
+}
+
static void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
{
mono_runtime_class_init (mono_class_vtable (mono_domain_get (), klass));
}
+static void
+ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage *image)
+{
+ MONO_ARCH_SAVE_REGS;
+
+ mono_image_check_for_module_cctor (image);
+ if (image->has_module_cctor) {
+ MonoClass *module_klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | 1);
+ mono_runtime_class_init (mono_class_vtable (mono_domain_get (), module_klass));
+ }
+}
+
static MonoObject *
ves_icall_System_Object_MemberwiseClone (MonoObject *this)
{
/* mono_reflection_parse_type() mangles the string */
if (!mono_reflection_parse_type (temp_str, &info)) {
- g_list_free (info.modifiers);
- g_list_free (info.nested);
+ mono_reflection_free_type_info (&info);
g_free (temp_str);
return NULL;
}
if (!info.assembly.name && !type) /* try mscorlib */
type = mono_reflection_get_type (NULL, &info, ignoreCase, &type_resolve);
- g_list_free (info.modifiers);
- g_list_free (info.nested);
+ mono_reflection_free_type_info (&info);
g_free (temp_str);
if (!type)
int i;
if (klass->generic_container ||
- (klass->generic_class && klass->generic_class->inst->is_open))
+ (klass->generic_class && klass->generic_class->context.class_inst->is_open))
return NULL;
info = mono_marshal_load_type_info (klass);
return NULL;
}
+static MonoReflectionField*
+ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoClass *klass)
+{
+ g_assert (handle);
+
+ if (!klass)
+ klass = handle->parent;
+
+ /* FIXME: check that handle is a field of klass or of a parent: return null
+ * and throw the exception in managed code.
+ */
+ return mono_field_get_object (mono_domain_get (), klass, handle);
+}
+
static MonoReflectionField*
ves_icall_System_Reflection_FieldInfo_internal_from_handle (MonoClassField *handle)
{
return mono_field_get_object (mono_domain_get (), handle->parent, handle);
}
+static MonoArray*
+ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
+{
+ MonoType *type = field->field->type;
+
+ return type_array_from_modifiers (field->field->parent->image, type, optional);
+}
+
static void
ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
{
MonoMethodSignature* sig;
MONO_ARCH_SAVE_REGS;
- if (method->is_inflated)
- method = mono_get_inflated_method (method);
-
sig = mono_method_signature (method);
+ if (!sig) {
+ g_assert (mono_loader_get_last_error ());
+ mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
+ }
info->parent = mono_type_get_object (domain, &method->klass->byval_arg);
info->ret = mono_type_get_object (domain, sig->ret);
{
MonoDomain *domain = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
- if (method->is_inflated)
- method = mono_get_inflated_method (method);
-
return mono_param_get_objects (domain, method);
}
MonoMarshalSpec **mspecs;
int i;
- MONO_ARCH_SAVE_REGS;
-
- if (method->is_inflated)
- method = mono_get_inflated_method (method);
-
mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
mono_method_get_marshal_info (method, mspecs);
break;
case MONO_TYPE_GENERICINST: {
MonoGenericClass *gclass = cf->type->data.generic_class;
- g_assert (!gclass->inst->is_open);
+ g_assert (!gclass->context.class_inst->is_open);
if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) {
MonoClass *nklass = mono_class_from_mono_type (cf->type);
- guint8 *buf;
+ MonoObject *nullable;
/*
* Convert the boxed vtype into a Nullable structure.
* This is complicated by the fact that Nullables have
* a variable structure.
*/
- /* Allocate using alloca so it gets GC tracking */
- buf = alloca (nklass->instance_size);
+ nullable = mono_object_new (mono_domain_get (), nklass);
- mono_nullable_init (buf, value, nklass);
+ mono_nullable_init (mono_object_unbox (nullable), value, nklass);
- v = (gchar*)buf;
+ v = mono_object_unbox (nullable);
}
else
if (gclass->container_class->valuetype && (v != NULL))
static MonoReflectionType*
ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod *rmethod)
{
- MonoMethod *method = mono_get_inflated_method (rmethod->method.method);
+ MonoMethod *method = rmethod->method.method;
return mono_type_get_object (mono_object_domain (rmethod), &method->klass->byval_arg);
}
MONO_ARCH_SAVE_REGS;
- /* open generic-instance classes can share their interface_id */
- if (class->generic_class && class->generic_class->inst->is_open) {
+ if (class->generic_class && class->generic_class->context.class_inst->is_open) {
context = mono_class_get_context (class);
class = class->generic_class->container_class;
}
for (i = 0; i < ifaces->len; ++i) {
MonoClass *ic = g_ptr_array_index (ifaces, i);
MonoType *ret = &ic->byval_arg;
- if (context && ic->generic_class && ic->generic_class->inst->is_open)
+ if (context && ic->generic_class && ic->generic_class->context.class_inst->is_open)
ret = mono_class_inflate_generic_type (ret, context);
mono_array_setref (intf, i, mono_type_get_object (domain, ret));
mono_class_setup_vtable (class);
/* type doesn't implement iface: the exception is thrown in managed code */
- if ((iclass->interface_id > class->max_interface_id) || !class->interface_offsets [iclass->interface_id])
+ if (! MONO_CLASS_IMPLEMENTS_INTERFACE (class, iclass->interface_id))
return;
len = mono_class_num_methods (iclass);
- ioffset = class->interface_offsets [iclass->interface_id];
+ ioffset = mono_class_interface_offset (class, iclass);
domain = mono_object_domain (type);
*targets = mono_array_new (domain, mono_defaults.method_info_class, len);
*methods = mono_array_new (domain, mono_defaults.method_info_class, len);
MONO_ARCH_SAVE_REGS;
- // GetElementType should only return a type for:
+ // GelElementType should only return a type for:
// Array Pointer PassedByRef
if (type->type->byref)
return mono_type_get_object (mono_object_domain (type), &class->byval_arg);
+ if (class->enumtype && class->enum_basetype) /* types that are modifierd typebuilkders may not have enum_basetype set */
+ return mono_type_get_object (mono_object_domain (type), class->enum_basetype);
else if (class->element_class && MONO_CLASS_IS_ARRAY (class))
return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
else if (class->element_class && type->type->type == MONO_TYPE_PTR)
mono_array_setref (res, i, mono_type_get_object (mono_object_domain (type), &pklass->byval_arg));
}
} else if (klass->generic_class) {
- MonoGenericInst *inst = klass->generic_class->inst;
+ MonoGenericInst *inst = klass->generic_class->context.class_inst;
res = mono_array_new (mono_object_domain (type), mono_defaults.monotype_class, inst->type_argc);
for (i = 0; i < inst->type_argc; ++i)
mono_array_setref (res, i, mono_type_get_object (mono_object_domain (type), inst->type_argv [i]));
static MonoReflectionMethod *
ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
{
- MonoGenericContext *context;
MonoMethodInflated *imethod;
MONO_ARCH_SAVE_REGS;
- if (!method->method->is_inflated) {
- if (mono_method_signature (method->method)->generic_param_count)
- return method;
+ if (method->method->generic_container)
+ return method;
+ if (!method->method->is_inflated)
return NULL;
- }
imethod = (MonoMethodInflated *) method->method;
- /* FIXME: should reflection_info be part of imethod? */
- context = mono_method_get_context (method->method);
- if (context->gmethod && context->gmethod->reflection_info)
- return context->gmethod->reflection_info;
+ if (imethod->reflection_info)
+ return imethod->reflection_info;
else
return mono_method_get_object (
mono_object_domain (method), imethod->declaring, NULL);
{
MONO_ARCH_SAVE_REGS;
- return !method->method->is_inflated &&
- (mono_method_signature (method->method)->generic_param_count != 0);
+ return method->method->generic_container != NULL;
}
static MonoArray*
domain = mono_object_domain (method);
if (method->method->is_inflated) {
- MonoGenericMethod *gmethod = mono_method_get_context (method->method)->gmethod;
+ MonoGenericInst *inst = mono_method_get_context (method->method)->method_inst;
- if (gmethod) {
- count = gmethod->inst->type_argc;
+ if (inst) {
+ count = inst->type_argc;
res = mono_array_new (domain, mono_defaults.monotype_class, count);
for (i = 0; i < count; i++)
- mono_array_setref (res, i, mono_type_get_object (domain, gmethod->inst->type_argv [i]));
+ mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
return res;
}
* is stupid), mono_runtime_invoke_*() calls the provided method, allowing
* greater flexibility.
*/
- MonoMethod *m = mono_get_inflated_method (method->method);
+ MonoMethod *m = method->method;
int pcount;
void *obj = this;
if (pcount != mono_method_signature (m)->param_count)
mono_raise_exception (mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException"));
- if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor"))
+ if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this)
mono_raise_exception (mono_exception_from_name_msg (mono_defaults.corlib, "System", "MethodAccessException", "Cannot invoke constructor of an abstract class."));
if (m->klass->image->assembly->ref_only)
compare_func = (bflags & BFLAGS_IgnoreCase) ? g_strcasecmp : strcmp;
handle_parent:
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
iter = NULL;
while ((field = mono_class_get_fields (klass, &iter))) {
match = 0;
+
+ if (field->type == NULL)
+ continue;
if (mono_field_is_deleted (field))
continue;
if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) {
len = 2;
res = mono_array_new (domain, mono_defaults.field_info_class, len);
handle_parent:
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
iter = NULL;
while ((field = mono_class_get_fields (klass, &iter))) {
match = 0;
mono_class_setup_vtable (klass);
- nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : klass->vtable_size;
+ if (is_generic_parameter (type->type))
+ nslots = klass->parent->vtable_size;
+ else
+ nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : klass->vtable_size;
if (nslots >= sizeof (method_slots_default) * 8) {
method_slots = g_new0 (guint32, nslots / 32 + 1);
} else {
res = mono_array_new (domain, mono_defaults.method_info_class, len);
handle_parent:
mono_class_setup_vtable (klass);
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
match = 0;
klass = startklass = mono_class_from_mono_type (type->type);
refklass = mono_class_from_mono_type (reftype->type);
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
if (!System_Reflection_ConstructorInfo)
System_Reflection_ConstructorInfo = mono_class_from_name (
mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
res = mono_array_new (domain, System_Reflection_PropertyInfo, len);
handle_parent:
mono_class_setup_vtable (klass);
+ if (klass->exception_type != MONO_EXCEPTION_NONE) {
+ if (method_slots != method_slots_default)
+ g_free (method_slots);
+ if (name != NULL)
+ g_free (propname);
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+ }
+
iter = NULL;
while ((prop = mono_class_get_properties (klass, &iter))) {
match = 0;
domain = mono_object_domain (type);
handle_parent:
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
iter = NULL;
while ((event = mono_class_get_events (klass, &iter))) {
if (strcmp (event->name, event_name))
len = 2;
res = mono_array_new (domain, System_Reflection_EventInfo, len);
handle_parent:
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
iter = NULL;
while ((event = mono_class_get_events (klass, &iter))) {
match = 0;
str = mono_string_to_utf8 (name);
handle_parent:
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
+
/*
* If a nested type is generic, return its generic type definition.
* Note that this means that the return value is essentially a
if (type->type->byref)
return mono_array_new (domain, mono_defaults.monotype_class, 0);
klass = mono_class_from_mono_type (type->type);
+ if (klass->exception_type != MONO_EXCEPTION_NONE)
+ mono_raise_exception (mono_class_get_exception_for_failure (klass));
/*
* If a nested type is generic, return its generic type definition.
/*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
if (!mono_reflection_parse_type (str, &info)) {
g_free (str);
- g_list_free (info.modifiers);
- g_list_free (info.nested);
+ mono_reflection_free_type_info (&info);
if (throwOnError) /* uhm: this is a parse error, though... */
mono_raise_exception (mono_get_exception_type_load (name, NULL));
/*g_print ("failed parse\n");*/
else
type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase, &type_resolve);
g_free (str);
- g_list_free (info.modifiers);
- g_list_free (info.nested);
+ mono_reflection_free_type_info (&info);
if (!type) {
MonoException *e = NULL;
return mono_method_get_object (mono_domain_get (), m, NULL);
}
+static MonoReflectionMethod*
+ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
+{
+ /* FIXME check that method belongs to klass or a parent */
+ MonoClass *klass;
+ if (type)
+ klass = mono_class_from_mono_type (type);
+ else
+ klass = method->klass;
+ return mono_method_get_object (mono_domain_get (), method, klass);
+}
+
static MonoReflectionMethod*
ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method)
{
if (!name)
return NULL;
- if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR))
+ if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR)) {
+ g_free (name);
return NULL;
+ }
res = mono_string_new (domain, name);
g_free (name);
}
static gint32
-ves_icall_System_Reflection_Module_get_MDStreamVersion (MonoReflectionModule *module)
+ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image)
{
- MonoImage *image = module->image;
-
- if (!image)
- mono_raise_exception (mono_get_exception_not_supported (""));
-
return (image->md_version_major << 16) | (image->md_version_minor);
}
return (*sig != 0x6);
}
+static void
+init_generic_context_from_args (MonoGenericContext *context, MonoArray *type_args, MonoArray *method_args)
+{
+ if (type_args)
+ context->class_inst = mono_metadata_get_generic_inst (mono_array_length (type_args),
+ mono_array_addr (type_args, MonoType*, 0));
+ else
+ context->class_inst = NULL;
+ if (method_args)
+ context->method_inst = mono_metadata_get_generic_inst (mono_array_length (method_args),
+ mono_array_addr (method_args, MonoType*, 0));
+ else
+ context->method_inst = NULL;
+}
+
static MonoType*
-ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
MonoClass *klass;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
+ MonoGenericContext context;
*error = ResolveTokenError_Other;
return NULL;
}
- if (image->dynamic)
- return mono_lookup_dynamic_token (image, token);
+ if (image->dynamic) {
+ if (type_args || method_args)
+ mono_raise_exception (mono_get_exception_not_implemented (NULL));
+ return mono_lookup_dynamic_token (image, token, NULL);
+ }
if ((index <= 0) || (index > image->tables [table].rows)) {
*error = ResolveTokenError_OutOfRange;
return NULL;
}
- klass = mono_class_get (image, token);
+ init_generic_context_from_args (&context, type_args, method_args);
+ klass = mono_class_get_full (image, token, &context);
+
if (klass)
return &klass->byval_arg;
else
}
static MonoMethod*
-ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
+ MonoGenericContext context;
+ MonoMethod *method;
*error = ResolveTokenError_Other;
return NULL;
}
- if (image->dynamic)
+ if (image->dynamic) {
+ if (type_args || method_args)
+ mono_raise_exception (mono_get_exception_not_implemented (NULL));
/* FIXME: validate memberref token type */
- return mono_lookup_dynamic_token (image, token);
+ return mono_lookup_dynamic_token (image, token, NULL);
+ }
if ((index <= 0) || (index > image->tables [table].rows)) {
*error = ResolveTokenError_OutOfRange;
return NULL;
}
- return mono_get_method (image, token, NULL);
+ init_generic_context_from_args (&context, type_args, method_args);
+ method = mono_get_method_full (image, token, NULL, &context);
+
+ return method;
}
static MonoString*
}
if (image->dynamic)
- return mono_lookup_dynamic_token (image, token);
+ return mono_lookup_dynamic_token (image, token, NULL);
if ((index <= 0) || (index >= image->heap_us.size)) {
*error = ResolveTokenError_OutOfRange;
}
static MonoClassField*
-ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
MonoClass *klass;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
+ MonoGenericContext context;
+ MonoClassField *field;
*error = ResolveTokenError_Other;
return NULL;
}
- if (image->dynamic)
+ if (image->dynamic) {
+ if (type_args || method_args)
+ mono_raise_exception (mono_get_exception_not_implemented (NULL));
/* FIXME: validate memberref token type */
- return mono_lookup_dynamic_token (image, token);
+ return mono_lookup_dynamic_token (image, token, NULL);
+ }
if ((index <= 0) || (index > image->tables [table].rows)) {
*error = ResolveTokenError_OutOfRange;
return NULL;
}
- return mono_field_from_token (image, token, &klass, NULL);
+ init_generic_context_from_args (&context, type_args, method_args);
+ field = mono_field_from_token (image, token, &klass, &context);
+
+ return field;
}
static MonoObject*
-ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
{
int table = mono_metadata_token_table (token);
case MONO_TABLE_TYPEDEF:
case MONO_TABLE_TYPEREF:
case MONO_TABLE_TYPESPEC: {
- MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, error);
+ MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
if (t)
return (MonoObject*)mono_type_get_object (mono_domain_get (), t);
else
}
case MONO_TABLE_METHOD:
case MONO_TABLE_METHODSPEC: {
- MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, error);
+ MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
if (m)
return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
else
return NULL;
}
case MONO_TABLE_FIELD: {
- MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, error);
+ MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
if (f)
return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
else
}
case MONO_TABLE_MEMBERREF:
if (mono_metadata_memberref_is_method (image, token)) {
- MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, error);
+ MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
if (m)
return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
else
return NULL;
}
else {
- MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, error);
+ MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
if (f)
return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
else
return NULL;
}
+static MonoArray*
+ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+{
+ int table = mono_metadata_token_table (token);
+ int idx = mono_metadata_token_index (token);
+ MonoTableInfo *tables = image->tables;
+ guint32 sig, len;
+ const char *ptr;
+ MonoArray *res;
+
+ *error = ResolveTokenError_OutOfRange;
+
+ /* FIXME: Support other tables ? */
+ if (table != MONO_TABLE_STANDALONESIG)
+ return NULL;
+
+ if (image->dynamic)
+ return NULL;
+
+ if ((idx == 0) || (idx > tables [MONO_TABLE_STANDALONESIG].rows))
+ return NULL;
+
+ sig = mono_metadata_decode_row_col (&tables [MONO_TABLE_STANDALONESIG], idx - 1, 0);
+
+ 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);
+ memcpy (mono_array_addr (res, guint8, 0), ptr, len);
+ return res;
+}
+
static MonoReflectionType*
ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
{
return delegate;
}
+static void
+ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate *this)
+{
+ gpointer iter;
+ MonoMethod *invoke;
+
+ /* Find the Invoke method */
+ iter = NULL;
+ while ((invoke = mono_class_get_methods (this->object.vtable->klass, &iter))) {
+ if (!strcmp (invoke->name, "Invoke"))
+ break;
+ }
+ g_assert (invoke);
+
+ this->invoke_impl = mono_compile_method (mono_marshal_get_delegate_invoke (invoke));
+}
+
/*
* Magic number to convert a time which is relative to
* Jan 1, 1970 into a value which is relative to Jan 1, 0001.
/*
* There is no standard way to get at environ.
*/
-#ifndef __MINGW32_VERSION
#ifndef _MSC_VER
+#ifndef __MINGW32_VERSION
extern
-#endif
char **environ;
#endif
+#endif
static MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
return mono_method_get_object (mono_domain_get (), result, NULL);
}
+static MonoString*
+ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
+{
+ MonoMethod *method = m->method;
+
+ MONO_OBJECT_SETREF (m, name, mono_string_new (mono_object_domain (m), method->name));
+ return m->name;
+}
+
static void
mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
{
}
/*
- * We eturn NULL for no modifiers so the corlib code can return Type.EmptyTypes
+ * We return NULL for no modifiers so the corlib code can return Type.EmptyTypes
* and avoid useless allocations.
*/
static MonoArray*
static MonoArray*
custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
{
- return mono_reflection_get_custom_attrs_by_type (obj, attr_type ? mono_class_from_mono_type (attr_type->type) : NULL);
+ MonoArray *res = mono_reflection_get_custom_attrs_by_type (obj, attr_type ? mono_class_from_mono_type (attr_type->type) : NULL);
+
+ if (mono_loader_get_last_error ()) {
+ mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
+ g_assert_not_reached ();
+ } else {
+ return res;
+ }
}
static MonoBoolean
projects / mono.git / blobdiff