/*
* We expect a pointer to a char, not a string
*/
-static double
-mono_double_ParseImpl (char *ptr)
+static gboolean
+mono_double_ParseImpl (char *ptr, double *result)
{
gchar *endptr = NULL;
- gdouble result = 0.0;
+ *result = 0.0;
MONO_ARCH_SAVE_REGS;
#ifdef __arm__
if (*ptr)
- result = strtod (ptr, &endptr);
+ *result = strtod (ptr, &endptr);
#else
if (*ptr)
- result = bsd_strtod (ptr, &endptr);
+ *result = bsd_strtod (ptr, &endptr);
#endif
if (!*ptr || (endptr && *endptr))
- mono_raise_exception (mono_exception_from_name (mono_get_corlib (),
- "System",
- "FormatException"));
+ return FALSE;
- return result;
+ return TRUE;
}
static void
mono_image_build_metadata (mb);
}
+static gboolean
+get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
+{
+ MonoMethod **dest = data;
+
+ /* skip unmanaged frames */
+ if (!managed)
+ return FALSE;
+
+ if (m == *dest) {
+ *dest = NULL;
+ return FALSE;
+ }
+ if (!(*dest)) {
+ *dest = m;
+ return TRUE;
+ }
+ return FALSE;
+}
+
static MonoReflectionType *
type_from_name (const char *str, MonoBoolean ignoreCase)
{
if (info.assembly.name) {
assembly = mono_assembly_load (&info.assembly, NULL, NULL);
} else {
- MonoReflectionAssembly *refass;
+ MonoMethod *m = mono_method_get_last_managed ();
+ MonoMethod *dest = m;
- refass = ves_icall_System_Reflection_Assembly_GetCallingAssembly ();
- assembly = refass->assembly;
+ mono_stack_walk_no_il (get_caller, &dest);
+ if (!dest)
+ dest = m;
+
+ /*
+ * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus
+ * causing ves_icall_System_Reflection_Assembly_GetCallingAssembly()
+ * to crash. This only seems to happen in some strange remoting
+ * scenarios and I was unable to figure out what's happening there.
+ * Dec 10, 2005 - Martin.
+ */
+
+ if (dest)
+ assembly = dest->klass->image->assembly;
+ else {
+ g_warning (G_STRLOC);
+ }
}
if (assembly)
MONO_ARCH_SAVE_REGS;
- info->declaring_type = mono_type_get_object (domain, &event->klass->byval_arg);
- info->reflected_type = mono_type_get_object (domain, &event->event->parent->byval_arg);
+ info->reflected_type = mono_type_get_object (domain, &event->klass->byval_arg);
+ info->declaring_type = mono_type_get_object (domain, &event->event->parent->byval_arg);
info->name = mono_string_new (domain, event->event->name);
info->attrs = event->event->attrs;
static MonoReflectionType*
ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
{
- MonoDomain *domain = mono_domain_get ();
- MonoClass *class = mono_class_from_mono_type (type->type);
+ MonoDomain *domain = mono_domain_get ();
+ MonoClass *class;
MONO_ARCH_SAVE_REGS;
- return class->nested_in ? mono_type_get_object (domain, &class->nested_in->byval_arg) : NULL;
+ if (type->type->type == MONO_TYPE_VAR)
+ class = type->type->data.generic_param->owner->klass;
+ else if (type->type->type == MONO_TYPE_MVAR)
+ class = type->type->data.generic_param->method->klass;
+ else
+ class = mono_class_from_mono_type (type->type)->nested_in;
+
+ return class ? mono_type_get_object (domain, &class->byval_arg) : NULL;
}
static MonoReflectionType*
if (!klass->generic_class && !klass->generic_container)
return NULL;
- if (!klass->generic_class->is_dynamic)
- return NULL;
-
return mono_type_get_object (mono_object_domain (type), gclass->parent);
}
MONO_ARCH_SAVE_REGS;
- method = type->type->data.generic_param->method;
- if (!method)
+ if (type->type->type != MONO_TYPE_MVAR)
return NULL;
+ method = type->type->data.generic_param->method;
+ g_assert (method);
klass = mono_class_from_mono_type (type->type);
return mono_method_get_object (mono_object_domain (type), method, klass);
}
{
MONO_ARCH_SAVE_REGS;
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return FALSE;
-
return mono_method_signature (method->method)->generic_param_count != 0;
}
{
MONO_ARCH_SAVE_REGS;
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return FALSE;
-
return method->method->is_inflated;
}
{
MONO_ARCH_SAVE_REGS;
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return FALSE;
-
return mono_method_signature (method->method)->generic_param_count != 0;
}
{
MonoArray *res;
MonoDomain *domain;
- MonoMethodNormal *mn;
int count, i;
MONO_ARCH_SAVE_REGS;
domain = mono_object_domain (method);
- if ((method->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- return mono_array_new (domain, mono_defaults.monotype_class, 0);
-
if (method->method->is_inflated) {
MonoMethodInflated *imethod = (MonoMethodInflated *) method->method;
MonoGenericMethod *gmethod = imethod->context->gmethod;
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));
}
}
}
- mn = (MonoMethodNormal *) method->method;
count = mono_method_signature (method->method)->generic_param_count;
res = mono_array_new (domain, mono_defaults.monotype_class, count);
for (i = 0; i < count; i++) {
- MonoGenericParam *param = &mn->generic_container->type_params [i];
+ MonoGenericParam *param = &method->method->generic_container->type_params [i];
MonoClass *pklass = mono_class_from_generic_parameter (
param, method->method->klass->image, TRUE);
mono_array_set (res, gpointer, i,
return result;
}
+static guint64
+read_enum_value (char *mem, int type)
+{
+ switch (type) {
+ case MONO_TYPE_U1:
+ return *(guint8*)mem;
+ case MONO_TYPE_I1:
+ return *(gint8*)mem;
+ case MONO_TYPE_U2:
+ return *(guint16*)mem;
+ case MONO_TYPE_I2:
+ return *(gint16*)mem;
+ case MONO_TYPE_U4:
+ return *(guint32*)mem;
+ case MONO_TYPE_I4:
+ return *(gint32*)mem;
+ case MONO_TYPE_U8:
+ return *(guint64*)mem;
+ case MONO_TYPE_I8:
+ return *(gint64*)mem;
+ default:
+ g_assert_not_reached ();
+ }
+ return 0;
+}
+
+static void
+write_enum_value (char *mem, int type, guint64 value)
+{
+ switch (type) {
+ case MONO_TYPE_U1:
+ case MONO_TYPE_I1: {
+ guint8 *p = mem;
+ *p = value;
+ break;
+ }
+ case MONO_TYPE_U2:
+ case MONO_TYPE_I2: {
+ guint16 *p = (void*)mem;
+ *p = value;
+ break;
+ }
+ case MONO_TYPE_U4:
+ case MONO_TYPE_I4: {
+ guint32 *p = (void*)mem;
+ *p = value;
+ break;
+ }
+ case MONO_TYPE_U8:
+ case MONO_TYPE_I8: {
+ guint64 *p = (void*)mem;
+ *p = value;
+ break;
+ }
+ default:
+ g_assert_not_reached ();
+ }
+ return;
+}
+
static MonoObject *
ves_icall_System_Enum_ToObject (MonoReflectionType *type, MonoObject *obj)
{
MonoDomain *domain;
MonoClass *enumc, *objc;
- gint32 s1, s2;
MonoObject *res;
+ guint64 val;
MONO_ARCH_SAVE_REGS;
MONO_CHECK_ARG (obj, enumc->enumtype == TRUE);
MONO_CHECK_ARG (obj, (objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 &&
objc->byval_arg.type <= MONO_TYPE_U8));
-
- s1 = mono_class_value_size (enumc, NULL);
- s2 = mono_class_value_size (objc, NULL);
res = mono_object_new (domain, enumc);
+ val = read_enum_value ((char *)obj + sizeof (MonoObject), objc->enumtype? objc->enum_basetype->type: objc->byval_arg.type);
+ write_enum_value ((char *)res + sizeof (MonoObject), enumc->enum_basetype->type, val);
-#if G_BYTE_ORDER == G_LITTLE_ENDIAN
- memcpy ((char *)res + sizeof (MonoObject), (char *)obj + sizeof (MonoObject), MIN (s1, s2));
-#else
- memcpy ((char *)res + sizeof (MonoObject) + (s1 > s2 ? s1 - s2 : 0),
- (char *)obj + sizeof (MonoObject) + (s2 > s1 ? s2 - s1 : 0),
- MIN (s1, s2));
-#endif
return res;
}
}
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;
compare_func = (ignore_case) ? g_strcasecmp : strcmp;
}
+ mono_class_setup_vtable (klass);
+
if (klass->vtable_size >= sizeof (method_slots_default) * 8) {
method_slots = g_new0 (guint32, klass->vtable_size / 32 + 1);
} else {
if (!match)
continue;
match = 0;
- l = g_slist_prepend (l, mono_event_get_object (domain, klass, event));
+ l = g_slist_prepend (l, mono_event_get_object (domain, startklass, event));
}
if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
goto handle_parent;
gchar *str;
MonoType *type = NULL;
MonoTypeNameParse info;
- gboolean type_resolve = FALSE;
+ gboolean type_resolve;
MONO_ARCH_SAVE_REGS;
+ /* On MS.NET, this does not fire a TypeResolve event */
+ type_resolve = TRUE;
str = mono_string_to_utf8 (name);
/*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
if (!mono_reflection_parse_type (str, &info)) {
}
-static gboolean
-get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
-{
- MonoMethod **dest = data;
-
- /* skip unmanaged frames */
- if (!managed)
- return FALSE;
-
- if (m == *dest) {
- *dest = NULL;
- return FALSE;
- }
- if (!(*dest)) {
- *dest = m;
- return TRUE;
- }
- return FALSE;
-}
-
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
{
return mono_assembly_get_object (domain, domain->entry_assembly);
}
-
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
{
if (!name)
return NULL;
+ if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR))
+ return NULL;
+
res = mono_string_new (domain, name);
g_free (name);
}
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->major, name->minor, name->build, name->revision);
+ 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)
{
}
}
+static gint32
+ves_icall_System_Reflection_Module_get_MDStreamVersion (MonoReflectionModule *module)
+{
+ MonoImage *image = module->image;
+
+ if (!image)
+ mono_raise_exception (mono_get_exception_not_supported (""));
+
+ return (image->md_version_major << 16) | (image->md_version_minor);
+}
+
static MonoArray*
ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
{
last = prev_last = 0;
for (i = 0; i < ilength; i++) {
c = start [i];
- if (isspace (c)) {
- ignored++;
- } else if (c >= sizeof (dbase64)) {
+ if (c >= sizeof (dbase64)) {
exc = mono_exception_from_name_msg (mono_get_corlib (),
"System", "FormatException",
"Invalid character found.");
mono_raise_exception (exc);
+ } else if (isspace (c)) {
+ ignored++;
} else {
prev_last = last;
last = c;
};
static const IcallEntry process_icalls [] = {
+ {"CreateProcess_internal(System.Diagnostics.ProcessStartInfo,intptr,intptr,intptr,System.Diagnostics.Process/ProcInfo&)", ves_icall_System_Diagnostics_Process_CreateProcess_internal},
{"ExitCode_internal(intptr)", ves_icall_System_Diagnostics_Process_ExitCode_internal},
{"ExitTime_internal(intptr)", ves_icall_System_Diagnostics_Process_ExitTime_internal},
{"GetModules_internal()", ves_icall_System_Diagnostics_Process_GetModules_internal},
{"ProcessName_internal(intptr)", ves_icall_System_Diagnostics_Process_ProcessName_internal},
{"Process_free_internal(intptr)", ves_icall_System_Diagnostics_Process_Process_free_internal},
{"SetWorkingSet_internal(intptr,int,int,bool)", ves_icall_System_Diagnostics_Process_SetWorkingSet_internal},
+ {"ShellExecuteEx_internal(System.Diagnostics.ProcessStartInfo,System.Diagnostics.Process/ProcInfo&)", ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal},
{"StartTime_internal(intptr)", ves_icall_System_Diagnostics_Process_StartTime_internal},
- {"Start_internal(string,string,string,intptr,intptr,intptr,System.Diagnostics.Process/ProcInfo&)", ves_icall_System_Diagnostics_Process_Start_internal},
{"WaitForExit_internal(intptr,int)", ves_icall_System_Diagnostics_Process_WaitForExit_internal}
};
{"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},
/* normal icalls again */
{"get_EntryPoint", ves_icall_System_Reflection_Assembly_get_EntryPoint},
{"get_ManifestModule", ves_icall_System_Reflection_Assembly_get_ManifestModule},
- {"get_MetadataToken", mono_reflection_get_token},
{"get_ReflectionOnly", ves_icall_System_Reflection_Assembly_get_ReflectionOnly},
{"get_code_base", ves_icall_System_Reflection_Assembly_get_code_base},
{"get_global_assembly_cache", ves_icall_System_Reflection_Assembly_get_global_assembly_cache},
{"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},
{"ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken},
{"ResolveStringToken", ves_icall_System_Reflection_Module_ResolveStringToken},
{"ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken},
+ {"get_MDStreamVersion", ves_icall_System_Reflection_Module_get_MDStreamVersion},
{"get_MetadataToken", mono_reflection_get_token}
};
{"GetGenericArguments", ves_icall_MonoMethod_GetGenericArguments},
{"GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition},
{"InternalInvoke", ves_icall_InternalInvoke},
- {"MakeGenericMethod", mono_reflection_bind_generic_method_parameters},
+ {"MakeGenericMethod_impl", 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 interlocked_icalls [] = {
- {"Add(int&,int)", ves_icall_System_Threading_Interlocked_Add_Int},
+ {"Add(int&,int)", ves_icall_System_Threading_Interlocked_Add_Int},
{"Add(long&,long)", ves_icall_System_Threading_Interlocked_Add_Long},
- {"CompareExchange(double&,double,double)", ves_icall_System_Threading_Interlocked_CompareExchange_Double},
+ {"CompareExchange(T&,T,T)", ves_icall_System_Threading_Interlocked_CompareExchange_T},
+ {"CompareExchange(double&,double,double)", ves_icall_System_Threading_Interlocked_CompareExchange_Double},
{"CompareExchange(int&,int,int)", ves_icall_System_Threading_Interlocked_CompareExchange_Int},
{"CompareExchange(intptr&,intptr,intptr)", ves_icall_System_Threading_Interlocked_CompareExchange_Object},
{"CompareExchange(long&,long,long)", ves_icall_System_Threading_Interlocked_CompareExchange_Long},
{"CompareExchange(single&,single,single)", ves_icall_System_Threading_Interlocked_CompareExchange_Single},
{"Decrement(int&)", ves_icall_System_Threading_Interlocked_Decrement_Int},
{"Decrement(long&)", ves_icall_System_Threading_Interlocked_Decrement_Long},
+ {"Exchange(T&,T)", ves_icall_System_Threading_Interlocked_Exchange_T},
{"Exchange(double&,double)", ves_icall_System_Threading_Interlocked_Exchange_Double},
{"Exchange(int&,int)", ves_icall_System_Threading_Interlocked_Exchange_Int},
{"Exchange(intptr&,intptr)", ves_icall_System_Threading_Interlocked_Exchange_Object},
static const IcallEntry mutex_icalls [] = {
{"CreateMutex_internal(bool,string,bool&)", ves_icall_System_Threading_Mutex_CreateMutex_internal},
+ {"OpenMutex_internal(string,System.Security.AccessControl.MutexRights,System.IO.MonoIOError&)", ves_icall_System_Threading_Mutex_OpenMutex_internal},
{"ReleaseMutex_internal(intptr)", ves_icall_System_Threading_Mutex_ReleaseMutex_internal}
};
+static const IcallEntry semaphore_icalls [] = {
+ {"CreateSemaphore_internal(int,int,string,bool&)", ves_icall_System_Threading_Semaphore_CreateSemaphore_internal},
+ {"OpenSemaphore_internal(string,System.Security.AccessControl.SemaphoreRights,System.IO.MonoIOError&)", ves_icall_System_Threading_Semaphore_OpenSemaphore_internal},
+ {"ReleaseSemaphore_internal(intptr,int,bool&)", ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal}
+};
+
static const IcallEntry nativeevents_icalls [] = {
{"CloseEvent_internal", ves_icall_System_Threading_Events_CloseEvent_internal},
- {"CreateEvent_internal", ves_icall_System_Threading_Events_CreateEvent_internal},
+ {"CreateEvent_internal(bool,bool,string,bool&)", ves_icall_System_Threading_Events_CreateEvent_internal},
+ {"OpenEvent_internal(string,System.Security.AccessControl.EventWaitHandleRights,System.IO.MonoIOError&)", ves_icall_System_Threading_Events_OpenEvent_internal},
{"ResetEvent_internal", ves_icall_System_Threading_Events_ResetEvent_internal},
{"SetEvent_internal", ves_icall_System_Threading_Events_SetEvent_internal}
};
{"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)},
{"System.Threading.Monitor", monitor_icalls, G_N_ELEMENTS (monitor_icalls)},
{"System.Threading.Mutex", mutex_icalls, G_N_ELEMENTS (mutex_icalls)},
{"System.Threading.NativeEventCalls", nativeevents_icalls, G_N_ELEMENTS (nativeevents_icalls)},
+ {"System.Threading.Semaphore", semaphore_icalls, G_N_ELEMENTS (semaphore_icalls)},
{"System.Threading.Thread", thread_icalls, G_N_ELEMENTS (thread_icalls)},
{"System.Threading.ThreadPool", threadpool_icalls, G_N_ELEMENTS (threadpool_icalls)},
{"System.Threading.WaitHandle", waithandle_icalls, G_N_ELEMENTS (waithandle_icalls)},
g_assert (method != NULL);
+ if (method->is_inflated)
+ method = ((MonoMethodInflated *) method)->declaring;
+
if (method->klass->nested_in) {
int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in);
if (!pos)
projects / mono.git / blobdiff