MONO_ARCH_SAVE_REGS;
+#ifdef __arm__
+ if (*ptr)
+ result = strtod (ptr, &endptr);
+#else
if (*ptr)
result = bsd_strtod (ptr, &endptr);
+#endif
if (!*ptr || (endptr && *endptr))
mono_raise_exception (mono_exception_from_name (mono_get_corlib (),
return TRUE;
}
+static void
+ves_icall_System_Array_InternalArray_GetGenericValueImpl (MonoObject *this, guint32 pos,
+ gpointer value)
+{
+ MonoClass *ac;
+ MonoArray *ao;
+ gint32 esize;
+ gpointer *ea;
+
+ MONO_ARCH_SAVE_REGS;
+
+ ao = (MonoArray *)this;
+ ac = (MonoClass *)ao->obj.vtable->klass;
+
+ esize = mono_array_element_size (ac);
+ ea = (gpointer*)((char*)ao->vector + (pos * esize));
+
+ memcpy (value, ea, esize);
+}
+
static void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
{
g_free (str);
if (type == NULL){
if (throwOnError)
- mono_raise_exception (mono_get_exception_type_load (name));
+ mono_raise_exception (mono_get_exception_type_load (name, NULL));
}
return type;
MonoClassField *cf = field->field;
MonoClass *klass;
MonoVTable *vtable;
+ MonoType *t;
MonoDomain *domain = mono_object_domain (field);
gchar *v;
gboolean is_static = FALSE;
mono_class_init (field->klass);
- switch (cf->type->type) {
+ t = mono_type_get_underlying_type (cf->type);
+ switch (t->type) {
case MONO_TYPE_STRING:
case MONO_TYPE_OBJECT:
case MONO_TYPE_CLASS:
case MONO_TYPE_I8:
case MONO_TYPE_R8:
case MONO_TYPE_VALUETYPE:
- is_ref = cf->type->byref;
+ is_ref = t->byref;
break;
default:
g_error ("type 0x%x not handled in "
- "ves_icall_Monofield_GetValue", cf->type->type);
+ "ves_icall_Monofield_GetValue", t->type);
return NULL;
}
case MONO_TYPE_SZARRAY:
/* Do nothing */
break;
+ case MONO_TYPE_GENERICINST: {
+ MonoGenericClass *gclass = cf->type->data.generic_class;
+ g_assert (!gclass->inst->is_open);
+ if (gclass->container_class->valuetype && (v != NULL))
+ v += sizeof (MonoObject);
+ break;
+ }
default:
g_error ("type 0x%x not handled in "
"ves_icall_FieldInfo_SetValueInternal", cf->type->type);
}
static MonoReflectionType*
-ves_icall_Type_BindGenericParameters (MonoReflectionType *type, MonoArray *type_array)
+ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
{
MonoType *geninst, **types;
int i, count;
}
geninst = mono_reflection_bind_generic_parameters (type, count, types);
+ if (!geninst)
+ return NULL;
return mono_type_get_object (mono_object_domain (type), geninst);
}
return klass->generic_class != NULL;
}
+static gboolean
+ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
+{
+ MonoClass *klass;
+ MONO_ARCH_SAVE_REGS;
+
+ klass = mono_class_from_mono_type (type->type);
+ return klass->generic_class != NULL || klass->generic_container != NULL;
+}
+
static gint32
ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
{
return res;
}
-static MonoBoolean
-ves_icall_MonoType_get_HasGenericArguments (MonoReflectionType *type)
-{
- MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
- klass = mono_class_from_mono_type (type->type);
- if (klass->generic_container || klass->generic_class)
- return TRUE;
- return FALSE;
-}
-
static MonoBoolean
ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
{
static MonoReflectionType*
ves_icall_MonoGenericClass_GetParentType (MonoReflectionGenericClass *type)
{
- MonoGenericClass *gclass;
+ MonoDynamicGenericClass *gclass;
MonoClass *klass;
MONO_ARCH_SAVE_REGS;
- gclass = type->type.type->data.generic_class;
- if (!gclass || !gclass->parent || (gclass->parent->type != MONO_TYPE_GENERICINST))
+ 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;
klass = mono_class_from_mono_type (gclass->parent);
ves_icall_MonoGenericClass_GetInterfaces (MonoReflectionGenericClass *type)
{
static MonoClass *System_Reflection_MonoGenericClass;
- MonoGenericClass *gclass;
+ MonoDynamicGenericClass *gclass;
MonoDomain *domain;
MonoClass *klass;
MonoArray *res;
domain = mono_object_domain (type);
- gclass = type->type.type->data.generic_class;
- if (!gclass || !gclass->ifaces)
+ g_assert (type->type.type->data.generic_class->is_dynamic);
+ gclass = (MonoDynamicGenericClass *) type->type.type->data.generic_class;
+ if (!gclass->ifaces)
return mono_array_new (domain, System_Reflection_MonoGenericClass, 0);
- klass = gclass->container_class;
+ klass = gclass->generic_class.generic_class.container_class;
res = mono_array_new (domain, System_Reflection_MonoGenericClass, gclass->count_ifaces);
static MonoReflectionMethod*
ves_icall_MonoGenericClass_GetCorrespondingInflatedMethod (MonoReflectionGenericClass *type,
- MonoMethod* generic)
+ MonoReflectionMethod* generic)
{
MonoGenericClass *gclass;
MonoDynamicGenericClass *dgclass;
domain = mono_object_domain (type);
for (i = 0; i < dgclass->count_methods; i++)
- if (generic->token == dgclass->methods [i]->token)
+ if (generic->method->token == dgclass->methods [i]->token)
return mono_method_get_object (domain, dgclass->methods [i], NULL);
return NULL;
static MonoReflectionMethod*
ves_icall_MonoGenericClass_GetCorrespondingInflatedConstructor (MonoReflectionGenericClass *type,
- MonoMethod* generic)
+ MonoReflectionMethod* generic)
{
MonoGenericClass *gclass;
MonoDynamicGenericClass *dgclass;
domain = mono_object_domain (type);
for (i = 0; i < dgclass->count_ctors; i++)
- if (generic->token == dgclass->ctors [i]->token)
+ if (generic->method->token == dgclass->ctors [i]->token)
return mono_method_get_object (domain, dgclass->ctors [i], NULL);
return NULL;
static MonoReflectionField*
ves_icall_MonoGenericClass_GetCorrespondingInflatedField (MonoReflectionGenericClass *type,
- MonoClassField* generic)
+ MonoString* generic_name)
{
MonoGenericClass *gclass;
MonoDynamicGenericClass *dgclass;
MonoDomain *domain;
MonoClass *refclass;
+ char *utf8_name = mono_string_to_utf8 (generic_name);
int i;
MONO_ARCH_SAVE_REGS;
domain = mono_object_domain (type);
for (i = 0; i < dgclass->count_fields; i++)
- if (strcmp (generic->name, dgclass->fields [i].name) == 0)
+ if (strcmp (utf8_name, dgclass->fields [i].name) == 0) {
+ g_free (utf8_name);
return mono_field_get_object (domain, refclass, &dgclass->fields [i]);
+ }
+
+ g_free (utf8_name);
return NULL;
}
static MonoReflectionMethod*
ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
- MonoMethod* generic)
+ MonoReflectionMethod* generic)
{
MonoDomain *domain;
MonoClass *klass;
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
- if (method->token == generic->token)
+ if (method->token == generic->method->token)
return mono_method_get_object (domain, method, klass);
}
return NULL;
}
-
-static MonoReflectionField*
-ves_icall_MonoType_GetCorrespondingInflatedField (MonoReflectionType *type,
- MonoClassField* generic)
-{
- MonoDomain *domain;
- MonoClass *klass;
- MonoClassField *field;
- gpointer iter;
-
- MONO_ARCH_SAVE_REGS;
-
- domain = ((MonoObject *)type)->vtable->domain;
-
- klass = mono_class_from_mono_type (type->type);
-
- iter = NULL;
- while ((field = mono_class_get_fields (klass, &iter))) {
- if (field->name == generic->name)
- return mono_field_get_object (domain, klass, field);
- }
-
- return NULL;
-}
-
-
static MonoArray*
ves_icall_MonoGenericClass_GetMethods (MonoReflectionGenericClass *type,
MonoReflectionType *reflected_type)
else
result = *((gpointer *)((char *)this + field->offset));
- g_assert (result);
out_args = mono_array_new (domain, mono_defaults.object_class, 1);
*outArgs = out_args;
mono_array_set (out_args, gpointer, 0, result);
}
g_free (utf8_name);
- return mono_field_get_object (domain, startklass, field);
+ return mono_field_get_object (domain, klass, field);
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
memset (method_slots, 0, sizeof (method_slots_default));
}
handle_parent:
+ mono_class_setup_vtable (klass);
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
match = 0;
memset (method_slots, 0, sizeof (method_slots_default));
}
handle_parent:
+ mono_class_setup_vtable (klass);
iter = NULL;
while ((prop = mono_class_get_properties (klass, &iter))) {
match = 0;
g_list_free (info.modifiers);
g_list_free (info.nested);
if (throwOnError) /* uhm: this is a parse error, though... */
- mono_raise_exception (mono_get_exception_type_load (name));
+ mono_raise_exception (mono_get_exception_type_load (name, NULL));
/*g_print ("failed parse\n");*/
return NULL;
}
g_list_free (info.nested);
if (!type) {
if (throwOnError)
- mono_raise_exception (mono_get_exception_type_load (name));
+ mono_raise_exception (mono_get_exception_type_load (name, NULL));
/* g_print ("failed find\n"); */
return NULL;
}
}
static MonoObject*
-create_version (MonoDomain *domain, MonoAssemblyName *aname)
+create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
{
static MonoClass *System_Version = NULL;
static MonoMethod *create_version = NULL;
MonoObject *result;
- int major, minor, build, revision;
gpointer args [4];
if (!System_Version) {
mono_method_desc_free (desc);
}
- major = aname->major;
- minor = aname->minor;
- build = aname->build;
- revision = aname->revision;
args [0] = &major;
args [1] = &minor;
args [2] = &build;
MonoDomain *domain = mono_object_domain (assembly);
int i, count = 0;
static MonoMethod *create_culture = NULL;
+ MonoImage *image = assembly->assembly->image;
MonoTableInfo *t;
MONO_ARCH_SAVE_REGS;
}
for (i = 0; i < count; i++) {
- MonoAssembly *assem;
MonoReflectionAssemblyName *aname;
+ guint32 cols [MONO_ASSEMBLYREF_SIZE];
- /* 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);
- }
+ mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
aname = (MonoReflectionAssemblyName *) mono_object_new (
domain, System_Reflection_AssemblyName);
- aname->name = mono_string_new (domain, assem->aname.name);
+ aname->name = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]));
- aname->major = assem->aname.major;
- aname->minor = assem->aname.minor;
- aname->build = assem->aname.build;
- aname->revision = assem->aname.revision;
- aname->hashalg = assem->aname.hash_alg;
- aname->flags = assem->aname.flags;
+ aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
+ aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
+ aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER];
+ aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER];
+ aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
aname->versioncompat = 1; /* SameMachine (default) */
- aname->version = create_version (domain, &assem->aname);
+ aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
+ 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, assem->aname.culture);
+ 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);
}
-
- if (assem->aname.public_key) {
- guint32 pkey_len;
- const char *pkey_ptr = (char*)assem->aname.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);
- memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
+
+ if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
+ const gchar *pkey_ptr = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]);
+ guint32 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
+
+ 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);
+ 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);
+ memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len);
+ }
}
-
- /* public key token isn't copied - the class library will
- automatically generate it from the public key if required */
-
+
/* 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). */
}
static MonoString *
-ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name)
+ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
+ gboolean assembly_qualified)
{
MonoDomain *domain = mono_object_domain (object);
+ MonoTypeNameFormat format;
MonoString *res;
gchar *name;
MONO_ARCH_SAVE_REGS;
-
if (full_name)
- name = mono_type_get_full_name (object->type);
+ format = assembly_qualified ?
+ MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED :
+ MONO_TYPE_NAME_FORMAT_FULL_NAME;
else
- name = mono_type_get_name (object->type);
+ format = MONO_TYPE_NAME_FORMAT_REFLECTION;
+
+ name = mono_type_get_name_full (object->type, format);
+ if (!name)
+ return NULL;
+
res = mono_string_new (domain, name);
g_free (name);
}
static void
-fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute)
+fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version)
{
static MonoMethod *create_culture = NULL;
gpointer args [1];
aname->build = name->build;
aname->revision = name->revision;
aname->hashalg = name->hash_alg;
- aname->version = create_version (domain, name);
+ if (by_default_version)
+ aname->version = create_version (domain, name->major, name->minor, name->build, name->revision);
codebase = g_filename_to_uri (absolute, NULL, NULL);
if (codebase) {
mono_method_desc_free (desc);
}
- args [0] = mono_string_new (domain, name->culture);
- aname->cultureInfo =
- mono_runtime_invoke (create_culture, NULL, args, NULL);
+ if (name->culture) {
+ args [0] = mono_string_new (domain, name->culture);
+ aname->cultureInfo = mono_runtime_invoke (create_culture, NULL, args, NULL);
+ }
if (name->public_key) {
pkey_ptr = (char*)name->public_key;
absolute = g_build_filename (assembly->assembly->basedir, assembly->assembly->image->module_name, NULL);
fill_reflection_assembly_name (mono_object_domain (assembly), aname,
- &assembly->assembly->aname, absolute);
+ &assembly->assembly->aname, absolute, TRUE);
g_free (absolute);
}
mono_raise_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest"));
}
- fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename);
+ fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, TRUE);
g_free (filename);
mono_image_close (image);
return res;
}
+static gboolean
+ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
+{
+ MonoAssemblyName aname;
+ MonoDomain *domain = mono_object_domain (name);
+ char *val;
+ gboolean is_version_defined;
+
+ val = mono_string_to_utf8 (assname);
+ if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined))
+ return FALSE;
+
+ fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined);
+
+ mono_assembly_name_free (&aname);
+ g_free ((guint8*) aname.public_key);
+ g_free (val);
+
+ return TRUE;
+}
+
static MonoReflectionType*
ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
{
*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;
-}
-
static gint32
-ves_icall_MonoDebugger_GetMethodIndex (MonoReflectionMethod *rmethod)
+ves_icall_MonoDebugger_GetMethodToken (MonoReflectionMethod *method)
{
- guint32 index;
-
- MONO_ARCH_SAVE_REGS;
-
- index = mono_method_get_index (rmethod->method);
- if (!index)
- return -1;
-
- return index - rmethod->method->klass->method.first;
-}
-
-static MonoReflectionType*
-ves_icall_MonoDebugger_MakeArrayType (MonoReflectionType *type, int rank)
-{
- MonoClass *klass, *aklass;
-
- MONO_ARCH_SAVE_REGS;
-
- klass = mono_class_from_mono_type (type->type);
- aklass = mono_array_class_get (klass, rank);
-
- return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
-}
-
-static int
-ves_icall_MonoDebugger_GetTypeToken (MonoObject *obj)
-{
- MONO_ARCH_SAVE_REGS;
-
- return mono_reflection_get_token (obj);
+ return method->method->token;
}
static MonoBoolean
return found;
}
+static MonoArray*
+custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
+{
+ return mono_reflection_get_custom_attrs_by_type (obj, attr_type ? mono_class_from_mono_type (attr_type->type) : NULL);
+}
+
static MonoBoolean
GCHandle_CheckCurrentDomain (guint32 gchandle)
{
};
static MonoArray *
-base64_to_byte_array (gunichar2 *start, gint ilength)
+base64_to_byte_array (gunichar2 *start, gint ilength, MonoBoolean allowWhitespaceOnly)
{
gint ignored;
gint i;
gunichar2 c;
+ gunichar2 last, prev_last;
gint olength;
MonoArray *result;
guchar *res_ptr;
MonoException *exc;
ignored = 0;
+ last = prev_last = 0;
for (i = 0; i < ilength; i++) {
c = start [i];
- if (isspace (c)) {
- ignored++;
- } else if (c >= sizeof (dbase64)) {
+ if (c >= sizeof (dbase64)) {
exc = mono_exception_from_name_msg (mono_get_corlib (),
"System", "FormatException",
"Invalid character found.");
mono_raise_exception (exc);
+ } else if (isspace (c)) {
+ ignored++;
+ } else {
+ prev_last = last;
+ last = c;
}
}
olength = ilength - ignored;
+
+ if (allowWhitespaceOnly && olength == 0) {
+ return mono_array_new (mono_domain_get (), mono_defaults.byte_class, 0);
+ }
+
if ((olength & 3) != 0 || olength <= 0) {
exc = mono_exception_from_name_msg (mono_get_corlib (), "System",
"FormatException", "Invalid length.");
}
olength = (olength * 3) / 4;
- if (start [ilength - 1] == '=')
+ if (last == '=')
olength--;
- if (start [ilength - 2] == '=')
+ if (prev_last == '=')
olength--;
result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, olength);
for (i = 0; i < ilength; ) {
int k;
- for (k = 0; k < 4 && i < ilength; k++) {
+ for (k = 0; k < 4 && i < ilength;) {
c = start [i++];
if (isspace (c))
continue;
-
+
a [k] = (guchar) c;
if (((b [k] = dbase64 [c]) & 0x80) != 0) {
exc = mono_exception_from_name_msg (mono_get_corlib (),
"Invalid character found.");
mono_raise_exception (exc);
}
+ k++;
}
*res_ptr++ = (b [0] << 2) | (b [1] >> 4);
}
static MonoArray *
-InternalFromBase64String (MonoString *str)
+InternalFromBase64String (MonoString *str, MonoBoolean allowWhitespaceOnly)
{
MONO_ARCH_SAVE_REGS;
- return base64_to_byte_array (mono_string_chars (str), mono_string_length (str));
+ return base64_to_byte_array (mono_string_chars (str),
+ mono_string_length (str), allowWhitespaceOnly);
}
static MonoArray *
{
MONO_ARCH_SAVE_REGS;
- return base64_to_byte_array (mono_array_addr (input, gunichar2, offset), length);
+ return base64_to_byte_array (mono_array_addr (input, gunichar2, offset),
+ length, FALSE);
}
/* icall map */
{"internal_is_lcid_neutral", ves_icall_System_Globalization_CultureInfo_internal_is_lcid_neutral}
};
+static const IcallEntry regioninfo_icalls [] = {
+ {"construct_internal_region_from_lcid", ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid},
+ {"construct_internal_region_from_name", ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_name}
+};
+
static const IcallEntry compareinfo_icalls [] = {
{"assign_sortkey(object,string,System.Globalization.CompareOptions)", ves_icall_System_Globalization_CompareInfo_assign_sortkey},
{"construct_compareinfo(string)", ves_icall_System_Globalization_CompareInfo_construct_compareinfo},
{"CreateDirectory(string,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_CreateDirectory},
{"CreatePipe(intptr&,intptr&)", ves_icall_System_IO_MonoIO_CreatePipe},
{"DeleteFile(string,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_DeleteFile},
- {"FindClose(intptr,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_FindClose},
- {"FindFirstFile(string,System.IO.MonoIOStat&,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_FindFirstFile},
- {"FindNextFile(intptr,System.IO.MonoIOStat&,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_FindNextFile},
{"Flush(intptr,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_Flush},
{"GetCurrentDirectory(System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_GetCurrentDirectory},
{"GetFileAttributes(string,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_GetFileAttributes},
{"GetFileStat(string,System.IO.MonoIOStat&,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_GetFileStat},
+ {"GetFileSystemEntries", ves_icall_System_IO_MonoIO_GetFileSystemEntries},
{"GetFileType(intptr,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_GetFileType},
{"GetLength(intptr,System.IO.MonoIOError&)", ves_icall_System_IO_MonoIO_GetLength},
{"GetTempPath(string&)", ves_icall_System_IO_MonoIO_GetTempPath},
static const IcallEntry customattrs_icalls [] = {
{"GetCustomAttributesDataInternal", mono_reflection_get_custom_attrs_data},
- {"GetCustomAttributesInternal", mono_reflection_get_custom_attrs},
+ {"GetCustomAttributesInternal", custom_attrs_get_by_type},
{"IsDefinedInternal", custom_attrs_defined_internal}
};
{"GetConstructors", ves_icall_Type_GetConstructors_internal},
{"GetConstructors_internal", ves_icall_Type_GetConstructors_internal},
{"GetCorrespondingInflatedConstructor", ves_icall_MonoType_GetCorrespondingInflatedMethod},
- {"GetCorrespondingInflatedField", ves_icall_MonoType_GetCorrespondingInflatedField},
{"GetCorrespondingInflatedMethod", ves_icall_MonoType_GetCorrespondingInflatedMethod},
{"GetElementType", ves_icall_MonoType_GetElementType},
{"GetEvents_internal", ves_icall_Type_GetEvents_internal},
{"get_BaseType", ves_icall_get_type_parent},
{"get_DeclaringMethod", ves_icall_MonoType_get_DeclaringMethod},
{"get_DeclaringType", ves_icall_MonoType_get_DeclaringType},
- {"get_HasGenericArguments", ves_icall_MonoType_get_HasGenericArguments},
{"get_IsGenericParameter", ves_icall_MonoType_get_IsGenericParameter},
{"get_Module", ves_icall_MonoType_get_Module},
{"get_Name", ves_icall_MonoType_get_Name},
/*
* 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_GetMethodIndex", ves_icall_MonoDebugger_GetMethodIndex},
{"MonoDebugger_GetMethodToken", ves_icall_MonoDebugger_GetMethodToken},
- {"MonoDebugger_GetType", ves_icall_MonoDebugger_GetType},
- {"MonoDebugger_GetTypeToken", ves_icall_MonoDebugger_GetTypeToken},
- {"MonoDebugger_MakeArrayType", ves_icall_MonoDebugger_MakeArrayType},
/* normal icalls again */
{"get_EntryPoint", ves_icall_System_Reflection_Assembly_get_EntryPoint},
{"load_with_partial_name", ves_icall_System_Reflection_Assembly_load_with_partial_name}
};
+static const IcallEntry assembly_name_icalls [] = {
+ {"ParseName", ves_icall_System_Reflection_AssemblyName_ParseName}
+};
+
static const IcallEntry methodbase_icalls [] = {
{"GetCurrentMethod", ves_icall_GetCurrentMethod},
{"GetMethodBodyInternal", ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal},
};
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},
+ {"MakeGenericMethod", mono_reflection_bind_generic_method_parameters},
{"get_HasGenericParameters", ves_icall_MonoMethod_get_HasGenericParameters},
{"get_IsGenericMethodDefinition", ves_icall_MonoMethod_get_IsGenericMethodDefinition},
{"get_Mono_IsInflatedMethod", ves_icall_MonoMethod_get_Mono_IsInflatedMethod},
};
static const IcallEntry methodbuilder_icalls [] = {
- {"BindGenericParameters", mono_reflection_bind_generic_method_parameters}
+ {"MakeGenericMethod", mono_reflection_bind_generic_method_parameters}
};
static const IcallEntry modulebuilder_icalls [] = {
{"GetSerializedCurrentUICulture", ves_icall_System_Threading_Thread_GetSerializedCurrentUICulture},
{"GetState", ves_icall_System_Threading_Thread_GetState},
{"Join_internal", ves_icall_System_Threading_Thread_Join_internal},
+ {"MemoryBarrier", ves_icall_System_Threading_Thread_MemoryBarrier},
{"ResetAbort_internal()", ves_icall_System_Threading_Thread_ResetAbort},
{"Resume_internal()", ves_icall_System_Threading_Thread_Resume},
{"SetCachedCurrentCulture", ves_icall_System_Threading_Thread_SetCachedCurrentCulture},
};
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},
{"GetTypeCodeInternal", ves_icall_type_GetTypeCodeInternal},
{"IsArrayImpl", ves_icall_Type_IsArrayImpl},
{"IsInstanceOfType", ves_icall_type_IsInstanceOfType},
+ {"MakeGenericType", ves_icall_Type_MakeGenericType},
{"MakePointerType", ves_icall_Type_MakePointerType},
{"get_IsGenericInstance", ves_icall_Type_get_IsGenericInstance},
+ {"get_IsGenericType", ves_icall_Type_get_IsGenericType},
{"get_IsGenericTypeDefinition", ves_icall_Type_get_IsGenericTypeDefinition},
{"internal_from_handle", ves_icall_type_from_handle},
{"internal_from_name", ves_icall_type_from_name},
{"set_SecurityEnabled", ves_icall_System_Security_SecurityManager_set_SecurityEnabled}
};
+static const IcallEntry generic_array_icalls [] = {
+ {"GetGenericValueImpl", ves_icall_System_Array_InternalArray_GetGenericValueImpl}
+};
+
/* proto
static const IcallEntry array_icalls [] = {
};
{"System.AppDomain", appdomain_icalls, G_N_ELEMENTS (appdomain_icalls)},
{"System.ArgIterator", argiterator_icalls, G_N_ELEMENTS (argiterator_icalls)},
{"System.Array", array_icalls, G_N_ELEMENTS (array_icalls)},
+ {"System.Array/InternalArray`1", generic_array_icalls, G_N_ELEMENTS (generic_array_icalls)},
{"System.Buffer", buffer_icalls, G_N_ELEMENTS (buffer_icalls)},
{"System.Char", char_icalls, G_N_ELEMENTS (char_icalls)},
{"System.Configuration.DefaultConfig", defaultconf_icalls, G_N_ELEMENTS (defaultconf_icalls)},
{"System.GC", gc_icalls, G_N_ELEMENTS (gc_icalls)},
{"System.Globalization.CompareInfo", compareinfo_icalls, G_N_ELEMENTS (compareinfo_icalls)},
{"System.Globalization.CultureInfo", cultureinfo_icalls, G_N_ELEMENTS (cultureinfo_icalls)},
+ {"System.Globalization.RegionInfo", regioninfo_icalls, G_N_ELEMENTS (regioninfo_icalls)},
{"System.IO.FAMWatcher", famwatcher_icalls, G_N_ELEMENTS (famwatcher_icalls)},
{"System.IO.FileSystemWatcher", filewatcher_icalls, G_N_ELEMENTS (filewatcher_icalls)},
{"System.IO.MonoIO", monoio_icalls, G_N_ELEMENTS (monoio_icalls)},
{"System.Net.Sockets.SocketException", socketex_icalls, G_N_ELEMENTS (socketex_icalls)},
{"System.Object", object_icalls, G_N_ELEMENTS (object_icalls)},
{"System.Reflection.Assembly", assembly_icalls, G_N_ELEMENTS (assembly_icalls)},
+ {"System.Reflection.AssemblyName", assembly_name_icalls, G_N_ELEMENTS (assembly_name_icalls)},
{"System.Reflection.Emit.AssemblyBuilder", assemblybuilder_icalls, G_N_ELEMENTS (assemblybuilder_icalls)},
{"System.Reflection.Emit.CustomAttributeBuilder", customattrbuilder_icalls, G_N_ELEMENTS (customattrbuilder_icalls)},
{"System.Reflection.Emit.DynamicMethod", dynamicmethod_icalls, G_N_ELEMENTS (dynamicmethod_icalls)},
g_assert (method != NULL);
- typelen = concat_class_name (mname, sizeof (mname), method->klass);
- if (!typelen)
- return NULL;
+ if (method->klass->nested_in) {
+ int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in);
+ if (!pos)
+ return NULL;
+
+ mname [pos++] = '/';
+ mname [pos] = 0;
+
+ typelen = concat_class_name (mname+pos, sizeof (mname)-pos-1, method->klass);
+ if (!typelen)
+ return NULL;
+
+ typelen += pos;
+ } else {
+ typelen = concat_class_name (mname, sizeof (mname), method->klass);
+ if (!typelen)
+ return NULL;
+ }
imap = find_class_icalls (mname);