#include <mono/metadata/char-conversions.h>
#include <mono/metadata/security.h>
#include <mono/metadata/mono-config.h>
+#include <mono/metadata/cil-coff.h>
#include <mono/io-layer/io-layer.h>
#include <mono/utils/strtod.h>
#include <mono/utils/monobitset.h>
return this->bounds [dimension].lower_bound;
}
+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);
+}
+
static gboolean
ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
{
MonoType *type = NULL;
MonoAssembly *assembly;
MonoTypeNameParse info;
+ char *temp_str = g_strdup (str);
+ gboolean type_resolve = FALSE;
MONO_ARCH_SAVE_REGS;
- if (!mono_reflection_parse_type (str, &info)) {
+ /* mono_reflection_parse_type() mangles the string */
+ if (!mono_reflection_parse_type (temp_str, &info)) {
g_list_free (info.modifiers);
g_list_free (info.nested);
+ g_free (temp_str);
return NULL;
}
}
if (assembly)
- type = mono_reflection_get_type (assembly->image, &info, ignoreCase);
+ type = mono_reflection_get_type (assembly->image, &info, ignoreCase, &type_resolve);
if (!info.assembly.name && !type) /* try mscorlib */
- type = mono_reflection_get_type (NULL, &info, ignoreCase);
+ type = mono_reflection_get_type (NULL, &info, ignoreCase, &type_resolve);
g_list_free (info.modifiers);
g_list_free (info.nested);
+ g_free (temp_str);
+
if (!type)
return NULL;
return mono_type_get_object (mono_domain_get (), type);
}
+#ifdef UNUSED
MonoReflectionType *
mono_type_get (const char *str)
{
g_free (copy);
return type;
}
+#endif
static MonoReflectionType*
ves_icall_type_from_name (MonoString *name,
return klass->flags;
}
+static MonoReflectionMarshal*
+ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *field)
+{
+ MonoClass *klass = field->field->parent;
+ MonoMarshalType *info;
+ int i;
+
+ if (klass->generic_container ||
+ (klass->generic_inst && klass->generic_inst->is_open))
+ return NULL;
+
+ info = mono_marshal_load_type_info (klass);
+
+ for (i = 0; i < info->num_fields; ++i) {
+ if (info->fields [i].field == field->field) {
+ if (!info->fields [i].mspec)
+ return NULL;
+ else
+ return mono_reflection_marshal_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
+ }
+ }
+
+ return NULL;
+}
+
static MonoReflectionField*
ves_icall_System_Reflection_FieldInfo_internal_from_handle (MonoClassField *handle)
{
return mono_param_get_objects (domain, method);
}
+static gint32
+ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
+{
+ return field->field->offset - sizeof (MonoObject);
+}
+
static MonoReflectionType*
ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
{
info->add_method = event->event->add ? mono_method_get_object (domain, event->event->add, NULL): NULL;
info->remove_method = event->event->remove ? mono_method_get_object (domain, event->event->remove, NULL): NULL;
info->raise_method = event->event->raise ? mono_method_get_object (domain, event->event->raise, NULL): NULL;
+
+ if (event->event->other) {
+ int i, n = 0;
+ while (event->event->other [n])
+ n++;
+ 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));
+ }
}
static MonoArray*
{
MonoDomain *domain = mono_object_domain (type);
MonoArray *intf;
- int ninterf, i;
+ GPtrArray *ifaces = 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);
return mono_array_new (domain, mono_defaults.monotype_class, 0);
}
- ninterf = 0;
for (parent = class; parent; parent = parent->parent) {
- for (i = 0; i < parent->interface_count; ++i) {
- if (mono_bitset_test (slots, parent->interfaces [i]->interface_id))
- continue;
+ GPtrArray *tmp_ifaces = mono_class_get_implemented_interfaces (parent);
+ if (tmp_ifaces) {
+ for (i = 0; i < tmp_ifaces->len; ++i) {
+ MonoClass *ic = g_ptr_array_index (tmp_ifaces, i);
+
+ if (mono_bitset_test (slots, ic->interface_id))
+ continue;
- mono_bitset_set (slots, parent->interfaces [i]->interface_id);
- ++ninterf;
+ mono_bitset_set (slots, ic->interface_id);
+ if (ifaces == NULL)
+ ifaces = g_ptr_array_new ();
+ g_ptr_array_add (ifaces, ic);
+ }
+ g_ptr_array_free (tmp_ifaces, TRUE);
}
}
+ mono_bitset_free (slots);
- intf = mono_array_new (domain, mono_defaults.monotype_class, ninterf);
- ninterf = 0;
- for (parent = class; parent; parent = parent->parent) {
- for (i = 0; i < parent->interface_count; ++i) {
- if (!mono_bitset_test (slots, parent->interfaces [i]->interface_id))
- continue;
-
- mono_bitset_clear (slots, parent->interfaces [i]->interface_id);
- mono_array_set (intf, gpointer, ninterf,
- mono_type_get_object (domain, &parent->interfaces [i]->byval_arg));
- ++ninterf;
- }
+ if (!ifaces)
+ return mono_array_new (domain, mono_defaults.monotype_class, 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);
+
+ mono_array_set (intf, gpointer, i,
+ mono_type_get_object (domain, &ic->byval_arg));
}
+ g_ptr_array_free (ifaces, TRUE);
- mono_bitset_free (slots);
return intf;
}
}
}
+static void
+ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
+{
+ MonoClass *klass = mono_class_from_mono_type (type->type);
+
+ g_assert (!klass->image->dynamic);
+
+ mono_metadata_packing_from_typedef (klass->image, klass->type_token, packing, size);
+}
+
static MonoReflectionType*
ves_icall_MonoType_GetElementType (MonoReflectionType *type)
{
MONO_ARCH_SAVE_REGS;
+ // GelElementType should only return a type for:
+ // Array Pointer PassedByRef
if (type->type->byref)
return mono_type_get_object (mono_object_domain (type), &class->byval_arg);
if (class->enumtype && class->enum_basetype) /* types that are modifierd typebuilkders may not have enum_basetype set */
return mono_type_get_object (mono_object_domain (type), class->enum_basetype);
- else if (class->element_class)
+ else if (class->element_class && MONO_CLASS_IS_ARRAY (class))
+ return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
+ else if (class->element_class && type->type->type == MONO_TYPE_PTR)
return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
else
return NULL;
while (class->nested_in)
class = class->nested_in;
- return mono_string_new (domain, class->name_space);
+ if (class->name_space [0] == '\0')
+ return NULL;
+ else
+ return mono_string_new (domain, class->name_space);
}
static gint32
if (type->type->byref) {
res = mono_array_new (mono_object_domain (type), mono_defaults.monotype_class, 0);
- } else if (klass->gen_params) {
- res = mono_array_new (mono_object_domain (type), mono_defaults.monotype_class, klass->num_gen_params);
- for (i = 0; i < klass->num_gen_params; ++i) {
- pklass = mono_class_from_generic_parameter (&klass->gen_params [i], klass->image, FALSE);
+ } else if (klass->generic_container) {
+ MonoGenericContainer *container = klass->generic_container;
+ 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));
}
} else if (klass->generic_inst) {
return FALSE;
klass = mono_class_from_mono_type (type->type);
- return klass->gen_params != NULL;
+ return klass->generic_container != NULL;
}
static MonoReflectionType*
if (type->type->byref)
return NULL;
klass = mono_class_from_mono_type (type->type);
- if (klass->gen_params) {
+ if (klass->generic_container) {
return type; /* check this one */
}
if (klass->generic_inst) {
return -1;
}
+static GenericParameterAttributes
+ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
+{
+ MONO_ARCH_SAVE_REGS;
+ return type->type->data.generic_param->flags;
+}
+
+static MonoArray *
+ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
+{
+ MonoGenericParam *param;
+ MonoDomain *domain;
+ MonoClass **ptr;
+ MonoArray *res;
+ int i, count;
+
+ MONO_ARCH_SAVE_REGS;
+
+ domain = mono_object_domain (type);
+ param = type->type->data.generic_param;
+ for (count = 0, ptr = param->constraints; ptr && *ptr; ptr++, count++)
+ ;
+
+ 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));
+
+
+ return res;
+}
+
static MonoBoolean
ves_icall_MonoType_get_HasGenericArguments (MonoReflectionType *type)
{
if (type->type->byref)
return FALSE;
klass = mono_class_from_mono_type (type->type);
- if (klass->gen_params || klass->generic_inst)
+ if (klass->generic_container || klass->generic_inst)
return TRUE;
return FALSE;
}
return NULL;
klass = mono_class_from_mono_type (ginst->parent);
- if (!klass->generic_inst && !klass->gen_params)
+ if (!klass->generic_inst && !klass->generic_container)
return NULL;
return mono_type_get_object (mono_object_domain (type), ginst->parent);
return mono_method_get_object (mono_object_domain (type), method, klass);
}
+static MonoReflectionDllImportAttribute*
+ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method)
+{
+ static MonoClass *DllImportAttributeClass = NULL;
+ MonoDomain *domain = mono_domain_get ();
+ MonoReflectionDllImportAttribute *attr;
+ MonoImage *image = method->klass->image;
+ MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method;
+ MonoTableInfo *tables = image->tables;
+ MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
+ MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
+ guint32 im_cols [MONO_IMPLMAP_SIZE];
+ guint32 scope_token;
+ const char *import = NULL;
+ const char *scope = NULL;
+ guint32 flags;
+
+ if (!method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)
+ return NULL;
+
+ if (!DllImportAttributeClass) {
+ DllImportAttributeClass =
+ mono_class_from_name (mono_defaults.corlib,
+ "System.Runtime.InteropServices", "DllImportAttribute");
+ g_assert (DllImportAttributeClass);
+ }
+
+ if (method->klass->image->dynamic) {
+ MonoReflectionMethodAux *method_aux =
+ mono_g_hash_table_lookup (
+ ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
+ if (method_aux) {
+ import = method_aux->dllentry;
+ scope = method_aux->dll;
+ }
+ }
+ else {
+ if (piinfo->implmap_idx) {
+ mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
+
+ piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
+ import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
+ scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
+ scope = mono_metadata_string_heap (image, scope_token);
+ }
+ }
+ flags = piinfo->piflags;
+
+ attr = (MonoReflectionDllImportAttribute*)mono_object_new (domain, DllImportAttributeClass);
+
+ attr->dll = mono_string_new (domain, scope);
+ attr->entry_point = mono_string_new (domain, import);
+ attr->call_conv = (flags & 0x700) >> 8;
+ attr->charset = ((flags & 0x6) >> 1) + 1;
+ if (attr->charset == 1)
+ attr->charset = 2;
+ attr->exact_spelling = (flags & 0x1) != 0;
+ attr->set_last_error = (flags & 0x4) != 0;
+ attr->best_fit_mapping = (flags & 0x10) != 0;
+ attr->throw_on_unmappable = (flags & 0x1000) != 0;
+ attr->preserve_sig = FALSE;
+
+ return attr;
+}
+
static MonoReflectionMethod *
ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
{
res = mono_array_new (domain, mono_defaults.monotype_class, count);
for (i = 0; i < count; i++) {
- MonoGenericParam *param = &mn->gen_params [i];
+ MonoGenericParam *param = &mn->generic_container->type_params [i];
MonoClass *pklass = mono_class_from_generic_parameter (
param, method->method->klass->image, TRUE);
mono_array_set (res, gpointer, i,
if (pcount != m->signature->param_count)
mono_raise_exception (mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException"));
+ if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor"))
+ mono_raise_exception (mono_exception_from_name_msg (mono_defaults.corlib, "System", "MethodAccessException", "Cannot invoke constructor of an abstract class."));
+
if (m->klass->rank && !strcmp (m->name, ".ctor")) {
int i;
guint32 *lengths;
if (!strcmp (m->name, "FieldGetter")) {
MonoClass *k = this->vtable->klass;
+
+ /* If this is a proxy, then it must be a CBO */
+ if (k == mono_defaults.transparent_proxy_class) {
+ MonoTransparentProxy *tp = (MonoTransparentProxy*) this;
+ this = tp->rp->unwrapped_server;
+ g_assert (this);
+ k = this->vtable->klass;
+ }
+
MonoString *name = mono_array_get (params, MonoString *, 1);
char *str;
} else if (!strcmp (m->name, "FieldSetter")) {
MonoClass *k = this->vtable->klass;
+
+ /* If this is a proxy, then it must be a CBO */
+ if (k == mono_defaults.transparent_proxy_class) {
+ MonoTransparentProxy *tp = (MonoTransparentProxy*) this;
+ this = tp->rp->unwrapped_server;
+ g_assert (this);
+ k = this->vtable->klass;
+ }
+
MonoString *name = mono_array_get (params, MonoString *, 1);
int size, align;
char *str;
out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count);
- /* fixme: handle constructors? */
+ /* handle constructors only for objects already allocated */
if (!strcmp (method->method->name, ".ctor"))
- g_assert_not_reached ();
+ g_assert (this);
/* This can be called only on MBR objects, so no need to unbox for valuetypes. */
g_assert (!method->method->klass->valuetype);
gchar *str;
MonoType *type = NULL;
MonoTypeNameParse info;
+ gboolean type_resolve = FALSE;
MONO_ARCH_SAVE_REGS;
if (module != NULL) {
if (module->image)
- type = mono_reflection_get_type (module->image, &info, ignoreCase);
+ type = mono_reflection_get_type (module->image, &info, ignoreCase, &type_resolve);
else
type = NULL;
}
if (abuilder->modules) {
for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
- type = mono_reflection_get_type (&mb->dynamic_image->image, &info, ignoreCase);
+ type = mono_reflection_get_type (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve);
if (type)
break;
}
if (!type && abuilder->loaded_modules) {
for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
- type = mono_reflection_get_type (mod->image, &info, ignoreCase);
+ type = mono_reflection_get_type (mod->image, &info, ignoreCase, &type_resolve);
if (type)
break;
}
}
}
else
- type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase);
+ type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase, &type_resolve);
g_free (str);
g_list_free (info.modifiers);
g_list_free (info.nested);
{
MonoDomain *domain = mono_object_domain (assembly);
MonoString *res;
- char *name = g_build_filename (
- assembly->assembly->basedir,
- assembly->assembly->image->module_name, NULL);
MONO_ARCH_SAVE_REGS;
- res = mono_string_new (domain, name);
- g_free (name);
+ res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image));
+
return res;
}
return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL);
}
+static MonoReflectionModule*
+ves_icall_System_Reflection_Assembly_get_ManifestModule (MonoReflectionAssembly *assembly)
+{
+ return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image);
+}
+
static MonoArray*
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
{
{
static MonoClass *System_Reflection_AssemblyName;
MonoArray *result;
- MonoAssembly **ptr;
MonoDomain *domain = mono_object_domain (assembly);
int i, count = 0;
static MonoMethod *create_culture = NULL;
+ MonoTableInfo *t;
MONO_ARCH_SAVE_REGS;
System_Reflection_AssemblyName = mono_class_from_name (
mono_defaults.corlib, "System.Reflection", "AssemblyName");
- for (ptr = assembly->assembly->image->references; ptr && *ptr; ptr++)
- count++;
+ t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF];
+ count = t->rows;
result = mono_array_new (domain, System_Reflection_AssemblyName, count);
}
for (i = 0; i < count; i++) {
- MonoAssembly *assem = assembly->assembly->image->references [i];
+ MonoAssembly *assem;
MonoReflectionAssemblyName *aname;
char *codebase, *absolute;
+ /* FIXME: There is no need to load the assemblies themselves */
+ mono_assembly_load_reference (assembly->assembly->image, i);
+
+ assem = assembly->assembly->image->references [i];
+ if (assem == (gpointer)-1) {
+ char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i, assembly->assembly->image->name);
+ MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL);
+ g_free (msg);
+ mono_raise_exception (ex);
+ }
+
aname = (MonoReflectionAssemblyName *) mono_object_new (
domain, System_Reflection_AssemblyName);
case MONO_IMPLEMENTATION_ASSEMBLYREF:
i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
+ mono_assembly_load_reference (assembly->assembly->image, i - 1);
+ if (assembly->assembly->image->references [i - 1] == (gpointer)-1) {
+ char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name);
+ MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL);
+ g_free (msg);
+ mono_raise_exception (ex);
+ }
info->assembly = mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]);
/* Obtain info recursively */
MonoDomain *domain = mono_domain_get();
MonoArray *res;
MonoClass *klass;
- int i, module_count = 0, file_count = 0;
- MonoImage **modules = assembly->assembly->image->modules;
+ int i, j, file_count = 0;
+ MonoImage **modules;
+ guint32 module_count, real_module_count;
MonoTableInfo *table;
- if (modules) {
- while (modules[module_count])
- ++module_count;
- }
+ g_assert (assembly->assembly->image != NULL);
table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
file_count = table->rows;
- g_assert( assembly->assembly->image != NULL);
- ++module_count;
+ modules = assembly->assembly->image->modules;
+ module_count = assembly->assembly->image->module_count;
- klass = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "Module");
- res = mono_array_new (domain, klass, module_count + file_count);
+ real_module_count = 0;
+ for (i = 0; i < module_count; ++i)
+ if (modules [i])
+ real_module_count ++;
+
+ klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
+ res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
mono_array_set (res, gpointer, 0, mono_module_get_object (domain, assembly->assembly->image));
- for ( i = 1; i < module_count; ++i )
- mono_array_set (res, gpointer, i, mono_module_get_object (domain, modules[i]));
+ 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]));
+ ++j;
+ }
- for (i = 0; i < table->rows; ++i)
- mono_array_set (res, gpointer, module_count + i, mono_module_file_get_object (domain, assembly->assembly->image, i));
+ for (i = 0; i < file_count; ++i, ++j)
+ mono_array_set (res, gpointer, j, mono_module_file_get_object (domain, assembly->assembly->image, i));
return res;
}
return mono_method_get_object (mono_domain_get (), m, NULL);
}
+static MonoReflectionMethod*
+ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method)
+{
+ return mono_method_get_object (mono_domain_get (), method, NULL);
+}
+
+static MonoReflectionMethodBody*
+ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
+{
+ return mono_method_body_get_object (mono_domain_get (), method);
+}
+
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
{
MONO_ARCH_SAVE_REGS;
- mono_stack_walk (get_caller, &dest);
+ mono_stack_walk_no_il (get_caller, &dest);
if (!dest)
dest = m;
return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
static MonoArray*
ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
{
- MonoArray *res;
- MonoImage *image = assembly->assembly->image;
- MonoTableInfo *table = &image->tables [MONO_TABLE_FILE];
+ MonoArray *res = NULL;
+ MonoImage *image = NULL;
+ MonoTableInfo *table = NULL;
MonoDomain *domain;
int i;
MONO_ARCH_SAVE_REGS;
domain = mono_object_domain (assembly);
+
+ if (assembly->assembly->dynamic) {
+ MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)assembly;
+ 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;
+ }
+ }
+ }
+
+ /*
+ * Replace TypeBuilders with the created types to be compatible
+ * with MS.NET.
+ */
+ if (res) {
+ 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);
+ }
+ }
+ }
+
+ 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;
+ }
+ }
+ }
+ return res;
+ }
+ image = assembly->assembly->image;
+ table = &image->tables [MONO_TABLE_FILE];
res = mono_module_get_types (domain, image, exportedOnly);
/* Append data from all modules in the assembly */
}
}
}
-
return res;
}
MONO_ARCH_SAVE_REGS;
g_assert (module->image);
+
+ if (module->image->dynamic && ((MonoDynamicImage*)(module->image))->initial_image)
+ /* These images do not have a global type */
+ return NULL;
+
klass = mono_class_get (module->image, 1 | MONO_TOKEN_TYPE_DEF);
return mono_type_get_object (domain, &klass->byval_arg);
}
return mono_string_new (domain, module->image->guid);
}
+static void
+ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine)
+{
+ if (image->dynamic) {
+ MonoDynamicImage *dyn = (MonoDynamicImage*)image;
+ *pe_kind = dyn->pe_kind;
+ *machine = dyn->machine;
+ }
+ else {
+ *pe_kind = ((MonoCLIImageInfo*)(image->image_info))->cli_cli_header.ch_flags & 0x3;
+ *machine = ((MonoCLIImageInfo*)(image->image_info))->cli_header.coff.coff_machine;
+ }
+}
+
static MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
return mono_module_get_types (mono_object_domain (module), module->image, FALSE);
}
+static gboolean
+mono_metadata_memberref_is_method (MonoImage *image, guint32 token)
+{
+ guint32 cols [MONO_MEMBERREF_SIZE];
+ const char *sig;
+ mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
+ sig = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
+ mono_metadata_decode_blob_size (sig, &sig);
+ return (*sig != 0x6);
+}
+
+static MonoType*
+ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+{
+ MonoClass *klass;
+ int table = mono_metadata_token_table (token);
+ int index = mono_metadata_token_index (token);
+
+ *error = ResolveTokenError_Other;
+
+ /* Validate token */
+ if ((table != MONO_TABLE_TYPEDEF) && (table != MONO_TABLE_TYPEREF) &&
+ (table != MONO_TABLE_TYPESPEC)) {
+ *error = ResolveTokenError_BadTable;
+ return NULL;
+ }
+
+ if (image->dynamic)
+ return mono_lookup_dynamic_token (image, token);
+
+ if ((index <= 0) || (index > image->tables [table].rows)) {
+ *error = ResolveTokenError_OutOfRange;
+ return NULL;
+ }
+
+ klass = mono_class_get (image, token);
+ if (klass)
+ return &klass->byval_arg;
+ else
+ return NULL;
+}
+
+static MonoMethod*
+ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+{
+ int table = mono_metadata_token_table (token);
+ int index = mono_metadata_token_index (token);
+
+ *error = ResolveTokenError_Other;
+
+ /* Validate token */
+ if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) &&
+ (table != MONO_TABLE_MEMBERREF)) {
+ *error = ResolveTokenError_BadTable;
+ return NULL;
+ }
+
+ if (image->dynamic)
+ /* FIXME: validate memberref token type */
+ return mono_lookup_dynamic_token (image, token);
+
+ if ((index <= 0) || (index > image->tables [table].rows)) {
+ *error = ResolveTokenError_OutOfRange;
+ return NULL;
+ }
+ if ((table == MONO_TABLE_MEMBERREF) && (!mono_metadata_memberref_is_method (image, token))) {
+ *error = ResolveTokenError_BadTable;
+ return NULL;
+ }
+
+ return mono_get_method (image, token, NULL);
+}
+
+static MonoString*
+ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+{
+ int index = mono_metadata_token_index (token);
+
+ *error = ResolveTokenError_Other;
+
+ /* Validate token */
+ if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
+ *error = ResolveTokenError_BadTable;
+ return NULL;
+ }
+
+ if (image->dynamic)
+ return mono_lookup_dynamic_token (image, token);
+
+ if ((index <= 0) || (index >= image->heap_us.size)) {
+ *error = ResolveTokenError_OutOfRange;
+ return NULL;
+ }
+
+ /* FIXME: What to do if the index points into the middle of a string ? */
+
+ return mono_ldstr (mono_domain_get (), image, index);
+}
+
+static MonoClassField*
+ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+{
+ MonoClass *klass;
+ int table = mono_metadata_token_table (token);
+ int index = mono_metadata_token_index (token);
+
+ *error = ResolveTokenError_Other;
+
+ /* Validate token */
+ if ((table != MONO_TABLE_FIELD) && (table != MONO_TABLE_MEMBERREF)) {
+ *error = ResolveTokenError_BadTable;
+ return NULL;
+ }
+
+ if (image->dynamic)
+ /* FIXME: validate memberref token type */
+ return mono_lookup_dynamic_token (image, token);
+
+ if ((index <= 0) || (index > image->tables [table].rows)) {
+ *error = ResolveTokenError_OutOfRange;
+ return NULL;
+ }
+ if ((table == MONO_TABLE_MEMBERREF) && (mono_metadata_memberref_is_method (image, token))) {
+ *error = ResolveTokenError_BadTable;
+ return NULL;
+ }
+
+ return mono_field_from_token (image, token, &klass, NULL);
+}
+
+
+static MonoObject*
+ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+{
+ int table = mono_metadata_token_table (token);
+
+ *error = ResolveTokenError_Other;
+
+ switch (table) {
+ case MONO_TABLE_TYPEDEF:
+ case MONO_TABLE_TYPEREF:
+ case MONO_TABLE_TYPESPEC: {
+ MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, error);
+ if (t)
+ return (MonoObject*)mono_type_get_object (mono_domain_get (), t);
+ else
+ return NULL;
+ }
+ case MONO_TABLE_METHOD:
+ case MONO_TABLE_METHODSPEC: {
+ MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, error);
+ if (m)
+ return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
+ else
+ return NULL;
+ }
+ case MONO_TABLE_FIELD: {
+ MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, error);
+ if (f)
+ return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
+ else
+ return NULL;
+ }
+ case MONO_TABLE_MEMBERREF:
+ if (mono_metadata_memberref_is_method (image, token)) {
+ MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, error);
+ if (m)
+ return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
+ else
+ return NULL;
+ }
+ else {
+ MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, error);
+ if (f)
+ return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
+ else
+ return NULL;
+ }
+ break;
+
+ default:
+ *error = ResolveTokenError_BadTable;
+ }
+
+ return NULL;
+}
+
static MonoReflectionType*
ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
{
return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
}
+static MonoReflectionType *
+ves_icall_Type_MakePointerType (MonoReflectionType *type)
+{
+ MonoClass *pklass;
+
+ MONO_ARCH_SAVE_REGS;
+
+ pklass = mono_ptr_class_get (type->type);
+
+ return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
+}
+
static MonoObject *
ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
MonoReflectionMethod *info)
return delegate;
}
+static void
+ves_icall_System_Delegate_FreeTrampoline (MonoDelegate *this)
+{
+ mono_delegate_free_ftnptr (this);
+}
+
/*
* Magic number to convert a time which is relative to
* Jan 1, 1970 into a value which is relative to Jan 1, 0001.
ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page)
{
const char *cset;
- char *p;
+ const char *p;
+ char *c;
char *codepage = NULL;
int code;
int want_name = *int_code_page;
MONO_ARCH_SAVE_REGS;
g_get_charset (&cset);
- p = codepage = strdup (cset);
- for (p = codepage; *p; p++){
- if (isascii (*p) && isalpha (*p))
- *p = tolower (*p);
- if (*p == '-')
- *p = '_';
+ c = codepage = strdup (cset);
+ for (c = codepage; *c; c++){
+ if (isascii (*c) && isalpha (*c))
+ *c = tolower (*c);
+ if (*c == '-')
+ *c = '_';
}
/* g_print ("charset: %s\n", cset); */
p = encodings [0];
code = 0;
for (i = 0; p != 0; ){
- if ((int) p < 7){
- code = (int) p;
+ if ((gssize) p < 7){
+ code = (gssize) p;
p = encodings [++i];
continue;
}
prelink_method (klass->methods [i]);
}
+/* These parameters are "readonly" in corlib/System/Char.cs */
static void
-ves_icall_System_Char_GetDataTablePointers (guint8 **category_data, guint8 **numeric_data,
- gdouble **numeric_data_values, guint16 **to_lower_data_low,
- guint16 **to_lower_data_high, guint16 **to_upper_data_low,
- guint16 **to_upper_data_high)
+ves_icall_System_Char_GetDataTablePointers (guint8 const **category_data,
+ guint8 const **numeric_data,
+ gdouble const **numeric_data_values,
+ guint16 const **to_lower_data_low,
+ guint16 const **to_lower_data_high,
+ guint16 const **to_upper_data_low,
+ guint16 const **to_upper_data_high)
{
*category_data = CategoryData;
*numeric_data = NumericData;
*to_upper_data_high = ToUpperDataHigh;
}
+static MonoString *
+ves_icall_MonoDebugger_check_runtime_version (MonoString *fname)
+{
+ gchar *filename, *error = NULL;
+
+ MONO_ARCH_SAVE_REGS;
+
+ filename = mono_string_to_utf8 (fname);
+ error = mono_debugger_check_runtime_version (filename);
+ g_free (filename);
+
+ if (error)
+ return mono_string_new (mono_domain_get (), error);
+ else
+ return NULL;
+}
+
/* icall map */
typedef struct {
const char *method;
};
static const IcallEntry array_icalls [] = {
+ {"ClearInternal", ves_icall_System_Array_ClearInternal},
{"Clone", mono_array_clone},
{"CreateInstanceImpl", ves_icall_System_Array_CreateInstanceImpl},
{"FastCopy", ves_icall_System_Array_FastCopy},
};
static const IcallEntry delegate_icalls [] = {
- {"CreateDelegate_internal", ves_icall_System_Delegate_CreateDelegate_internal}
+ {"CreateDelegate_internal", ves_icall_System_Delegate_CreateDelegate_internal},
+ {"FreeTrampoline", ves_icall_System_Delegate_FreeTrampoline}
};
static const IcallEntry tracelist_icalls [] = {
};
static const IcallEntry customattrs_icalls [] = {
- {"GetCustomAttributes", mono_reflection_get_custom_attrs}
+ {"GetCustomAttributesInternal", mono_reflection_get_custom_attrs}
};
static const IcallEntry enuminfo_icalls [] = {
};
static const IcallEntry fieldinfo_icalls [] = {
+ {"GetUnmanagedMarshal", ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal},
{"internal_from_handle", ves_icall_System_Reflection_FieldInfo_internal_from_handle}
};
+static const IcallEntry memberinfo_icalls [] = {
+ {"get_MetadataToken", mono_reflection_get_token}
+};
+
static const IcallEntry monotype_icalls [] = {
{"GetArrayRank", ves_icall_MonoType_GetArrayRank},
{"GetConstructors", ves_icall_Type_GetConstructors_internal},
/*
* Private icalls for the Mono Debugger
*/
+ {"MonoDebugger_CheckRuntimeVersion", ves_icall_MonoDebugger_check_runtime_version},
{"MonoDebugger_GetLocalTypeFromSignature", ves_icall_MonoDebugger_GetLocalTypeFromSignature},
{"MonoDebugger_GetMethod", ves_icall_MonoDebugger_GetMethod},
{"MonoDebugger_GetMethodToken", ves_icall_MonoDebugger_GetMethodToken},
{"MonoDebugger_GetType", ves_icall_MonoDebugger_GetType},
+
/* 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_code_base", ves_icall_System_Reflection_Assembly_get_code_base},
{"get_global_assembly_cache", ves_icall_System_Reflection_Assembly_get_global_assembly_cache},
{"get_location", ves_icall_System_Reflection_Assembly_get_location},
};
static const IcallEntry methodbase_icalls [] = {
- {"GetCurrentMethod", ves_icall_GetCurrentMethod}
+ {"GetCurrentMethod", ves_icall_GetCurrentMethod},
+ {"GetMethodBodyInternal", ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal},
+ {"GetMethodFromHandleInternal", ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal}
};
static const IcallEntry module_icalls [] = {
{"Close", ves_icall_System_Reflection_Module_Close},
{"GetGlobalType", ves_icall_System_Reflection_Module_GetGlobalType},
{"GetGuidInternal", ves_icall_System_Reflection_Module_GetGuidInternal},
- {"InternalGetTypes", ves_icall_System_Reflection_Module_InternalGetTypes}
+ {"GetPEKind", ves_icall_System_Reflection_Module_GetPEKind},
+ {"InternalGetTypes", ves_icall_System_Reflection_Module_InternalGetTypes},
+ {"ResolveFieldToken", ves_icall_System_Reflection_Module_ResolveFieldToken},
+ {"ResolveMemberToken", ves_icall_System_Reflection_Module_ResolveMemberToken},
+ {"ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken},
+ {"ResolveStringToken", ves_icall_System_Reflection_Module_ResolveStringToken},
+ {"ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken},
+ {"get_MetadataToken", mono_reflection_get_token}
};
static const IcallEntry monocmethod_icalls [] = {
};
static const IcallEntry monofield_icalls [] = {
+ {"GetFieldOffset", ves_icall_MonoField_GetFieldOffset},
{"GetParentType", ves_icall_MonoField_GetParentType},
{"GetValueInternal", ves_icall_MonoField_GetValueInternal},
{"Mono_GetGenericFieldDefinition", ves_icall_MonoField_Mono_GetGenericFieldDefinition},
static const IcallEntry monomethod_icalls [] = {
{"BindGenericParameters", mono_reflection_bind_generic_method_parameters},
+ {"GetDllImportAttribute", ves_icall_MonoMethod_GetDllImportAttribute},
{"GetGenericArguments", ves_icall_MonoMethod_GetGenericArguments},
{"GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition},
{"InternalInvoke", ves_icall_InternalInvoke},
{"get_property_info", ves_icall_get_property_info}
};
+static const IcallEntry parameterinfo_icalls [] = {
+ {"get_MetadataToken", mono_reflection_get_token}
+};
+
static const IcallEntry dns_icalls [] = {
{"GetHostByAddr_internal(string,string&,string[]&,string[]&)", ves_icall_System_Net_Dns_GetHostByAddr_internal},
{"GetHostByName_internal(string,string&,string[]&,string[]&)", ves_icall_System_Net_Dns_GetHostByName_internal},
};
static const IcallEntry typebuilder_icalls [] = {
+ {"create_generic_class", mono_reflection_create_generic_class},
{"create_internal_class", mono_reflection_create_internal_class},
{"create_runtime_class", mono_reflection_create_runtime_class},
{"get_IsGenericParameter", ves_icall_TypeBuilder_get_IsGenericParameter},
static const IcallEntry marshal_icalls [] = {
{"AllocCoTaskMem", ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem},
- {"AllocHGlobal", mono_marshal_alloc},
+ {"AllocHGlobal", ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal},
{"DestroyStructure", ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure},
{"FreeCoTaskMem", ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem},
- {"FreeHGlobal", mono_marshal_free},
+ {"FreeHGlobal", ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal},
+ {"GetDelegateForFunctionPointerInternal", ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal},
+ {"GetFunctionPointerForDelegateInternal", mono_delegate_to_ftnptr},
{"GetLastWin32Error", ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error},
{"OffsetOf", ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf},
{"Prelink", ves_icall_System_Runtime_InteropServices_Marshal_Prelink},
static const IcallEntry type_icalls [] = {
{"BindGenericParameters", ves_icall_Type_BindGenericParameters},
{"Equals", ves_icall_type_Equals},
+ {"GetGenericParameterAttributes", ves_icall_Type_GetGenericParameterAttributes},
+ {"GetGenericParameterConstraints_impl", ves_icall_Type_GetGenericParameterConstraints},
{"GetGenericParameterPosition", ves_icall_Type_GetGenericParameterPosition},
{"GetGenericTypeDefinition_impl", ves_icall_Type_GetGenericTypeDefinition_impl},
{"GetInterfaceMapData", ves_icall_Type_GetInterfaceMapData},
+ {"GetPacking", ves_icall_Type_GetPacking},
{"GetTypeCode", ves_icall_type_GetTypeCode},
{"IsArrayImpl", ves_icall_Type_IsArrayImpl},
{"IsInstanceOfType", ves_icall_type_IsInstanceOfType},
+ {"MakePointerType", ves_icall_Type_MakePointerType},
{"get_IsGenericInstance", ves_icall_Type_get_IsGenericInstance},
{"get_IsGenericTypeDefinition", ves_icall_Type_get_IsGenericTypeDefinition},
{"internal_from_handle", ves_icall_type_from_handle},
{"System.Reflection.Emit.SignatureHelper", signaturehelper_icalls, G_N_ELEMENTS (signaturehelper_icalls)},
{"System.Reflection.Emit.TypeBuilder", typebuilder_icalls, G_N_ELEMENTS (typebuilder_icalls)},
{"System.Reflection.FieldInfo", fieldinfo_icalls, G_N_ELEMENTS (fieldinfo_icalls)},
+ {"System.Reflection.MemberInfo", memberinfo_icalls, G_N_ELEMENTS (memberinfo_icalls)},
{"System.Reflection.MethodBase", methodbase_icalls, G_N_ELEMENTS (methodbase_icalls)},
{"System.Reflection.Module", module_icalls, G_N_ELEMENTS (module_icalls)},
{"System.Reflection.MonoCMethod", monocmethod_icalls, G_N_ELEMENTS (monocmethod_icalls)},
{"System.Reflection.MonoMethod", monomethod_icalls, G_N_ELEMENTS (monomethod_icalls)},
{"System.Reflection.MonoMethodInfo", monomethodinfo_icalls, G_N_ELEMENTS (monomethodinfo_icalls)},
{"System.Reflection.MonoPropertyInfo", monopropertyinfo_icalls, G_N_ELEMENTS (monopropertyinfo_icalls)},
+ {"System.Reflection.ParameterInfo", parameterinfo_icalls, G_N_ELEMENTS (parameterinfo_icalls)},
{"System.Runtime.CompilerServices.RuntimeHelpers", runtimehelpers_icalls, G_N_ELEMENTS (runtimehelpers_icalls)},
{"System.Runtime.InteropServices.GCHandle", gchandle_icalls, G_N_ELEMENTS (gchandle_icalls)},
{"System.Runtime.InteropServices.Marshal", marshal_icalls, G_N_ELEMENTS (marshal_icalls)},
static MonoType*
type_from_typename (char *typename)
{
- MonoClass *klass;
+ MonoClass *klass = NULL; /* assignment to shut GCC warning up */
if (!strcmp (typename, "int"))
klass = mono_defaults.int_class;
g_strfreev (parts);
- g_hash_table_insert (mono_defaults.corlib->helper_signatures, sigstr, res);
+ g_hash_table_insert (mono_defaults.corlib->helper_signatures, (gpointer)sigstr, res);
mono_loader_unlock ();
projects / mono.git / blobdiff