Wed Aug 29 18:37:37 CEST 2007 Paolo Molaro <lupus@ximian.com>

[mono.git] / mono / metadata / debug-helpers.c

diff --git a/mono/metadata/debug-helpers.c b/mono/metadata/debug-helpers.c
index c4491b852a5058385bfb810308803c9ae86272b9..3a79e24fae8c75e68eb9c70c6461f62ba19708a2 100644 (file)
--- a/mono/metadata/debug-helpers.c
+++ b/mono/metadata/debug-helpers.c
@@ -17,36 +17,49 @@ struct MonoMethodDesc {
        gboolean include_namespace;
 };
 
-static const char *wrapper_type_names [] = {
-       "none",
-       "delegate-invoke",
-       "delegate-begin-invoke",
-       "delegate-end-invoke",
-       "runtime-invoke",
-       "native-to-managed",
-       "managed-to-native",
-       "managed-to-managed",
-       "remoting-invoke",
-       "remoting-invoke-with-check",
-       "xdomain-invoke",
-       "xdomain-dispatch",
-       "ldfld",
-       "stfld",
-       "ldfld-remote",
-       "stfld-remote",
-       "synchronized",
-       "dynamic-method",
-       "isinst",
-       "cancast",
-       "proxy_isinst",
-       "stelemref",
-       "unbox",
-       "ldflda",
-       "write-barrier",
-       "unknown",
-       "cominterop-invoke",
-       "cominterop"
+#ifdef HAVE_ARRAY_ELEM_INIT
+#define MSGSTRFIELD(line) MSGSTRFIELD1(line)
+#define MSGSTRFIELD1(line) str##line
+static const struct msgstr_t {
+#define WRAPPER(a,b) char MSGSTRFIELD(__LINE__) [sizeof (b)];
+#include "wrapper-types.h"
+#undef WRAPPER
+} opstr = {
+#define WRAPPER(a,b) b,
+#include "wrapper-types.h"
+#undef WRAPPER
 };
+static const gint16 opidx [] = {
+#define WRAPPER(a,b) [MONO_WRAPPER_ ## a] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
+#include "wrapper-types.h"
+#undef WRAPPER
+};
+
+static const char*
+wrapper_type_to_str (guint32 wrapper_type)
+{
+       g_assert (wrapper_type < MONO_WRAPPER_NUM);
+
+       return (const char*)&opstr + opidx [wrapper_type];
+}
+
+#else
+#define WRAPPER(a,b) b,
+static const char* const
+wrapper_type_names [MONO_WRAPPER_NUM + 1] = {
+#include "wrapper-types.h"
+       NULL
+};
+
+static const char*
+wrapper_type_to_str (guint32 wrapper_type)
+{
+       g_assert (wrapper_type < MONO_WRAPPER_NUM);
+
+       return wrapper_type_names [wrapper_type];
+}
+
+#endif
 
 static void
 append_class_name (GString *res, MonoClass *class, gboolean include_namespace)
@@ -108,7 +121,7 @@ mono_type_get_desc (GString *res, MonoType *type, gboolean include_namespace) {
                g_string_append_c (res, '*');
                break;
        case MONO_TYPE_ARRAY:
-               append_class_name (res, type->data.array->eklass, include_namespace);
+               mono_type_get_desc (res, &type->data.array->eklass->byval_arg, include_namespace);
                g_string_sprintfa (res, "[%d]", type->data.array->rank);
                break;
        case MONO_TYPE_SZARRAY:
@@ -285,13 +298,50 @@ mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method)
        return TRUE;
 }
 
+static const char *
+my_strrchr (const char *str, char ch, int *len)
+{
+       int pos;
+
+       for (pos = (*len)-1; pos >= 0; pos--) {
+               if (str [pos] != ch)
+                       continue;
+
+               *len = pos;
+               return str + pos;
+       }
+
+       return NULL;
+}
+
+static gboolean
+match_class (MonoMethodDesc *desc, int pos, MonoClass *klass)
+{
+       const char *p;
+
+       p = my_strrchr (desc->klass, '/', &pos);
+       if (!p) {
+               if (strncmp (desc->klass, klass->name, pos))
+                       return FALSE;
+               if (desc->namespace && strcmp (desc->namespace, klass->name_space))
+                       return FALSE;
+               return TRUE;
+       }
+
+       if (strcmp (p+1, klass->name))
+               return FALSE;
+       if (!klass->nested_in)
+               return FALSE;
+
+       return match_class (desc, pos, klass->nested_in);
+}
+
 gboolean
 mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
 {
-       if (strcmp (desc->klass, method->klass->name))
-               return FALSE;
-       if (desc->namespace && strcmp (desc->namespace, method->klass->name_space))
+       if (!match_class (desc, strlen (desc->klass), method->klass))
                return FALSE;
+
        return mono_method_desc_match (desc, method);
 }
 
@@ -507,12 +557,16 @@ mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const
        return result;
 }
 
-static const char*
-wrapper_type_to_str (guint32 wrapper_type)
+char *
+mono_field_full_name (MonoClassField *field)
 {
-       g_assert (wrapper_type < sizeof (wrapper_type_names) / sizeof (char*));
+       char *res;
+       const char *nspace = field->parent->name_space;
 
-       return wrapper_type_names [wrapper_type];
+       res = g_strdup_printf ("%s%s%s:%s", nspace, *nspace ? "." : "",
+                                                  field->parent->name, field->name);
+
+       return res;
 }
 
 char *