#include <mono/metadata/rand.h>
#include <mono/metadata/sysmath.h>
#include <mono/metadata/string-icalls.h>
-#include <mono/metadata/mono-debug-debugger.h>
+#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/process.h>
#include <mono/metadata/environment.h>
#include <mono/metadata/profiler-private.h>
/*
* We expect a pointer to a char, not a string
*/
-static double
-mono_double_ParseImpl (char *ptr)
+static gboolean
+mono_double_ParseImpl (char *ptr, double *result)
{
gchar *endptr = NULL;
- gdouble result = 0.0;
+ *result = 0.0;
MONO_ARCH_SAVE_REGS;
#ifdef __arm__
if (*ptr)
- result = strtod (ptr, &endptr);
+ *result = strtod (ptr, &endptr);
#else
if (*ptr)
- result = bsd_strtod (ptr, &endptr);
+ *result = bsd_strtod (ptr, &endptr);
#endif
if (!*ptr || (endptr && *endptr))
- mono_raise_exception (mono_exception_from_name (mono_get_corlib (),
- "System",
- "FormatException"));
+ return FALSE;
- return result;
+ return TRUE;
}
static void
ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
{
int sz = mono_array_element_size (mono_object_class (arr));
- memset (mono_array_addr_with_size (arr, idx, sz), 0, length * sz);
+ memset (mono_array_addr_with_size (arr, sz, idx), 0, length * sz);
}
static gboolean
(source_idx + length > mono_array_length (source)))
return FALSE;
- element_size = mono_array_element_size (source->obj.vtable->klass);
- dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx);
- source_addr = mono_array_addr_with_size (source, element_size, source_idx);
-
src_class = source->obj.vtable->klass->element_class;
dest_class = dest->obj.vtable->klass->element_class;
/* Case1: object[] -> valuetype[] (ArrayList::ToArray) */
if (src_class == mono_defaults.object_class && dest_class->valuetype) {
+ int has_refs = dest_class->has_references;
for (i = source_idx; i < source_idx + length; ++i) {
MonoObject *elem = mono_array_get (source, MonoObject*, i);
if (elem && !mono_object_isinst (elem, dest_class))
}
element_size = mono_array_element_size (dest->obj.vtable->klass);
+ memset (mono_array_addr_with_size (dest, element_size, dest_idx), 0, element_size * length);
for (i = 0; i < length; ++i) {
MonoObject *elem = mono_array_get (source, MonoObject*, source_idx + i);
void *addr = mono_array_addr_with_size (dest, element_size, dest_idx + i);
if (!elem)
- memset (addr, 0, element_size);
+ continue;
+ if (has_refs)
+ mono_value_copy (addr, (char *)elem + sizeof (MonoObject), dest_class);
else
memcpy (addr, (char *)elem + sizeof (MonoObject), element_size);
}
return FALSE;
}
- memmove (dest_addr, source_addr, element_size * length);
+ if (dest_class->valuetype) {
+ element_size = mono_array_element_size (source->obj.vtable->klass);
+ source_addr = mono_array_addr_with_size (source, element_size, source_idx);
+ if (dest_class->has_references) {
+ mono_value_copy_array (dest, dest_idx, source_addr, length);
+ } else {
+ dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx);
+ memmove (dest_addr, source_addr, element_size * length);
+ }
+ } else {
+ mono_array_memcpy_refs (dest, dest_idx, source, source_idx, length);
+ }
return TRUE;
}
klass = mono_object_class (this);
if (mono_class_num_fields (klass) == 0)
- return ves_icall_System_Object_GetHashCode (this);
+ return mono_object_hash (this);
/*
* Compute the starting value of the hashcode for fields of primitive
}
if (values) {
+ int i;
*fields = mono_array_new (mono_domain_get (), mono_defaults.object_class, count);
- memcpy (mono_array_addr (*fields, MonoObject*, 0), values, count * sizeof (MonoObject*));
- }
- else
+ for (i = 0; i < count; ++i)
+ mono_array_setref (*fields, i, values [i]);
+ } else {
*fields = NULL;
+ }
return result;
}
}
if (values) {
+ int i;
*fields = mono_array_new (mono_domain_get (), mono_defaults.object_class, count);
- memcpy (mono_array_addr (*fields, MonoObject*, 0), values, count * sizeof (MonoObject*));
-
+ for (i = 0; i < count; ++i)
+ mono_array_setref (*fields, i, values [i]);
return FALSE;
- }
- else
+ } else {
return TRUE;
+ }
}
static MonoReflectionType *
mono_image_build_metadata (mb);
}
+static gboolean
+get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
+{
+ MonoMethod **dest = data;
+
+ /* skip unmanaged frames */
+ if (!managed)
+ return FALSE;
+
+ if (m == *dest) {
+ *dest = NULL;
+ return FALSE;
+ }
+ if (!(*dest)) {
+ *dest = m;
+ return TRUE;
+ }
+ return FALSE;
+}
+
static MonoReflectionType *
type_from_name (const char *str, MonoBoolean ignoreCase)
{
MonoType *type = NULL;
- MonoAssembly *assembly;
+ MonoAssembly *assembly = NULL;
MonoTypeNameParse info;
char *temp_str = g_strdup (str);
gboolean type_resolve = FALSE;
if (info.assembly.name) {
assembly = mono_assembly_load (&info.assembly, NULL, NULL);
} else {
- MonoReflectionAssembly *refass;
+ MonoMethod *m = mono_method_get_last_managed ();
+ MonoMethod *dest = m;
- refass = ves_icall_System_Reflection_Assembly_GetCallingAssembly ();
- assembly = refass->assembly;
+ mono_stack_walk_no_il (get_caller, &dest);
+ if (!dest)
+ dest = m;
+
+ /*
+ * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus
+ * causing ves_icall_System_Reflection_Assembly_GetCallingAssembly()
+ * to crash. This only seems to happen in some strange remoting
+ * scenarios and I was unable to figure out what's happening there.
+ * Dec 10, 2005 - Martin.
+ */
+
+ if (dest)
+ assembly = dest->klass->image->assembly;
+ else {
+ g_warning (G_STRLOC);
+ }
}
if (assembly)
{
MONO_ARCH_SAVE_REGS;
- if (type->type && c->type)
+ if (c && type->type && c->type)
return mono_metadata_type_equal (type->type, c->type);
else
return FALSE;
return mono_param_get_objects (domain, method);
}
+static MonoReflectionMarshal*
+ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
+{
+ MonoDomain *domain = mono_domain_get ();
+ MonoReflectionMarshal* res = NULL;
+ 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);
+
+ if (mspecs [0])
+ res = mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [0]);
+
+ for (i = mono_method_signature (method)->param_count; i >= 0; i--)
+ if (mspecs [i])
+ mono_metadata_free_marshal_spec (mspecs [i]);
+ g_free (mspecs);
+
+ return res;
+}
+
static gint32
ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
{
case MONO_TYPE_VALUETYPE:
is_ref = t->byref;
break;
+ case MONO_TYPE_GENERICINST:
+ if (mono_type_generic_inst_is_valuetype (t)) {
+ is_ref = t->byref;
+ } else {
+ is_ref = TRUE;
+ }
+ break;
default:
g_error ("type 0x%x not handled in "
"ves_icall_Monofield_GetValue", t->type);
return o;
}
+ if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) {
+ MonoClass *nklass = mono_class_from_mono_type (cf->type);
+ guint8 *buf;
+
+ /* Convert the Nullable structure into a boxed vtype */
+ if (is_static)
+ buf = (guint8*)vtable->data + cf->offset;
+ else
+ buf = (guint8*)obj + cf->offset;
+
+ return mono_nullable_box (buf, nklass);
+ }
+
/* boxed value type */
klass = mono_class_from_mono_type (cf->type);
o = mono_object_new (domain, klass);
case MONO_TYPE_GENERICINST: {
MonoGenericClass *gclass = cf->type->data.generic_class;
g_assert (!gclass->inst->is_open);
- if (gclass->container_class->valuetype && (v != NULL))
- v += sizeof (MonoObject);
+
+ if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) {
+ MonoClass *nklass = mono_class_from_mono_type (cf->type);
+ guint8 *buf;
+
+ /*
+ * 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);
+
+ mono_nullable_init (buf, value, nklass);
+
+ v = (gchar*)buf;
+ }
+ else
+ if (gclass->container_class->valuetype && (v != NULL))
+ v += sizeof (MonoObject);
break;
}
default:
}
}
-static MonoReflectionField*
-ves_icall_MonoField_Mono_GetGenericFieldDefinition (MonoReflectionField *field)
-{
- MONO_ARCH_SAVE_REGS;
-
- if (field->field->generic_info && field->field->generic_info->reflection_info)
- return field->field->generic_info->reflection_info;
-
- return field;
-}
-
static MonoReflectionType*
ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod *rmethod)
{
MONO_ARCH_SAVE_REGS;
- info->declaring_type = mono_type_get_object (domain, &event->klass->byval_arg);
- info->reflected_type = mono_type_get_object (domain, &event->event->parent->byval_arg);
+ info->reflected_type = mono_type_get_object (domain, &event->klass->byval_arg);
+ info->declaring_type = mono_type_get_object (domain, &event->event->parent->byval_arg);
info->name = mono_string_new (domain, event->event->name);
info->attrs = event->event->attrs;
info->other_methods = mono_array_new (domain, mono_defaults.method_info_class, n);
for (i = 0; i < n; i++)
- mono_array_set (info->other_methods, gpointer, i,
- mono_method_get_object (domain, event->event->other [i], NULL));
+ mono_array_setref (info->other_methods, i, mono_method_get_object (domain, event->event->other [i], NULL));
}
}
int i;
MonoClass *class = mono_class_from_mono_type (type->type);
MonoClass *parent;
- MonoBitSet *slots = mono_bitset_new (class->max_interface_id + 1, 0);
+ MonoBitSet *slots;
+ MonoGenericContext *context = NULL;
MONO_ARCH_SAVE_REGS;
+ /* open generic-instance classes can share their interface_id */
+ if (class->generic_class && class->generic_class->inst->is_open) {
+ context = class->generic_class->context;
+ class = class->generic_class->container_class;
+ }
+
+ mono_class_setup_vtable (class);
+
+ slots = mono_bitset_new (class->max_interface_id + 1, 0);
+
if (class->rank) {
/* GetInterfaces() returns an empty array in MS.NET (this may be a bug) */
mono_bitset_free (slots);
intf = mono_array_new (domain, mono_defaults.monotype_class, ifaces->len);
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)
+ ret = mono_class_inflate_generic_type (ret, context);
- mono_array_set (intf, gpointer, i,
- mono_type_get_object (domain, &ic->byval_arg));
+ mono_array_setref (intf, i, mono_type_get_object (domain, ret));
}
g_ptr_array_free (ifaces, TRUE);
MONO_ARCH_SAVE_REGS;
+ 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])
return;
iter = NULL;
while ((method = mono_class_get_methods (iclass, &iter))) {
member = mono_method_get_object (domain, method, iclass);
- mono_array_set (*methods, gpointer, i, member);
+ mono_array_setref (*methods, i, member);
member = mono_method_get_object (domain, class->vtable [i + ioffset], class);
- mono_array_set (*targets, gpointer, i, member);
+ mono_array_setref (*targets, i, member);
i ++;
}
static MonoReflectionType*
ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
{
- MonoDomain *domain = mono_domain_get ();
- MonoClass *class = mono_class_from_mono_type (type->type);
+ MonoDomain *domain = mono_domain_get ();
+ MonoClass *class;
MONO_ARCH_SAVE_REGS;
- return class->nested_in ? mono_type_get_object (domain, &class->nested_in->byval_arg) : NULL;
+ if (type->type->byref)
+ return NULL;
+ if (type->type->type == MONO_TYPE_VAR)
+ class = type->type->data.generic_param->owner->klass;
+ else if (type->type->type == MONO_TYPE_MVAR)
+ class = type->type->data.generic_param->method->klass;
+ else
+ class = mono_class_from_mono_type (type->type)->nested_in;
+
+ return class ? mono_type_get_object (domain, &class->byval_arg) : NULL;
}
static MonoReflectionType*
res = mono_array_new (mono_object_domain (type), mono_defaults.monotype_class, container->type_argc);
for (i = 0; i < container->type_argc; ++i) {
pklass = mono_class_from_generic_parameter (&container->type_params [i], klass->image, FALSE);
- mono_array_set (res, gpointer, i, mono_type_get_object (mono_object_domain (type), &pklass->byval_arg));
+ 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;
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_set (res, gpointer, i, mono_type_get_object (mono_object_domain (type), inst->type_argv [i]));
- }
+ 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]));
} else {
res = mono_array_new (mono_object_domain (type), mono_defaults.monotype_class, 0);
}
res = mono_array_new (domain, mono_defaults.monotype_class, count);
for (i = 0; i < count; i++)
- mono_array_set (res, gpointer, i,
- mono_type_get_object (domain, ¶m->constraints [i]->byval_arg));
+ mono_array_setref (res, i, mono_type_get_object (domain, ¶m->constraints [i]->byval_arg));
return res;
MONO_ARCH_SAVE_REGS;
if (type->type->type == MONO_TYPE_VAR || type->type->type == MONO_TYPE_MVAR)
- return TRUE;
+ return !type->type->byref;
return FALSE;
}
MONO_ARCH_SAVE_REGS;
if (tb->type.type->type == MONO_TYPE_VAR || tb->type.type->type == MONO_TYPE_MVAR)
- return TRUE;
+ return !tb->type.type->byref;
return FALSE;
}
ves_icall_MonoGenericClass_GetParentType (MonoReflectionGenericClass *type)
{
MonoDynamicGenericClass *gclass;
+ MonoReflectionType *parent = NULL;
+ MonoDomain *domain;
+ MonoType *inflated;
MonoClass *klass;
MONO_ARCH_SAVE_REGS;
g_assert (type->type.type->data.generic_class->is_dynamic);
gclass = (MonoDynamicGenericClass *) type->type.type->data.generic_class;
- if (!gclass->parent || (gclass->parent->type != MONO_TYPE_GENERICINST))
- return NULL;
+ domain = mono_object_domain (type);
+ klass = mono_class_from_mono_type (type->generic_type->type);
- klass = mono_class_from_mono_type (gclass->parent);
if (!klass->generic_class && !klass->generic_container)
return NULL;
- return mono_type_get_object (mono_object_domain (type), gclass->parent);
+ if (!strcmp (type->generic_type->object.vtable->klass->name, "TypeBuilder")) {
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *) type->generic_type;
+ parent = tb->parent;
+ } else if (klass->wastypebuilder) {
+ MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *) type->generic_type;
+ parent = tb->parent;
+ } else {
+ MonoClass *pklass = klass->parent;
+ if (pklass)
+ parent = mono_type_get_object (domain, &pklass->byval_arg);
+ }
+
+ if (!parent || (parent->type->type != MONO_TYPE_GENERICINST))
+ return NULL;
+
+ inflated = mono_class_inflate_generic_type (
+ parent->type, gclass->generic_class.generic_class.context);
+
+ return mono_type_get_object (domain, inflated);
}
static MonoArray*
{
static MonoClass *System_Reflection_MonoGenericClass;
MonoDynamicGenericClass *gclass;
+ MonoReflectionTypeBuilder *tb = NULL;
+ MonoClass *klass = NULL;
MonoDomain *domain;
- MonoClass *klass;
MonoArray *res;
- int i;
+ int icount, i;
MONO_ARCH_SAVE_REGS;
g_assert (type->type.type->data.generic_class->is_dynamic);
gclass = (MonoDynamicGenericClass *) type->type.type->data.generic_class;
- if (!gclass->ifaces)
- return mono_array_new (domain, System_Reflection_MonoGenericClass, 0);
- klass = gclass->generic_class.generic_class.container_class;
+ if (!strcmp (type->generic_type->object.vtable->klass->name, "TypeBuilder")) {
+ tb = (MonoReflectionTypeBuilder *) type->generic_type;
+ icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0;
+ } else {
+ klass = gclass->generic_class.generic_class.container_class;
+ mono_class_init (klass);
+ icount = klass->interface_count;
+ }
+
+ res = mono_array_new (domain, System_Reflection_MonoGenericClass, icount);
- res = mono_array_new (domain, System_Reflection_MonoGenericClass, gclass->count_ifaces);
+ for (i = 0; i < icount; i++) {
+ MonoReflectionType *iface;
+ MonoType *it;
- for (i = 0; i < gclass->count_ifaces; i++) {
- MonoReflectionType *iface = mono_type_get_object (domain, gclass->ifaces [i]);
+ if (tb) {
+ iface = mono_array_get (tb->interfaces, MonoReflectionType *, i);
+ it = iface->type;
+ } else
+ it = &klass->interfaces [i]->byval_arg;
- mono_array_set (res, gpointer, i, iface);
+ it = mono_class_inflate_generic_type (
+ it, gclass->generic_class.generic_class.context);
+
+ iface = mono_type_get_object (domain, it);
+ mono_array_setref (res, i, iface);
}
return res;
}
-
static MonoReflectionMethod*
ves_icall_MonoGenericClass_GetCorrespondingInflatedMethod (MonoReflectionGenericClass *type,
MonoReflectionMethod* generic)
res = mono_array_new (domain, mono_defaults.method_info_class, dgclass->count_methods);
for (i = 0; i < dgclass->count_methods; i++)
- mono_array_set (res, gpointer, i,
- mono_method_get_object (domain, dgclass->methods [i], refclass));
+ mono_array_setref (res, i, mono_method_get_object (domain, dgclass->methods [i], refclass));
return res;
}
res = mono_array_new (domain, System_Reflection_ConstructorInfo, dgclass->count_ctors);
for (i = 0; i < dgclass->count_ctors; i++)
- mono_array_set (res, gpointer, i,
- mono_method_get_object (domain, dgclass->ctors [i], refclass));
+ mono_array_setref (res, i, mono_method_get_object (domain, dgclass->ctors [i], refclass));
return res;
}
res = mono_array_new (domain, mono_defaults.field_info_class, dgclass->count_fields);
for (i = 0; i < dgclass->count_fields; i++)
- mono_array_set (res, gpointer, i,
- mono_field_get_object (domain, refclass, &dgclass->fields [i]));
+ mono_array_setref (res, i, mono_field_get_object (domain, refclass, &dgclass->fields [i]));
return res;
}
res = mono_array_new (domain, System_Reflection_PropertyInfo, dgclass->count_properties);
for (i = 0; i < dgclass->count_properties; i++)
- mono_array_set (res, gpointer, i,
- mono_property_get_object (domain, refclass, &dgclass->properties [i]));
+ mono_array_setref (res, i, mono_property_get_object (domain, refclass, &dgclass->properties [i]));
return res;
}
res = mono_array_new (domain, System_Reflection_EventInfo, dgclass->count_events);
for (i = 0; i < dgclass->count_events; i++)
- mono_array_set (res, gpointer, i,
- mono_event_get_object (domain, refclass, &dgclass->events [i]));
+ mono_array_setref (res, i, mono_event_get_object (domain, refclass, &dgclass->events [i]));
return res;
}
MONO_ARCH_SAVE_REGS;
- method = type->type->data.generic_param->method;
- if (!method)
+ if (type->type->byref || type->type->type != MONO_TYPE_MVAR)
return NULL;
+ method = type->type->data.generic_param->method;
+ g_assert (method);
klass = mono_class_from_mono_type (type->type);
return mono_method_get_object (mono_object_domain (type), method, klass);
}
attr = (MonoReflectionDllImportAttribute*)mono_object_new (domain, DllImportAttributeClass);
- attr->dll = mono_string_new (domain, scope);
- attr->entry_point = mono_string_new (domain, import);
+ MONO_OBJECT_SETREF (attr, dll, mono_string_new (domain, scope));
+ MONO_OBJECT_SETREF (attr, entry_point, mono_string_new (domain, import));
attr->call_conv = (flags & 0x700) >> 8;
attr->charset = ((flags & 0x6) >> 1) + 1;
if (attr->charset == 1)
}
static gboolean
-ves_icall_MonoMethod_get_HasGenericParameters (MonoReflectionMethod *method)
+ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return FALSE;
-
return mono_method_signature (method->method)->generic_param_count != 0;
}
-static gboolean
-ves_icall_MonoMethod_get_Mono_IsInflatedMethod (MonoReflectionMethod *method)
-{
- MONO_ARCH_SAVE_REGS;
-
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return FALSE;
-
- return method->method->is_inflated;
-}
-
static gboolean
ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return FALSE;
-
- return mono_method_signature (method->method)->generic_param_count != 0;
+ return !method->method->is_inflated &&
+ (mono_method_signature (method->method)->generic_param_count != 0);
}
static MonoArray*
{
MonoArray *res;
MonoDomain *domain;
- MonoMethodNormal *mn;
int count, i;
MONO_ARCH_SAVE_REGS;
domain = mono_object_domain (method);
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return mono_array_new (domain, mono_defaults.monotype_class, 0);
-
if (method->method->is_inflated) {
MonoMethodInflated *imethod = (MonoMethodInflated *) method->method;
MonoGenericMethod *gmethod = imethod->context->gmethod;
count = gmethod->inst->type_argc;
res = mono_array_new (domain, mono_defaults.monotype_class, count);
- for (i = 0; i < count; i++) {
- MonoType *t = gmethod->inst->type_argv [i];
- mono_array_set (
- res, gpointer, i, mono_type_get_object (domain, t));
- }
+ for (i = 0; i < count; i++)
+ mono_array_setref (res, i, mono_type_get_object (domain, gmethod->inst->type_argv [i]));
return res;
}
}
- mn = (MonoMethodNormal *) method->method;
count = mono_method_signature (method->method)->generic_param_count;
res = mono_array_new (domain, mono_defaults.monotype_class, count);
for (i = 0; i < count; i++) {
- MonoGenericParam *param = &mn->generic_container->type_params [i];
+ MonoGenericParam *param = &method->method->generic_container->type_params [i];
MonoClass *pklass = mono_class_from_generic_parameter (
param, method->method->klass->image, TRUE);
- mono_array_set (res, gpointer, i,
+ mono_array_setref (res, i,
mono_type_get_object (domain, &pklass->byval_arg));
}
* is stupid), mono_runtime_invoke_*() calls the provided method, allowing
* greater flexibility.
*/
- MonoMethod *m = method->method;
+ MonoMethod *m = mono_get_inflated_method (method->method);
int pcount;
void *obj = this;
out_args = mono_array_new (domain, mono_defaults.object_class, 1);
*outArgs = out_args;
- mono_array_set (out_args, gpointer, 0, result);
+ mono_array_setref (out_args, 0, result);
g_free (str);
return NULL;
}
if (sig->params [i]->byref) {
gpointer arg;
arg = mono_array_get (params, gpointer, i);
- mono_array_set (out_args, gpointer, j, arg);
+ mono_array_setref (out_args, j, arg);
j++;
}
}
return result;
}
+static guint64
+read_enum_value (char *mem, int type)
+{
+ switch (type) {
+ case MONO_TYPE_U1:
+ return *(guint8*)mem;
+ case MONO_TYPE_I1:
+ return *(gint8*)mem;
+ case MONO_TYPE_U2:
+ return *(guint16*)mem;
+ case MONO_TYPE_I2:
+ return *(gint16*)mem;
+ case MONO_TYPE_U4:
+ return *(guint32*)mem;
+ case MONO_TYPE_I4:
+ return *(gint32*)mem;
+ case MONO_TYPE_U8:
+ return *(guint64*)mem;
+ case MONO_TYPE_I8:
+ return *(gint64*)mem;
+ default:
+ g_assert_not_reached ();
+ }
+ return 0;
+}
+
+static void
+write_enum_value (char *mem, int type, guint64 value)
+{
+ switch (type) {
+ case MONO_TYPE_U1:
+ case MONO_TYPE_I1: {
+ guint8 *p = (guint8*)mem;
+ *p = value;
+ break;
+ }
+ case MONO_TYPE_U2:
+ case MONO_TYPE_I2: {
+ guint16 *p = (void*)mem;
+ *p = value;
+ break;
+ }
+ case MONO_TYPE_U4:
+ case MONO_TYPE_I4: {
+ guint32 *p = (void*)mem;
+ *p = value;
+ break;
+ }
+ case MONO_TYPE_U8:
+ case MONO_TYPE_I8: {
+ guint64 *p = (void*)mem;
+ *p = value;
+ break;
+ }
+ default:
+ g_assert_not_reached ();
+ }
+ return;
+}
+
static MonoObject *
ves_icall_System_Enum_ToObject (MonoReflectionType *type, MonoObject *obj)
{
MonoDomain *domain;
MonoClass *enumc, *objc;
- gint32 s1, s2;
MonoObject *res;
+ guint64 val;
MONO_ARCH_SAVE_REGS;
enumc = mono_class_from_mono_type (type->type);
objc = obj->vtable->klass;
- MONO_CHECK_ARG (obj, enumc->enumtype == TRUE);
- MONO_CHECK_ARG (obj, (objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 &&
- objc->byval_arg.type <= MONO_TYPE_U8));
-
- s1 = mono_class_value_size (enumc, NULL);
- s2 = mono_class_value_size (objc, NULL);
+ if (!enumc->enumtype)
+ mono_raise_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
+ if (!((objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 && objc->byval_arg.type <= MONO_TYPE_U8)))
+ mono_raise_exception (mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32."));
res = mono_object_new (domain, enumc);
+ val = read_enum_value ((char *)obj + sizeof (MonoObject), objc->enumtype? objc->enum_basetype->type: objc->byval_arg.type);
+ write_enum_value ((char *)res + sizeof (MonoObject), enumc->enum_basetype->type, val);
-#if G_BYTE_ORDER == G_LITTLE_ENDIAN
- memcpy ((char *)res + sizeof (MonoObject), (char *)obj + sizeof (MonoObject), MIN (s1, s2));
-#else
- memcpy ((char *)res + sizeof (MonoObject) + (s1 > s2 ? s1 - s2 : 0),
- (char *)obj + sizeof (MonoObject) + (s2 > s1 ? s2 - s1 : 0),
- MIN (s1, s2));
-#endif
return res;
}
continue;
if (mono_field_is_deleted (field))
continue;
- mono_array_set (info->names, gpointer, j, mono_string_new (domain, field->name));
+ mono_array_setref (info->names, j, mono_string_new (domain, field->name));
if (!field->data) {
crow = mono_metadata_get_constant_index (enumc->image, mono_class_get_field_token (field), crow + 1);
i = 0;
tmp = l = g_slist_reverse (l);
for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
+ mono_array_setref (res, i, tmp->data);
g_slist_free (l);
return res;
}
MonoMethod *method;
gpointer iter;
MonoObject *member;
- int i, len, match;
+ int i, len, match, nslots;
guint32 method_slots_default [8];
guint32 *method_slots;
gchar *mname = NULL;
compare_func = (ignore_case) ? g_strcasecmp : strcmp;
}
- if (klass->vtable_size >= sizeof (method_slots_default) * 8) {
- method_slots = g_new0 (guint32, klass->vtable_size / 32 + 1);
+ mono_class_setup_vtable (klass);
+
+ 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 {
method_slots = method_slots_default;
memset (method_slots, 0, sizeof (method_slots_default));
match = 0;
if (method->slot != -1) {
+ g_assert (method->slot < nslots);
if (method_slots [method->slot >> 5] & (1 << (method->slot & 0x1f)))
continue;
method_slots [method->slot >> 5] |= 1 << (method->slot & 0x1f);
tmp = l = g_slist_reverse (l);
for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
+ mono_array_setref (res, i, tmp->data);
g_slist_free (l);
if (method_slots != method_slots_default)
g_free (method_slots);
i = 0;
tmp = l = g_slist_reverse (l);
for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
+ mono_array_setref (res, i, tmp->data);
g_slist_free (l);
return res;
}
MonoArray *res;
MonoMethod *method;
MonoProperty *prop;
- int i, match;
+ int i, match, nslots;
int len = 0;
guint32 flags;
guint32 method_slots_default [8];
compare_func = (ignore_case) ? g_strcasecmp : strcmp;
}
- if (klass->vtable_size >= sizeof (method_slots_default) * 8) {
- method_slots = g_new0 (guint32, klass->vtable_size / 32 + 1);
+ mono_class_setup_vtable (klass);
+
+ 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 {
method_slots = method_slots_default;
memset (method_slots, 0, sizeof (method_slots_default));
tmp = l = g_slist_reverse (l);
for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
+ mono_array_setref (res, i, tmp->data);
g_slist_free (l);
if (method_slots != method_slots_default)
g_free (method_slots);
if (!match)
continue;
match = 0;
- l = g_slist_prepend (l, mono_event_get_object (domain, klass, event));
+ l = g_slist_prepend (l, mono_event_get_object (domain, startklass, event));
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
tmp = l = g_slist_reverse (l);
for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
+ mono_array_setref (res, i, tmp->data);
g_slist_free (l);
return res;
}
i = 0;
tmp = l = g_slist_reverse (l);
for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
+ mono_array_setref (res, i, tmp->data);
g_slist_free (l);
return res;
}
gchar *str;
MonoType *type = NULL;
MonoTypeNameParse info;
- gboolean type_resolve = FALSE;
+ gboolean type_resolve;
MONO_ARCH_SAVE_REGS;
+ /* On MS.NET, this does not fire a TypeResolve event */
+ type_resolve = TRUE;
str = mono_string_to_utf8 (name);
/*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
if (!mono_reflection_parse_type (str, &info)) {
}
static MonoString *
-ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly)
+ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly, MonoBoolean escaped)
{
MonoDomain *domain = mono_object_domain (assembly);
MonoAssembly *mass = assembly->assembly;
- MonoString *res;
+ MonoString *res = NULL;
gchar *uri;
gchar *absolute;
MONO_ARCH_SAVE_REGS;
absolute = g_build_filename (mass->basedir, mass->image->module_name, NULL);
- uri = g_filename_to_uri (absolute, NULL, NULL);
- res = mono_string_new (domain, uri);
- g_free (uri);
+#if PLATFORM_WIN32
+ {
+ gint i;
+ for (i = strlen (absolute) - 1; i >= 0; i--)
+ if (absolute [i] == '\\')
+ absolute [i] = '/';
+ }
+#endif
+ if (escaped) {
+ uri = g_filename_to_uri (absolute, NULL, NULL);
+ } else {
+ uri = g_strconcat ("file://", absolute, NULL);
+ }
+
+ if (uri) {
+ res = mono_string_new (domain, uri);
+ g_free (uri);
+ }
g_free (absolute);
return res;
}
for (i = 0; i < table->rows; ++i) {
val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
- mono_array_set (result, gpointer, i, mono_string_new (mono_object_domain (assembly), val));
+ mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val));
}
return result;
}
aname = (MonoReflectionAssemblyName *) mono_object_new (
domain, System_Reflection_AssemblyName);
- aname->name = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]));
+ MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
aname->versioncompat = 1; /* SameMachine (default) */
aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
- aname->version = create_version (domain, aname->major, aname->minor, aname->build, aname->revision);
+ MONO_OBJECT_SETREF (aname, version, create_version (domain, aname->major, aname->minor, aname->build, aname->revision));
if (create_culture) {
gpointer args [1];
args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]));
- aname->cultureInfo = mono_runtime_invoke (create_culture, NULL, args, NULL);
+ MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
}
if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
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 */
- aname->publicKey = mono_array_new (domain, mono_defaults.byte_class, pkey_len);
+ 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);
} else {
- aname->keyToken = mono_array_new (domain, mono_defaults.byte_class, pkey_len);
+ 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);
}
}
/* note: this function doesn't return the codebase on purpose (i.e. it can
be used under partial trust as path information isn't present). */
- mono_array_set (result, gpointer, i, aname);
+ mono_array_setref (result, i, aname);
}
return result;
}
{
MonoString *name = mono_string_new (mono_object_domain (info->res), key);
- mono_array_set (info->res, gpointer, info->idx, name);
+ mono_array_setref (info->res, info->idx, name);
info->idx++;
}
table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE);
val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]);
- info->filename = mono_string_new (mono_object_domain (assembly), val);
+ MONO_OBJECT_SETREF (info, filename, mono_string_new (mono_object_domain (assembly), val));
if (file_cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
info->location = 0;
else
g_free (msg);
mono_raise_exception (ex);
}
- info->assembly = mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]);
+ MONO_OBJECT_SETREF (info, assembly, mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]));
/* Obtain info recursively */
ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info);
if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
n = g_concat_dir_and_file (assembly->assembly->basedir, val);
- mono_array_set (result, gpointer, count, mono_string_new (mono_object_domain (assembly), n));
+ mono_array_setref (result, count, mono_string_new (mono_object_domain (assembly), n));
g_free (n);
count ++;
}
klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
- mono_array_set (res, gpointer, 0, mono_module_get_object (domain, assembly->assembly->image));
+ mono_array_setref (res, 0, mono_module_get_object (domain, assembly->assembly->image));
j = 1;
for (i = 0; i < module_count; ++i)
if (modules [i]) {
- mono_array_set (res, gpointer, j, mono_module_get_object (domain, modules[i]));
+ mono_array_setref (res, j, mono_module_get_object (domain, modules[i]));
++j;
}
for (i = 0; i < file_count; ++i, ++j)
- mono_array_set (res, gpointer, j, mono_module_file_get_object (domain, assembly->assembly->image, i));
+ mono_array_setref (res, j, mono_module_file_get_object (domain, assembly->assembly->image, i));
if (assembly->assembly->dynamic)
g_free (modules);
}
-static gboolean
-get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
-{
- MonoMethod **dest = data;
-
- /* skip unmanaged frames */
- if (!managed)
- return FALSE;
-
- if (m == *dest) {
- *dest = NULL;
- return FALSE;
- }
- if (!(*dest)) {
- *dest = m;
- return TRUE;
- }
- return FALSE;
-}
-
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
{
return mono_assembly_get_object (domain, domain->entry_assembly);
}
-
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
{
if (!name)
return NULL;
+ if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR))
+ return NULL;
+
res = mono_string_new (domain, name);
g_free (name);
MONO_ARCH_SAVE_REGS;
- aname->name = mono_string_new (domain, name->name);
+ MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
aname->major = name->major;
aname->minor = name->minor;
aname->build = name->build;
aname->revision = name->revision;
aname->hashalg = name->hash_alg;
if (by_default_version)
- aname->version = create_version (domain, name->major, name->minor, name->build, name->revision);
+ MONO_OBJECT_SETREF (aname, version, create_version (domain, name->major, name->minor, name->build, name->revision));
codebase = g_filename_to_uri (absolute, NULL, NULL);
if (codebase) {
- aname->codebase = mono_string_new (domain, codebase);
+ MONO_OBJECT_SETREF (aname, codebase, mono_string_new (domain, codebase));
g_free (codebase);
}
if (name->culture) {
args [0] = mono_string_new (domain, name->culture);
- aname->cultureInfo = mono_runtime_invoke (create_culture, NULL, args, NULL);
+ MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
}
if (name->public_key) {
pkey_ptr = (char*)name->public_key;
pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
- aname->publicKey = mono_array_new (domain, mono_defaults.byte_class, pkey_len);
+ 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);
}
int i, j;
char *p;
- aname->keyToken = mono_array_new (domain, mono_defaults.byte_class, 8);
+ MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8));
p = mono_array_addr (aname->keyToken, char, 0);
for (i = 0, j = 0; i < 8; i++) {
filename = mono_string_to_utf8 (fname);
image = mono_image_open (filename, &status);
-
+
if (!image){
MonoException *exc;
mono_raise_exception (exc);
}
+ /* So we can call mono_image_close () later */
+ mono_image_addref (image);
res = mono_assembly_fill_assembly_name (image, &name);
if (!res) {
mono_image_close (image);
visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
if (!exportedOnly || (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)) {
klass = mono_class_get (image, (i + 1) | MONO_TOKEN_TYPE_DEF);
- mono_array_set (res, gpointer, count, mono_type_get_object (domain, &klass->byval_arg));
+ mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg));
count++;
}
}
if (abuilder->modules) {
for (i = 0; i < mono_array_length(abuilder->modules); i++) {
MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
- if (res == NULL)
- res = mb->types;
- else {
- MonoArray *append = mb->types;
- if (mono_array_length (append) > 0) {
- guint32 len1, len2;
- MonoArray *new;
- len1 = mono_array_length (res);
- len2 = mono_array_length (append);
- new = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
- memcpy (mono_array_addr (new, MonoReflectionType*, 0),
- mono_array_addr (res, MonoReflectionType*, 0),
- len1 * sizeof (MonoReflectionType*));
- memcpy (mono_array_addr (new, MonoReflectionType*, len1),
- mono_array_addr (append, MonoReflectionType*, 0),
- len2 * sizeof (MonoReflectionType*));
- res = new;
- }
+ MonoArray *append = mb->types;
+ if (append && mono_array_length (append) > 0) {
+ guint32 len1, len2;
+ MonoArray *new;
+ len1 = res ? mono_array_length (res) : 0;
+ len2 = mono_array_length (append);
+ new = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
+ if (res)
+ mono_array_memcpy_refs (new, 0, res, 0, len1);
+ mono_array_memcpy_refs (new, len1, append, 0, len2);
+ res = new;
}
}
- /*
+ /*
* Replace TypeBuilders with the created types to be compatible
* with MS.NET.
*/
for (i = 0; i < mono_array_length (res); ++i) {
MonoReflectionTypeBuilder *tb = mono_array_get (res, MonoReflectionTypeBuilder*, i);
if (tb->created)
- mono_array_set (res, MonoReflectionType*, i, tb->created);
+ mono_array_setref (res, i, tb->created);
}
}
}
if (abuilder->loaded_modules)
for (i = 0; i < mono_array_length(abuilder->loaded_modules); i++) {
MonoReflectionModule *rm = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
- if (res == NULL)
- res = mono_module_get_types (domain, rm->image, exportedOnly);
- else {
- MonoArray *append = mono_module_get_types (domain, rm->image, exportedOnly);
- if (mono_array_length (append) > 0) {
- guint32 len1, len2;
- MonoArray *new;
- len1 = mono_array_length (res);
- len2 = mono_array_length (append);
- new = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
- memcpy (mono_array_addr (new, MonoReflectionType*, 0),
- mono_array_addr (res, MonoReflectionType*, 0),
- len1 * sizeof (MonoReflectionType*));
- memcpy (mono_array_addr (new, MonoReflectionType*, len1),
- mono_array_addr (append, MonoReflectionType*, 0),
- len2 * sizeof (MonoReflectionType*));
- res = new;
- }
+ MonoArray *append = mono_module_get_types (domain, rm->image, exportedOnly);
+ if (append && mono_array_length (append) > 0) {
+ guint32 len1, len2;
+ MonoArray *new;
+ len1 = res ? mono_array_length (res) : 0;
+ len2 = mono_array_length (append);
+ new = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
+ if (res)
+ mono_array_memcpy_refs (new, 0, res, 0, len1);
+ mono_array_memcpy_refs (new, len1, append, 0, len2);
+ res = new;
}
}
- return res;
+ if (res)
+ return res;
+ else
+ return mono_array_new (domain, mono_defaults.monotype_class, 0);
}
image = assembly->assembly->image;
table = &image->tables [MONO_TABLE_FILE];
len1 = mono_array_length (res);
len2 = mono_array_length (res2);
res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
- memcpy (mono_array_addr (res3, MonoReflectionType*, 0),
- mono_array_addr (res, MonoReflectionType*, 0),
- len1 * sizeof (MonoReflectionType*));
- memcpy (mono_array_addr (res3, MonoReflectionType*, len1),
- mono_array_addr (res2, MonoReflectionType*, 0),
- len2 * sizeof (MonoReflectionType*));
+ mono_array_memcpy_refs (res3, 0, res, 0, len1);
+ mono_array_memcpy_refs (res3, len1, res2, 0, len2);
res = res3;
}
}
/* keep the class in the list */
list = g_list_append (list, klass);
/* and replace Type with NULL */
- mono_array_set (res, gpointer, i, NULL);
+ mono_array_setref (res, i, NULL);
}
}
MonoArray *exl = mono_array_new (domain, mono_defaults.exception_class, length);
for (i = 0, tmp = list; i < length; i++, tmp = tmp->next) {
MonoException *exc = mono_class_get_exception_for_failure (tmp->data);
- mono_array_set (exl, gpointer, i, exc);
+ mono_array_setref (exl, i, exc);
}
g_list_free (list);
list = NULL;
}
}
+static gint32
+ves_icall_System_Reflection_Module_get_MDStreamVersion (MonoReflectionModule *module)
+{
+ MonoImage *image = module->image;
+
+ if (!image)
+ mono_raise_exception (mono_get_exception_not_supported (""));
+
+ return (image->md_version_major << 16) | (image->md_version_minor);
+}
+
static MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
* Returns true on success and zero on failure.
*/
static guint32
-ves_icall_System_CurrentTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
+ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
{
#ifndef PLATFORM_WIN32
MonoDomain *domain = mono_domain_get ();
t = time (NULL);
tt = *localtime (&t);
strftime (tzone, sizeof (tzone), "%Z", &tt);
- mono_array_set ((*names), gpointer, 0, mono_string_new (domain, tzone));
- mono_array_set ((*names), gpointer, 1, mono_string_new (domain, tzone));
+ mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
+ mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
return 1;
}
/* Write data, if we're already in daylight saving, we're done. */
if (is_daylight) {
- mono_array_set ((*names), gpointer, 0, mono_string_new (domain, tzone));
+ mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
mono_array_set ((*data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
return 1;
} else {
- mono_array_set ((*names), gpointer, 1, mono_string_new (domain, tzone));
+ mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
mono_array_set ((*data), gint64, 0, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
is_daylight = 1;
}
if (!is_daylight) {
strftime (tzone, sizeof (tzone), "%Z", &tt);
- mono_array_set ((*names), gpointer, 0, mono_string_new (domain, tzone));
- mono_array_set ((*names), gpointer, 1, mono_string_new (domain, tzone));
+ mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
+ mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
mono_array_set ((*data), gint64, 0, 0);
mono_array_set ((*data), gint64, 1, 0);
mono_array_set ((*data), gint64, 2, (gint64) gmtoff * 10000000L);
for (i = 0; i < 32; ++i)
if (!tz_info.DaylightName [i])
break;
- mono_array_set ((*names), gpointer, 1, mono_string_new_utf16 (domain, tz_info.DaylightName, i));
+ mono_array_setref ((*names), 1, mono_string_new_utf16 (domain, tz_info.DaylightName, i));
for (i = 0; i < 32; ++i)
if (!tz_info.StandardName [i])
break;
- mono_array_set ((*names), gpointer, 0, mono_string_new_utf16 (domain, tz_info.StandardName, i));
+ mono_array_setref ((*names), 0, mono_string_new_utf16 (domain, tz_info.StandardName, i));
if ((year <= 1601) || (year > 30827)) {
/*
res = mono_object_new (domain, mono_defaults.transparent_proxy_class);
tp = (MonoTransparentProxy*) res;
- tp->rp = rp;
+ MONO_OBJECT_SETREF (tp, rp, rp);
type = ((MonoReflectionType *)rp->class_to_proxy)->type;
klass = mono_class_from_mono_type (type);
g_free (buf);
return result;
#else
- gchar *buf;
- int len;
+ gchar buf [256];
MonoString *result;
- MONO_ARCH_SAVE_REGS;
-
- len = 256;
- buf = g_new (gchar, len);
-
- result = NULL;
- if (gethostname (buf, len) == 0)
+ if (gethostname (buf, sizeof (buf)) == 0)
result = mono_string_new (mono_domain_get (), buf);
+ else
+ result = NULL;
- g_free (buf);
return result;
#endif
}
utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
value = g_getenv (utf8_name);
+
g_free (utf8_name);
if (value == 0)
parts = g_strsplit (*e, "=", 2);
if (*parts != 0) {
str = mono_string_new (domain, *parts);
- mono_array_set (names, MonoString *, n, str);
+ mono_array_setref (names, n, str);
}
g_strfreev (parts);
return names;
}
+/*
+ * 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
+
+static void
+ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
+{
+ gchar *utf8_name, *utf8_value;
+
+ MONO_ARCH_SAVE_REGS;
+
+ utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
+
+ if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
+ g_unsetenv (utf8_name);
+ return;
+ }
+
+ utf8_value = mono_string_to_utf8 (value);
+
+ g_setenv (utf8_name, utf8_value, TRUE);
+
+ g_free (utf8_name);
+ g_free (utf8_value);
+}
+
/*
* Returns: the number of milliseconds elapsed since the system started.
*/
u16 = dname;
while (*u16) { u16++; len ++; }
drivestr = mono_string_new_utf16 (domain, dname, len);
- mono_array_set (result, gpointer, ndrives++, drivestr);
+ mono_array_setref (result, ndrives++, drivestr);
while (*dname++);
} while (*dname);
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
+ if (mono_class_is_nullable (klass))
+ /* No arguments -> null */
+ return NULL;
+
return mono_object_new (domain, klass);
}
static MonoString*
ves_icall_Mono_Runtime_GetDisplayName (void)
{
- char *display_name_str = g_strdup_printf ("Mono %s", VERSION);
+ static const char display_name_str [] = "Mono " VERSION;
MonoString *display_name = mono_string_new (mono_domain_get (), display_name_str);
- g_free (display_name_str);
return display_name;
}
-static guchar dbase64 [] = {
+const static guchar
+dbase64 [] = {
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128,
128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
- };
+};
static MonoArray *
base64_to_byte_array (gunichar2 *start, gint ilength, MonoBoolean allowWhitespaceOnly)
last = prev_last = 0;
for (i = 0; i < ilength; i++) {
c = start [i];
- if (isspace (c)) {
- ignored++;
- } else if (c >= sizeof (dbase64)) {
+ if (c >= sizeof (dbase64)) {
exc = mono_exception_from_name_msg (mono_get_corlib (),
"System", "FormatException",
"Invalid character found.");
mono_raise_exception (exc);
+ } else if (isspace (c)) {
+ ignored++;
} else {
prev_last = last;
last = c;
};
static const IcallEntry consoledriver_icalls [] = {
+ {"GetTtySize", ves_icall_System_ConsoleDriver_GetTtySize },
{"InternalKeyAvailable", ves_icall_System_ConsoleDriver_InternalKeyAvailable },
{"Isatty", ves_icall_System_ConsoleDriver_Isatty },
{"SetBreak", ves_icall_System_ConsoleDriver_SetBreak },
};
static const IcallEntry timezone_icalls [] = {
- {"GetTimeZoneData", ves_icall_System_CurrentTimeZone_GetTimeZoneData}
+ {"GetTimeZoneData", ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData}
};
static const IcallEntry datetime_icalls [] = {
};
static const IcallEntry process_icalls [] = {
+ {"CreateProcess_internal(System.Diagnostics.ProcessStartInfo,intptr,intptr,intptr,System.Diagnostics.Process/ProcInfo&)", ves_icall_System_Diagnostics_Process_CreateProcess_internal},
{"ExitCode_internal(intptr)", ves_icall_System_Diagnostics_Process_ExitCode_internal},
{"ExitTime_internal(intptr)", ves_icall_System_Diagnostics_Process_ExitTime_internal},
{"GetModules_internal()", ves_icall_System_Diagnostics_Process_GetModules_internal},
{"ProcessName_internal(intptr)", ves_icall_System_Diagnostics_Process_ProcessName_internal},
{"Process_free_internal(intptr)", ves_icall_System_Diagnostics_Process_Process_free_internal},
{"SetWorkingSet_internal(intptr,int,int,bool)", ves_icall_System_Diagnostics_Process_SetWorkingSet_internal},
+ {"ShellExecuteEx_internal(System.Diagnostics.ProcessStartInfo,System.Diagnostics.Process/ProcInfo&)", ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal},
{"StartTime_internal(intptr)", ves_icall_System_Diagnostics_Process_StartTime_internal},
- {"Start_internal(string,string,string,intptr,intptr,intptr,System.Diagnostics.Process/ProcInfo&)", ves_icall_System_Diagnostics_Process_Start_internal},
{"WaitForExit_internal(intptr,int)", ves_icall_System_Diagnostics_Process_WaitForExit_internal}
};
{"GetMachineConfigPath", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path},
{"GetOSVersionString", ves_icall_System_Environment_GetOSVersionString},
{"GetWindowsFolderPath", ves_icall_System_Environment_GetWindowsFolderPath},
+ {"InternalSetEnvironmentVariable", ves_icall_System_Environment_InternalSetEnvironmentVariable},
{"get_ExitCode", mono_environment_exitcode_get},
{"get_HasShutdownStarted", ves_icall_System_Environment_get_HasShutdownStarted},
{"get_MachineName", ves_icall_System_Environment_get_MachineName},
{"GetTempPath(string&)", ves_icall_System_IO_MonoIO_GetTempPath},
{"Lock(intptr,long,long,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_Lock},
{"MoveFile(string,string,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_MoveFile},
- {"Open(string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,bool,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_Open},
+ {"Open(string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,System.IO.FileOptions,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_Open},
{"Read(intptr,byte[],int,int,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_Read},
{"RemoveDirectory(string,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_RemoveDirectory},
{"Seek(intptr,long,System.IO.SeekOrigin,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_Seek},
/* normal icalls again */
{"get_EntryPoint", ves_icall_System_Reflection_Assembly_get_EntryPoint},
{"get_ManifestModule", ves_icall_System_Reflection_Assembly_get_ManifestModule},
- {"get_MetadataToken", mono_reflection_get_token},
{"get_ReflectionOnly", ves_icall_System_Reflection_Assembly_get_ReflectionOnly},
{"get_code_base", ves_icall_System_Reflection_Assembly_get_code_base},
{"get_global_assembly_cache", ves_icall_System_Reflection_Assembly_get_global_assembly_cache},
{"ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken},
{"ResolveStringToken", ves_icall_System_Reflection_Module_ResolveStringToken},
{"ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken},
+ {"get_MDStreamVersion", ves_icall_System_Reflection_Module_get_MDStreamVersion},
{"get_MetadataToken", mono_reflection_get_token}
};
static const IcallEntry monocmethod_icalls [] = {
{"GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition},
{"InternalInvoke", ves_icall_InternalInvoke},
- {"get_Mono_IsInflatedMethod", ves_icall_MonoMethod_get_Mono_IsInflatedMethod}
};
static const IcallEntry monoeventinfo_icalls [] = {
{"GetFieldOffset", ves_icall_MonoField_GetFieldOffset},
{"GetParentType", ves_icall_MonoField_GetParentType},
{"GetValueInternal", ves_icall_MonoField_GetValueInternal},
- {"Mono_GetGenericFieldDefinition", ves_icall_MonoField_Mono_GetGenericFieldDefinition},
{"SetValueInternal", ves_icall_FieldInfo_SetValueInternal}
};
{"GetGenericArguments", ves_icall_MonoMethod_GetGenericArguments},
{"GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition},
{"InternalInvoke", ves_icall_InternalInvoke},
- {"MakeGenericMethod", mono_reflection_bind_generic_method_parameters},
- {"get_HasGenericParameters", ves_icall_MonoMethod_get_HasGenericParameters},
+ {"MakeGenericMethod_impl", mono_reflection_bind_generic_method_parameters},
+ {"get_IsGenericMethod", ves_icall_MonoMethod_get_IsGenericMethod},
{"get_IsGenericMethodDefinition", ves_icall_MonoMethod_get_IsGenericMethodDefinition},
- {"get_Mono_IsInflatedMethod", ves_icall_MonoMethod_get_Mono_IsInflatedMethod},
{"get_base_definition", ves_icall_MonoMethod_get_base_definition}
};
static const IcallEntry monomethodinfo_icalls [] = {
{"get_method_info", ves_icall_get_method_info},
- {"get_parameter_info", ves_icall_get_parameter_info}
+ {"get_parameter_info", ves_icall_get_parameter_info},
+ {"get_retval_marshal", ves_icall_System_MonoMethodInfo_get_retval_marshal}
};
static const IcallEntry monopropertyinfo_icalls [] = {
static const IcallEntry object_icalls [] = {
{"GetType", ves_icall_System_Object_GetType},
- {"InternalGetHashCode", ves_icall_System_Object_GetHashCode},
+ {"InternalGetHashCode", mono_object_hash},
{"MemberwiseClone", ves_icall_System_Object_MemberwiseClone},
{"obj_address", ves_icall_System_Object_obj_address}
};
};
static const IcallEntry interlocked_icalls [] = {
- {"Add(int&,int)", ves_icall_System_Threading_Interlocked_Add_Int},
+ {"Add(int&,int)", ves_icall_System_Threading_Interlocked_Add_Int},
{"Add(long&,long)", ves_icall_System_Threading_Interlocked_Add_Long},
- {"CompareExchange(double&,double,double)", ves_icall_System_Threading_Interlocked_CompareExchange_Double},
+ {"CompareExchange(T&,T,T)", ves_icall_System_Threading_Interlocked_CompareExchange_T},
+ {"CompareExchange(double&,double,double)", ves_icall_System_Threading_Interlocked_CompareExchange_Double},
{"CompareExchange(int&,int,int)", ves_icall_System_Threading_Interlocked_CompareExchange_Int},
{"CompareExchange(intptr&,intptr,intptr)", ves_icall_System_Threading_Interlocked_CompareExchange_Object},
{"CompareExchange(long&,long,long)", ves_icall_System_Threading_Interlocked_CompareExchange_Long},
{"CompareExchange(single&,single,single)", ves_icall_System_Threading_Interlocked_CompareExchange_Single},
{"Decrement(int&)", ves_icall_System_Threading_Interlocked_Decrement_Int},
{"Decrement(long&)", ves_icall_System_Threading_Interlocked_Decrement_Long},
+ {"Exchange(T&,T)", ves_icall_System_Threading_Interlocked_Exchange_T},
{"Exchange(double&,double)", ves_icall_System_Threading_Interlocked_Exchange_Double},
{"Exchange(int&,int)", ves_icall_System_Threading_Interlocked_Exchange_Int},
{"Exchange(intptr&,intptr)", ves_icall_System_Threading_Interlocked_Exchange_Object},
static const IcallEntry mutex_icalls [] = {
{"CreateMutex_internal(bool,string,bool&)", ves_icall_System_Threading_Mutex_CreateMutex_internal},
+ {"OpenMutex_internal(string,System.Security.AccessControl.MutexRights,System.IO.MonoIOError&)", ves_icall_System_Threading_Mutex_OpenMutex_internal},
{"ReleaseMutex_internal(intptr)", ves_icall_System_Threading_Mutex_ReleaseMutex_internal}
};
+static const IcallEntry semaphore_icalls [] = {
+ {"CreateSemaphore_internal(int,int,string,bool&)", ves_icall_System_Threading_Semaphore_CreateSemaphore_internal},
+ {"OpenSemaphore_internal(string,System.Security.AccessControl.SemaphoreRights,System.IO.MonoIOError&)", ves_icall_System_Threading_Semaphore_OpenSemaphore_internal},
+ {"ReleaseSemaphore_internal(intptr,int,bool&)", ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal}
+};
+
static const IcallEntry nativeevents_icalls [] = {
{"CloseEvent_internal", ves_icall_System_Threading_Events_CloseEvent_internal},
- {"CreateEvent_internal", ves_icall_System_Threading_Events_CreateEvent_internal},
+ {"CreateEvent_internal(bool,bool,string,bool&)", ves_icall_System_Threading_Events_CreateEvent_internal},
+ {"OpenEvent_internal(string,System.Security.AccessControl.EventWaitHandleRights,System.IO.MonoIOError&)", ves_icall_System_Threading_Events_OpenEvent_internal},
{"ResetEvent_internal", ves_icall_System_Threading_Events_ResetEvent_internal},
{"SetEvent_internal", ves_icall_System_Threading_Events_SetEvent_internal}
};
{"Abort_internal(object)", ves_icall_System_Threading_Thread_Abort},
{"ClrState", ves_icall_System_Threading_Thread_ClrState},
{"CurrentThread_internal", mono_thread_current},
+ {"FreeLocalSlotValues", mono_thread_free_local_slot_values},
{"GetCachedCurrentCulture", ves_icall_System_Threading_Thread_GetCachedCurrentCulture},
{"GetCachedCurrentUICulture", ves_icall_System_Threading_Thread_GetCachedCurrentUICulture},
{"GetDomainID", ves_icall_System_Threading_Thread_GetDomainID},
{"System.Configuration.DefaultConfig", defaultconf_icalls, G_N_ELEMENTS (defaultconf_icalls)},
{"System.ConsoleDriver", consoledriver_icalls, G_N_ELEMENTS (consoledriver_icalls)},
{"System.Convert", convert_icalls, G_N_ELEMENTS (convert_icalls)},
- {"System.CurrentTimeZone", timezone_icalls, G_N_ELEMENTS (timezone_icalls)},
+ {"System.CurrentSystemTimeZone", timezone_icalls, G_N_ELEMENTS (timezone_icalls)},
{"System.DateTime", datetime_icalls, G_N_ELEMENTS (datetime_icalls)},
#ifndef DISABLE_DECIMAL
{"System.Decimal", decimal_icalls, G_N_ELEMENTS (decimal_icalls)},
{"System.Threading.Monitor", monitor_icalls, G_N_ELEMENTS (monitor_icalls)},
{"System.Threading.Mutex", mutex_icalls, G_N_ELEMENTS (mutex_icalls)},
{"System.Threading.NativeEventCalls", nativeevents_icalls, G_N_ELEMENTS (nativeevents_icalls)},
+ {"System.Threading.Semaphore", semaphore_icalls, G_N_ELEMENTS (semaphore_icalls)},
{"System.Threading.Thread", thread_icalls, G_N_ELEMENTS (thread_icalls)},
{"System.Threading.ThreadPool", threadpool_icalls, G_N_ELEMENTS (threadpool_icalls)},
{"System.Threading.WaitHandle", waithandle_icalls, G_N_ELEMENTS (waithandle_icalls)},
g_assert (method != NULL);
+ if (method->is_inflated)
+ method = ((MonoMethodInflated *) method)->declaring;
+
if (method->klass->nested_in) {
int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in);
if (!pos)
mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
{
mono_loader_lock ();
- g_hash_table_insert (jit_icall_hash_addr, (gpointer)info->wrapper, info);
+ g_hash_table_insert (jit_icall_hash_addr, (gpointer)wrapper, info);
mono_loader_unlock ();
}
g_assert_not_reached ();
}
- info = g_new (MonoJitICallInfo, 1);
+ info = g_new0 (MonoJitICallInfo, 1);
info->name = name;
info->func = func;
projects / mono.git / blobdiff