/*
* 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)
static MonoReflectionMarshal*
ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *field)
{
- MonoClass *klass;
+ MonoClass *klass = field->field->parent;
MonoMarshalType *info;
int i;
- if (strcmp (field->object.vtable->klass->name, "FieldBuilder") == 0)
- return ((MonoReflectionFieldBuilder*)field)->marshal_info;
-
- klass = field->field->parent;
-
if (klass->generic_container ||
(klass->generic_class && klass->generic_class->inst->is_open))
return NULL;
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*
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;
}
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 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)
{
};
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}
};
/* normal icalls again */
{"get_EntryPoint", ves_icall_System_Reflection_Assembly_get_EntryPoint},
{"get_ManifestModule", ves_icall_System_Reflection_Assembly_get_ManifestModule},
- {"get_MetadataToken", mono_reflection_get_token},
{"get_ReflectionOnly", ves_icall_System_Reflection_Assembly_get_ReflectionOnly},
{"get_code_base", ves_icall_System_Reflection_Assembly_get_code_base},
{"get_global_assembly_cache", ves_icall_System_Reflection_Assembly_get_global_assembly_cache},
{"ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken},
{"ResolveStringToken", ves_icall_System_Reflection_Module_ResolveStringToken},
{"ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken},
+ {"get_MDStreamVersion", ves_icall_System_Reflection_Module_get_MDStreamVersion},
{"get_MetadataToken", mono_reflection_get_token}
};
{"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.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