return TRUE;
}
+static MonoClass *
+mono_class_get_throw (MonoImage *image, guint32 type_token)
+{
+ MonoClass *class = mono_class_get (image, type_token);
+ MonoLoaderError *error;
+ MonoException *ex;
+
+ if (class != NULL){
+ if (class->exception_type) {
+ MonoException *exc = mono_class_get_exception_for_failure (class);
+ g_assert (exc);
+ mono_raise_exception (exc);
+ }
+ return class;
+ }
+ error = mono_loader_get_last_error ();
+ g_assert (error != NULL);
+
+ ex = mono_loader_error_prepare_exception (error);
+ mono_raise_exception (ex);
+ return NULL;
+}
+
static void
ves_icall_System_Double_AssertEndianity (double *value)
{
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;
}
return mono_object_clone (this);
}
-#define MONO_OBJECT_ALIGNMENT_SHIFT 3
-
-/*
- * Return hashcode based on object address. This function will need to be
- * smarter in the presence of a moving garbage collector, which will cache
- * the address hash before relocating the object.
- *
- * Wang's address-based hash function:
- * http://www.concentric.net/~Ttwang/tech/addrhash.htm
- */
-static gint32
-ves_icall_System_Object_GetHashCode (MonoObject *this)
-{
- MONO_ARCH_SAVE_REGS;
-
- return (GPOINTER_TO_UINT (this) >> MONO_OBJECT_ALIGNMENT_SHIFT) * 2654435761u;
-}
-
static gint32
ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fields)
{
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_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)
{
/* Convert the Nullable structure into a boxed vtype */
if (is_static)
- buf = (char*)vtable->data + cf->offset;
+ buf = (guint8*)vtable->data + cf->offset;
else
- buf = (char*)obj + cf->offset;
+ buf = (guint8*)obj + cf->offset;
return mono_nullable_box (buf, nklass);
}
mono_nullable_init (buf, value, nklass);
- v = buf;
+ v = (gchar*)buf;
}
else
if (gclass->container_class->valuetype && (v != NULL))
}
}
-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)
{
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));
}
}
MonoClass *class = mono_class_from_mono_type (type->type);
MonoClass *parent;
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);
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);
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 ++;
}
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) {
- MonoType *t = inst->type_argv [i];
- /* Ensure that our dummy null-owner types don't leak into userspace. */
- g_assert ((t->type != MONO_TYPE_VAR && t->type != MONO_TYPE_MVAR) || t->data.generic_param->owner);
- mono_array_set (res, gpointer, i, mono_type_get_object (mono_object_domain (type), t));
- }
+ 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;
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*
it, gclass->generic_class.generic_class.context);
iface = mono_type_get_object (domain, it);
- mono_array_set (res, gpointer, i, iface);
+ mono_array_setref (res, i, iface);
}
return res;
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;
}
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;
}
static gboolean
-ves_icall_MonoMethod_get_Mono_IsInflatedMethod (MonoReflectionMethod *method)
+ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
{
MONO_ARCH_SAVE_REGS;
- return method->method->is_inflated;
+ return !method->method->is_inflated &&
+ (mono_method_signature (method->method)->generic_param_count != 0);
}
static MonoArray*
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];
- /* Ensure that our dummy null-owner types don't leak into userspace. */
- g_assert ((t->type != MONO_TYPE_VAR && t->type != MONO_TYPE_MVAR) || t->data.generic_param->owner);
- 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;
}
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));
}
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++;
}
}
switch (type) {
case MONO_TYPE_U1:
case MONO_TYPE_I1: {
- guint8 *p = mem;
+ guint8 *p = (guint8*)mem;
*p = value;
break;
}
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));
+ 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);
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);
ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
- GSList *l = NULL, *tmp;
MonoClass *startklass, *klass, *refklass;
MonoArray *res;
MonoObject *member;
domain = ((MonoObject *)type)->vtable->domain;
if (type->type->byref)
- return mono_array_new (domain, mono_defaults.method_info_class, 0);
+ return mono_array_new (domain, mono_defaults.field_info_class, 0);
klass = startklass = mono_class_from_mono_type (type->type);
refklass = mono_class_from_mono_type (reftype->type);
+ i = 0;
+ len = 2;
+ res = mono_array_new (domain, mono_defaults.field_info_class, len);
handle_parent:
iter = NULL;
while ((field = mono_class_get_fields (klass, &iter))) {
if (!match)
continue;
member = (MonoObject*)mono_field_get_object (domain, refklass, field);
- l = g_slist_prepend (l, member);
+ if (i >= len) {
+ MonoArray *new_res = mono_array_new (domain, mono_defaults.field_info_class, len * 2);
+ mono_array_memcpy_refs (new_res, 0, res, 0, len);
+ len *= 2;
+ res = new_res;
+ }
+ mono_array_setref (res, i, member);
+ ++i;
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
- len = g_slist_length (l);
- res = mono_array_new (domain, mono_defaults.field_info_class, len);
- i = 0;
- tmp = l = g_slist_reverse (l);
- for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
- g_slist_free (l);
+ if (i != len) {
+ MonoArray *new_res = mono_array_new (domain, mono_defaults.field_info_class, i);
+ mono_array_memcpy_refs (new_res, 0, res, 0, i);
+ res = new_res;
+ /*
+ * Better solution for the new GC.
+ * res->max_length = i;
+ */
+ }
return res;
}
ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
MonoDomain *domain;
- GSList *l = NULL, *tmp;
MonoClass *startklass, *klass, *refklass;
MonoArray *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;
mono_class_setup_vtable (klass);
- if (klass->vtable_size >= sizeof (method_slots_default) * 8) {
- method_slots = g_new0 (guint32, klass->vtable_size / 32 + 1);
+ 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));
}
+ i = 0;
+ len = 1;
+ res = mono_array_new (domain, mono_defaults.method_info_class, len);
handle_parent:
mono_class_setup_vtable (klass);
iter = NULL;
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);
member = (MonoObject*)mono_method_get_object (domain, method, refklass);
- l = g_slist_prepend (l, member);
- len++;
+ if (i >= len) {
+ MonoArray *new_res = mono_array_new (domain, mono_defaults.method_info_class, len * 2);
+ mono_array_memcpy_refs (new_res, 0, res, 0, len);
+ len *= 2;
+ res = new_res;
+ }
+ mono_array_setref (res, i, member);
+ ++i;
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
g_free (mname);
- res = mono_array_new (domain, mono_defaults.method_info_class, len);
- i = 0;
-
- tmp = l = g_slist_reverse (l);
-
- for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
- g_slist_free (l);
if (method_slots != method_slots_default)
g_free (method_slots);
+ if (i != len) {
+ MonoArray *new_res = mono_array_new (domain, mono_defaults.method_info_class, i);
+ mono_array_memcpy_refs (new_res, 0, res, 0, i);
+ res = new_res;
+ /*
+ * Better solution for the new GC.
+ * res->max_length = i;
+ */
+ }
return res;
}
ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
- GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_ConstructorInfo;
MonoClass *startklass, *klass, *refklass;
MonoArray *res;
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");
+
+ i = 0;
+ len = 2;
+ res = mono_array_new (domain, System_Reflection_ConstructorInfo, len);
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
match = 0;
if (!match)
continue;
member = (MonoObject*)mono_method_get_object (domain, method, refklass);
-
- l = g_slist_prepend (l, member);
+
+ if (i >= len) {
+ MonoArray *new_res = mono_array_new (domain, System_Reflection_ConstructorInfo, len * 2);
+ mono_array_memcpy_refs (new_res, 0, res, 0, len);
+ len *= 2;
+ res = new_res;
+ }
+ mono_array_setref (res, i, member);
+ ++i;
+ }
+ if (i != len) {
+ MonoArray *new_res = mono_array_new (domain, System_Reflection_ConstructorInfo, i);
+ mono_array_memcpy_refs (new_res, 0, res, 0, i);
+ res = new_res;
+ /*
+ * Better solution for the new GC.
+ * res->max_length = i;
+ */
}
- len = g_slist_length (l);
- if (!System_Reflection_ConstructorInfo)
- System_Reflection_ConstructorInfo = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
- res = mono_array_new (domain, System_Reflection_ConstructorInfo, len);
- i = 0;
- tmp = l = g_slist_reverse (l);
- for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
- g_slist_free (l);
return res;
}
ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
{
MonoDomain *domain;
- GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_PropertyInfo;
MonoClass *startklass, *klass;
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));
}
+ i = 0;
+ len = 2;
+ res = mono_array_new (domain, System_Reflection_PropertyInfo, len);
handle_parent:
mono_class_setup_vtable (klass);
iter = NULL;
method_slots [prop->set->slot >> 5] |= 1 << (prop->set->slot & 0x1f);
}
- l = g_slist_prepend (l, mono_property_get_object (domain, startklass, prop));
- len++;
+ if (i >= len) {
+ MonoArray *new_res = mono_array_new (domain, System_Reflection_PropertyInfo, len * 2);
+ mono_array_memcpy_refs (new_res, 0, res, 0, len);
+ len *= 2;
+ res = new_res;
+ }
+ mono_array_setref (res, i, mono_property_get_object (domain, startklass, prop));
+ ++i;
}
if ((!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)))
goto handle_parent;
g_free (propname);
- res = mono_array_new (domain, System_Reflection_PropertyInfo, len);
- i = 0;
-
- tmp = l = g_slist_reverse (l);
-
- for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
- g_slist_free (l);
if (method_slots != method_slots_default)
g_free (method_slots);
+ if (i != len) {
+ MonoArray *new_res = mono_array_new (domain, System_Reflection_PropertyInfo, i);
+ mono_array_memcpy_refs (new_res, 0, res, 0, i);
+ res = new_res;
+ /*
+ * Better solution for the new GC.
+ * res->max_length = i;
+ */
+ }
return res;
}
ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
{
MonoDomain *domain;
- GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_EventInfo;
MonoClass *startklass, *klass;
MonoArray *res;
return mono_array_new (domain, System_Reflection_EventInfo, 0);
klass = startklass = mono_class_from_mono_type (type->type);
+ i = 0;
+ len = 2;
+ res = mono_array_new (domain, System_Reflection_EventInfo, len);
handle_parent:
iter = NULL;
while ((event = mono_class_get_events (klass, &iter))) {
if (!match)
continue;
match = 0;
- l = g_slist_prepend (l, mono_event_get_object (domain, startklass, event));
+ if (i >= len) {
+ MonoArray *new_res = mono_array_new (domain, System_Reflection_EventInfo, len * 2);
+ mono_array_memcpy_refs (new_res, 0, res, 0, len);
+ len *= 2;
+ res = new_res;
+ }
+ mono_array_setref (res, i, mono_event_get_object (domain, startklass, event));
+ ++i;
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
- len = g_slist_length (l);
- res = mono_array_new (domain, System_Reflection_EventInfo, len);
- i = 0;
-
- tmp = l = g_slist_reverse (l);
-
- for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
- g_slist_free (l);
+ if (i != len) {
+ MonoArray *new_res = mono_array_new (domain, System_Reflection_EventInfo, i);
+ mono_array_memcpy_refs (new_res, 0, res, 0, i);
+ res = new_res;
+ /*
+ * Better solution for the new GC.
+ * res->max_length = i;
+ */
+ }
return res;
}
ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags)
{
MonoDomain *domain;
- GSList *l = NULL, *tmp;
GList *tmpn;
MonoClass *startklass, *klass;
MonoArray *res;
return mono_array_new (domain, mono_defaults.monotype_class, 0);
klass = startklass = mono_class_from_mono_type (type->type);
+ i = 0;
+ len = 1;
+ res = mono_array_new (domain, mono_defaults.monotype_class, len);
for (tmpn = klass->nested_classes; tmpn; tmpn = tmpn->next) {
match = 0;
nested = tmpn->data;
if (!match)
continue;
member = (MonoObject*)mono_type_get_object (domain, &nested->byval_arg);
- l = g_slist_prepend (l, member);
+ if (i >= len) {
+ MonoArray *new_res = mono_array_new (domain, mono_defaults.monotype_class, len * 2);
+ mono_array_memcpy_refs (new_res, 0, res, 0, len);
+ len *= 2;
+ res = new_res;
+ }
+ mono_array_setref (res, i, member);
+ ++i;
+ }
+ if (i != len) {
+ MonoArray *new_res = mono_array_new (domain, mono_defaults.monotype_class, i);
+ mono_array_memcpy_refs (new_res, 0, res, 0, i);
+ res = new_res;
+ /*
+ * Better solution for the new GC.
+ * res->max_length = i;
+ */
}
- len = g_slist_length (l);
- res = mono_array_new (domain, mono_defaults.monotype_class, len);
- i = 0;
- tmp = l = g_slist_reverse (l);
- for (; tmp; tmp = tmp->next, ++i)
- mono_array_set (res, gpointer, i, tmp->data);
- g_slist_free (l);
return res;
}
MONO_ARCH_SAVE_REGS;
absolute = g_build_filename (mass->basedir, mass->image->module_name, NULL);
+#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 {
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);
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;
}
static MonoArray*
-mono_module_get_types (MonoDomain *domain, MonoImage *image,
- MonoBoolean exportedOnly)
+mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoBoolean exportedOnly)
{
MonoArray *res;
MonoClass *klass;
attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS);
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));
+ klass = mono_class_get_throw (image, (i + 1) | MONO_TOKEN_TYPE_DEF);
+ if (mono_loader_get_last_error ())
+ mono_loader_clear_error ();
+ mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg));
count++;
}
}
MonoImage *image = NULL;
MonoTableInfo *table = NULL;
MonoDomain *domain;
- int i;
+ GList *list = NULL;
+ int i, len;
MONO_ARCH_SAVE_REGS;
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;
}
}
}
}
- if (mono_is_security_manager_active ()) {
- /* the ReflectionTypeLoadException must have all the types (Types property),
- * NULL replacing types which throws an exception. The LoaderException must
- * contains all exceptions for NULL items.
- */
+ /* the ReflectionTypeLoadException must have all the types (Types property),
+ * NULL replacing types which throws an exception. The LoaderException must
+ * contain all exceptions for NULL items.
+ */
- guint32 len = mono_array_length (res);
- GList *list = NULL;
-
- for (i = 0; i < len; i++) {
- MonoReflectionType *t = mono_array_get (res, gpointer, i);
- MonoClass *klass = mono_type_get_class (t->type);
- if ((klass != NULL) && klass->exception_type) {
- /* keep the class in the list */
- list = g_list_append (list, klass);
- /* and replace Type with NULL */
- mono_array_set (res, gpointer, i, NULL);
- }
+ len = mono_array_length (res);
+
+ for (i = 0; i < len; i++) {
+ MonoReflectionType *t = mono_array_get (res, gpointer, i);
+ MonoClass *klass = mono_type_get_class (t->type);
+ if ((klass != NULL) && klass->exception_type) {
+ /* keep the class in the list */
+ list = g_list_append (list, klass);
+ /* and replace Type with NULL */
+ mono_array_setref (res, i, NULL);
}
+ }
- if (list) {
- GList *tmp = NULL;
- MonoException *exc = NULL;
- int length = g_list_length (list);
+ if (list) {
+ GList *tmp = NULL;
+ MonoException *exc = NULL;
+ MonoArray *exl = NULL;
+ int length = g_list_length (list);
- 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);
- }
- g_list_free (list);
- list = NULL;
+ mono_loader_clear_error ();
- exc = mono_get_exception_reflection_type_load (res, exl);
- mono_raise_exception (exc);
+ 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_setref (exl, i, exc);
}
+ g_list_free (list);
+ list = NULL;
+
+ exc = mono_get_exception_reflection_type_load (res, exl);
+ mono_raise_exception (exc);
}
return res;
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
}
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)
+{
+#ifdef PLATFORM_WIN32
+ gunichar2 *utf16_name, *utf16_value;
+#else
+ gchar *utf8_name, *utf8_value;
+#endif
+
+ MONO_ARCH_SAVE_REGS;
+
+#ifdef PLATFORM_WIN32
+ utf16_name = mono_string_to_utf16 (name);
+ if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
+ SetEnvironmentVariable (utf16_name, NULL);
+ g_free (utf16_name);
+ return;
+ }
+
+ utf16_value = mono_string_to_utf16 (value);
+
+ SetEnvironmentVariable (utf16_name, utf16_value);
+
+ g_free (utf16_name);
+ g_free (utf16_value);
+#else
+ 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);
+ g_free (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);
+#endif
+}
+
/*
* 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);
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)
{"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},
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}
};
{"GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition},
{"InternalInvoke", ves_icall_InternalInvoke},
{"MakeGenericMethod_impl", mono_reflection_bind_generic_method_parameters},
- {"get_HasGenericParameters", ves_icall_MonoMethod_get_HasGenericParameters},
- {"get_Mono_IsInflatedMethod", ves_icall_MonoMethod_get_Mono_IsInflatedMethod},
+ {"get_IsGenericMethod", ves_icall_MonoMethod_get_IsGenericMethod},
+ {"get_IsGenericMethodDefinition", ves_icall_MonoMethod_get_IsGenericMethodDefinition},
{"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}
};
{"AllocCoTaskMem", ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem},
{"AllocHGlobal", ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal},
{"DestroyStructure", ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure},
+ {"FreeBSTR", ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR},
{"FreeCoTaskMem", ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem},
{"FreeHGlobal", ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal},
+ {"GetComSlotForMethodInfoInternal", ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal},
{"GetDelegateForFunctionPointerInternal", ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal},
{"GetFunctionPointerForDelegateInternal", mono_delegate_to_ftnptr},
{"GetLastWin32Error", ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error},
{"ReadInt64", ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64},
{"ReadIntPtr", ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr},
{"SizeOf", ves_icall_System_Runtime_InteropServices_Marshal_SizeOf},
+ {"StringToBSTR", ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR},
{"StringToHGlobalAnsi", ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi},
{"StringToHGlobalAuto", ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi},
{"StringToHGlobalUni", ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni},
{"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},
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;