mono/dis/get.c

   1 /*
   2  * get.c: Functions to get stringified values from the metadata tables.
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9 #include <config.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14 #include <glib.h>
  15 #include "meta.h"
  16 #include "util.h"
  17 #include "get.h"
  18 #include <mono/metadata/class.h>
  19 #include <mono/metadata/marshal.h>
  20
  21 extern gboolean substitute_with_mscorlib_p;
  22
  23 static char *
  24 get_memberref_parent (MonoImage *m, guint32 mrp_token);
  25
  26 GHashTable *key_table = NULL;
  27 gboolean show_method_tokens = FALSE;
  28 gboolean show_tokens = FALSE;
  29
  30 char *
  31 get_typedef (MonoImage *m, int idx)
  32 {
  33         guint32 cols [MONO_TYPEDEF_SIZE];
  34         const char *ns;
  35         char *tstring, *result;
  36         guint32 token;
  37
  38         mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEDEF], idx - 1, cols, MONO_TYPEDEF_SIZE);
  39
  40         ns = mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAMESPACE]);
  41
  42         /* Check if this is a nested type */
  43         token = MONO_TOKEN_TYPE_DEF | (idx);
  44         token = mono_metadata_nested_in_typedef (m, token);
  45         tstring = show_tokens ? g_strdup_printf ("/*%08x*/", token) : NULL;
  46         if (token) {
  47                 char *outer;
  48
  49                 outer = get_typedef (m, mono_metadata_token_index (token));
  50                 result = g_strdup_printf (
  51                         "%s%s%s/%s%s", ns, *ns?".":"", outer,
  52                         mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME]),
  53                         tstring ? tstring : "");
  54                 g_free (outer);
  55                 g_free (tstring);
  56                 return result;
  57         }
  58
  59
  60         result = g_strdup_printf (
  61                 "%s%s%s%s", ns, *ns?".":"",
  62                 mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME]),
  63                 tstring ? tstring : "");
  64         g_free (tstring);
  65         return result;
  66 }
  67
  68 char *
  69 get_module (MonoImage *m, int idx)
  70 {
  71         guint32 cols [MONO_MODULE_SIZE];
  72
  73         /*
  74          * There MUST BE only one module in the Module table
  75          */
  76         g_assert (idx == 1);
  77
  78         mono_metadata_decode_row (&m->tables [MONO_TABLE_MODULE], idx - 1, cols, MONO_MODULE_SIZE);
  79
  80         return g_strdup (mono_metadata_string_heap (m, cols [MONO_MODULE_NAME]));
  81 }
  82
  83 char *
  84 get_moduleref (MonoImage *m, int idx)
  85 {
  86         guint32 cols [MONO_MODULEREF_SIZE];
  87
  88         mono_metadata_decode_row (&m->tables [MONO_TABLE_MODULEREF], idx - 1, cols, MONO_MODULEREF_SIZE);
  89
  90         return g_strdup (mono_metadata_string_heap (m, cols [MONO_MODULEREF_NAME]));
  91 }
  92
  93 char *
  94 get_assemblyref (MonoImage *m, int idx)
  95 {
  96         guint32 cols [MONO_ASSEMBLYREF_SIZE];
  97
  98         mono_metadata_decode_row (&m->tables [MONO_TABLE_ASSEMBLYREF], idx - 1, cols, MONO_ASSEMBLYREF_SIZE);
  99
 100         return g_strdup (mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_NAME]));
 101 }
 102
 103 /*
 104  *
 105  * Returns a string representing the ArrayShape (22.2.16).
 106  */
 107 static const char *
 108 get_array_shape (MonoImage *m, const char *ptr, char **result)
 109 {
 110         GString *res = g_string_new ("[");
 111         guint32 rank, num_sizes, num_lo_bounds;
 112         guint32 *sizes = NULL, *lo_bounds = NULL;
 113         int i, r;
 114         char buffer [80];
 115
 116         rank = mono_metadata_decode_value (ptr, &ptr);
 117         num_sizes = mono_metadata_decode_value (ptr, &ptr);
 118
 119         if (num_sizes > 0)
 120                 sizes = g_new (guint32, num_sizes);
 121
 122         for (i = 0; i < num_sizes; i++)
 123                 sizes [i] = mono_metadata_decode_value (ptr, &ptr);
 124
 125         num_lo_bounds = mono_metadata_decode_value (ptr, &ptr);
 126         if (num_lo_bounds > 0)
 127                 lo_bounds = g_new (guint32, num_lo_bounds);
 128
 129         for (i = 0; i < num_lo_bounds; i++)
 130                 lo_bounds [i] = mono_metadata_decode_value (ptr, &ptr);
 131
 132         for (r = 0; r < rank; r++){
 133                 if (r < num_sizes){
 134                         if (r < num_lo_bounds){
 135                                 sprintf (buffer, "%d..%d", lo_bounds [r], lo_bounds [r] + sizes [r] - 1);
 136                         } else {
 137                                 sprintf (buffer, "0..%d", sizes [r] - 1);
 138                         }
 139                 } else
 140                         buffer [0] = 0;
 141
 142                 g_string_append (res, buffer);
 143                 if ((r + 1) != rank)
 144                         g_string_append (res, ", ");
 145         }
 146         g_string_append (res, "]");
 147
 148         if (sizes)
 149                 g_free (sizes);
 150
 151         if (lo_bounds)
 152                 g_free (lo_bounds);
 153
 154         *result = res->str;
 155         g_string_free (res, FALSE);
 156
 157         return ptr;
 158 }
 159
 160 /**
 161  * get_typespec:
 162  * @m: metadata context
 163  * @blob_idx: index into the blob heap
 164  *
 165  * Returns the stringified representation of a TypeSpec signature (22.2.17)
 166  */
 167 char *
 168 get_typespec (MonoImage *m, guint32 idx)
 169 {
 170         guint32 cols [MONO_TYPESPEC_SIZE];
 171         const char *ptr;
 172         char *s, *result;
 173         GString *res = g_string_new ("");
 174         int len;
 175
 176         MonoType *type;
 177
 178         type = mono_type_create_from_typespec (m, idx);
 179
 180         mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPESPEC], idx-1, cols, MONO_TYPESPEC_SIZE);
 181         ptr = mono_metadata_blob_heap (m, cols [MONO_TYPESPEC_SIGNATURE]);
 182         len = mono_metadata_decode_value (ptr, &ptr);
 183
 184         switch (*ptr++){
 185         case MONO_TYPE_PTR:
 186                 ptr = get_custom_mod (m, ptr, &s);
 187                 if (s){
 188                         g_string_append (res, s);
 189                         g_string_append_c (res, ' ');
 190                         g_free (s);
 191                 }
 192
 193                 if (*ptr == MONO_TYPE_VOID)
 194                         g_string_append (res, "void");
 195                 else {
 196                         ptr = get_type (m, ptr, &s);
 197                         if (s)
 198                                 g_string_append (res, s);
 199                 }
 200                 break;
 201
 202         case MONO_TYPE_FNPTR:
 203                 g_string_append (res, "FNPTR ");
 204                 /*
 205                  * we assume MethodRefSig, as we do not know
 206                  * whether it is a MethodDefSig or a MethodRefSig.
 207                  */
 208                 printf ("\n FNPTR:\n");
 209
 210                 hex_dump (ptr, 0, 40);
 211                 break;
 212
 213         case MONO_TYPE_ARRAY:
 214                 ptr = get_type (m, ptr, &s);
 215                 g_string_append (res, s);
 216                 g_free (s);
 217                 g_string_append_c (res, ' ');
 218                 ptr = get_array_shape (m, ptr, &s);
 219                 g_string_append (res, s);
 220                 g_free (s);
 221                 break;
 222
 223         case MONO_TYPE_SZARRAY:
 224                 ptr = get_custom_mod (m, ptr, &s);
 225                 if (s){
 226                         g_string_append (res, s);
 227                         g_string_append_c (res, ' ');
 228                         g_free (s);
 229                 }
 230                 ptr = get_type (m, ptr, &s);
 231                 g_string_append (res, s);
 232                 g_string_append (res, "[]");
 233                 g_free (s);
 234                 break;
 235
 236         case MONO_TYPE_VAR:
 237         case MONO_TYPE_MVAR:
 238                 ptr = get_type (m, ptr-1, &s);
 239                 g_string_append (res, s);
 240                 g_free (s);
 241                 break;
 242
 243         default:
 244                 s = dis_stringify_type (m, type);
 245                 g_string_append (res, s);
 246                 g_free (s);
 247                 break;
 248         }
 249
 250         if (show_tokens) {
 251                 int token = mono_metadata_make_token (MONO_TABLE_TYPESPEC, idx);
 252                 result = g_strdup_printf ("%s/*%08x*/", res->str, token);
 253         } else
 254                 result = res->str;
 255
 256         g_string_free (res, FALSE);
 257
 258         return result;
 259 }
 260
 261 char *
 262 get_typeref (MonoImage *m, int idx)
 263 {
 264         guint32 cols [MONO_TYPEREF_SIZE];
 265         const char *s, *t;
 266         char *x, *ret;
 267         guint32 rs_idx, table;
 268
 269         mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEREF], idx - 1, cols, MONO_TYPEREF_SIZE);
 270
 271         t = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]);
 272         s = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]);
 273
 274         rs_idx = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
 275         table = cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
 276
 277         switch (table){
 278         case RESOLTION_SCOPE_MODULE: /* Module */
 279                 x = get_module (m, rs_idx);
 280                 ret = g_strdup_printf ("[%s] %s%s%s", x, s, *s?".":"", t);
 281                 g_free (x);
 282                 break;
 283
 284         case RESOLTION_SCOPE_MODULEREF: /* ModuleRef */
 285                 x = get_moduleref (m, rs_idx);
 286                 ret = g_strdup_printf ("[.module %s]%s%s%s", x, s, *s ? "." : "", t);
 287                 break;
 288
 289         case RESOLTION_SCOPE_ASSEMBLYREF: /*
 290                  * AssemblyRef (ECMA docs claim it is 3, but it looks to
 291                  * me like it is 2 (tokens are prefixed with 0x23)
 292                  */
 293                 x = get_assemblyref (m, rs_idx);
 294                 ret = g_strdup_printf ("[%s]%s%s%s", x, s, *s?".":"", t);
 295                 g_free (x);
 296                 break;
 297
 298         case RESOLTION_SCOPE_TYPEREF: /* TypeRef */
 299                 x = get_typeref (m, rs_idx);
 300                 ret =  g_strdup_printf ("%s/%s", x, t);
 301                 g_free (x);
 302                 break;
 303
 304         default:
 305                 ret = g_strdup_printf ("Unknown table in TypeRef %d", table);
 306         }
 307
 308         if (show_tokens) {
 309                 int token = mono_metadata_make_token (MONO_TABLE_TYPEREF, idx);
 310                 char *temp = g_strdup_printf ("%s/*%08x*/", ret, token);
 311                 g_free (ret);
 312                 ret = temp;
 313         }
 314
 315         return ret;
 316 }
 317
 318 /**
 319  * get_typedef_or_ref:
 320  * @m: metadata context
 321  * @dor_token: def or ref encoded index
 322  *
 323  * Low two bits contain table to lookup from
 324  * high bits contain the index into the def or ref table
 325  *
 326  * Returns: a stringified version of the MethodDef or MethodRef
 327  * at (dor_token >> 2)
 328  */
 329 char *
 330 get_typedef_or_ref (MonoImage *m, guint32 dor_token)
 331 {
 332         char *temp = NULL, *s = NULL;
 333         int table, idx;
 334
 335         /*
 336          * low 2 bits contain encoding
 337          */
 338         table = dor_token & TYPEDEFORREF_MASK;
 339         idx = dor_token >> TYPEDEFORREF_BITS;
 340
 341         switch (table){
 342         case 0: /* TypeDef */
 343                 temp = get_typedef (m, idx);
 344                 s = g_strdup_printf ("%s", temp);
 345                 break;
 346
 347         case 1: /* TypeRef */
 348                 temp = get_typeref (m, idx);
 349                 s = g_strdup_printf ("%s", temp);
 350                 break;
 351
 352         case 2: /* TypeSpec */
 353                 s = get_typespec (m, idx);
 354                 break;
 355
 356         default:
 357                 g_error ("Unhandled encoding for typedef-or-ref coded index 0x%08x", dor_token);
 358
 359         }
 360
 361         if (temp)
 362                 g_free (temp);
 363
 364         return s;
 365 }
 366
 367 /**
 368  * get_type_or_methdef
 369  * @m: metadata context
 370  * @dor_token: type or method def encoded index
 371  *
 372  * Low bit contains the table to lookup from
 373  * high bits contain the index into the type def or method def table
 374  *
 375  * Returns: a stringified version of the TypeOrMethodDef token
 376  */
 377 char *
 378 get_type_or_methdef (MonoImage *m, guint32 dor_token)
 379 {
 380         if (dor_token & MONO_TYPEORMETHOD_METHOD) /* MethodDef */
 381                 return get_methoddef (m, dor_token >> MONO_TYPEORMETHOD_BITS);
 382         else  /* TypeDef */
 383                 return get_typedef (m, dor_token >> MONO_TYPEORMETHOD_BITS);
 384 }
 385
 386 /**
 387  * get_encoded_typedef_or_ref:
 388  * @m: metadata context
 389  * @ptr: location to decode from.
 390  * @result: pointer to string where resulting decoded string is stored
 391  *
 392  * result will point to a g_malloc()ed string.
 393  *
 394  * Returns: the new ptr to continue decoding
 395  */
 396 const char *
 397 get_encoded_typedef_or_ref (MonoImage *m, const char *ptr, char **result)
 398 {
 399         guint32 token;
 400
 401         token = mono_metadata_decode_value (ptr, &ptr);
 402
 403         *result = get_typedef_or_ref (m, token);
 404
 405         return ptr;
 406 }
 407
 408 /**
 409  * get_custom_mod:
 410  *
 411  * Decodes a CustomMod (22.2.7)
 412  *
 413  * Returns: updated pointer location
 414  */
 415 const char *
 416 get_custom_mod (MonoImage *m, const char *ptr, char **return_value)
 417 {
 418         char *s;
 419         const char *reqd;
 420
 421         *return_value = NULL;
 422         while ((*ptr == MONO_TYPE_CMOD_OPT) ||
 423                    (*ptr == MONO_TYPE_CMOD_REQD)) {
 424                 reqd = (*ptr == MONO_TYPE_CMOD_REQD) ? "reqd" : "opt";
 425                 ptr++;
 426                 ptr = get_encoded_typedef_or_ref (m, ptr, &s);
 427
 428                 if (*return_value == NULL)
 429                         *return_value = g_strconcat (reqd, " ", s, NULL);
 430                 else
 431                         *return_value = g_strconcat (*return_value, " ", reqd, " ", s, NULL);
 432                 g_free (s);
 433         }
 434         return ptr;
 435 }
 436
 437
 438 static dis_map_t element_type_map [] = {
 439         { MONO_TYPE_END        , "end" },
 440         { MONO_TYPE_VOID       , "void" },
 441         { MONO_TYPE_BOOLEAN    , "bool" },
 442         { MONO_TYPE_CHAR       , "char" },
 443         { MONO_TYPE_I1         , "int8" },
 444         { MONO_TYPE_U1         , "unsigned int8" },
 445         { MONO_TYPE_I2         , "int16" },
 446         { MONO_TYPE_U2         , "unsigned int16" },
 447         { MONO_TYPE_I4         , "int32" },
 448         { MONO_TYPE_U4         , "unsigned int32" },
 449         { MONO_TYPE_I8         , "int64" },
 450         { MONO_TYPE_U8         , "unsigned int64" },
 451         { MONO_TYPE_R4         , "float32" },
 452         { MONO_TYPE_R8         , "float64" },
 453         { MONO_TYPE_STRING     , "string" },
 454         { MONO_TYPE_TYPEDBYREF , "TypedByRef" },
 455         { MONO_TYPE_I          , "native int" },
 456         { MONO_TYPE_U          , "native unsigned int" },
 457         { MONO_TYPE_OBJECT     , "object" },
 458         { 0, NULL }
 459 };
 460
 461 static dis_map_t call_conv_type_map [] = {
 462         { MONO_CALL_DEFAULT     , "default" },
 463         { MONO_CALL_C           , "c" },
 464         { MONO_CALL_STDCALL     , "stdcall" },
 465         { MONO_CALL_THISCALL    , "thiscall" },
 466         { MONO_CALL_FASTCALL    , "fastcall" },
 467         { MONO_CALL_VARARG      , "vararg" },
 468         { 0, NULL }
 469 };
 470
 471 char*
 472 dis_stringify_token (MonoImage *m, guint32 token)
 473 {
 474         guint idx = token & 0xffffff;
 475         switch (token >> 24) {
 476         case MONO_TABLE_TYPEDEF: return get_typedef (m, idx);
 477         case MONO_TABLE_TYPEREF: return get_typeref (m, idx);
 478         case MONO_TABLE_TYPESPEC: return get_typespec (m, idx);
 479         default:
 480                  break;
 481         }
 482         return g_strdup_printf("0x%08x", token);
 483 }
 484
 485 char*
 486 dis_stringify_array (MonoImage *m, MonoArrayType *array)
 487 {
 488         char *type;
 489         GString *s = g_string_new("");
 490         int i;
 491
 492         type = dis_stringify_type (m, &array->eklass->byval_arg);
 493         g_string_append (s, type);
 494         g_free (type);
 495         g_string_append_c (s, '[');
 496         for (i = 0; i < array->rank; ++i) {
 497                 if (i)
 498                         g_string_append_c (s, ',');
 499                 if (i < array->numsizes) {
 500                         if (i < array->numlobounds && array->lobounds[i] != 0)
 501                                 g_string_sprintfa (s, "%d..%d", array->lobounds[i], array->sizes[i]);
 502                         else
 503                                 g_string_sprintfa (s, "%d", array->sizes[i]);
 504                 }
 505         }
 506         g_string_append_c (s, ']');
 507         type = s->str;
 508         g_string_free (s, FALSE);
 509         return type;
 510 }
 511
 512 char*
 513 dis_stringify_modifiers (MonoImage *m, int n, MonoCustomMod *mod)
 514 {
 515         GString *s = g_string_new("");
 516         char *result;
 517         int i;
 518         for (i = 0; i < n; ++i) {
 519                 char *tok = dis_stringify_token (m, mod[i].token);
 520                 if (i > 0)
 521                         g_string_sprintfa (s, " ");
 522                 g_string_sprintfa (s, "%s (%s)", mod[i].required ? "modreq": "modopt", tok);
 523                 g_free (tok);
 524         }
 525         g_string_append_c (s, ' ');
 526         result = s->str;
 527         g_string_free (s, FALSE);
 528         return result;
 529 }
 530
 531 char*
 532 dis_stringify_param (MonoImage *m, MonoType *param)
 533 {
 534         char *t;
 535         char *result;
 536         const char *out = param->attrs & 2 ? "[out] ": "";
 537         t = dis_stringify_type (m, param);
 538         result = g_strconcat (out, t, NULL);
 539         g_free (t);
 540         return result;
 541 }
 542
 543 /**
 544  * get_generic_param
 545  * @m: metadata context
 546  * @table_type: The type of table we are getting generics for (0 for typedef, 1 for method)
 547  * @row: The row in the table
 548  *
 549  * Returns: Allocated stringified generic parameters
 550  */
 551 char*
 552 get_generic_param (MonoImage *m, int table_type, guint32 row)
 553 {
 554         MonoTableInfo *t = &m->tables [MONO_TABLE_GENERICPARAM];
 555         GString *result = g_string_new ("");
 556         char *retval;
 557         guint32 cols [MONO_GENERICPARAM_SIZE];
 558         int i, own_tok, table, idx, found_count;
 559
 560         g_assert (table_type != MONO_TYPEORMETHOD_TYPE || table_type != MONO_TYPEORMETHOD_METHOD);
 561
 562         found_count = 0;
 563         for (i = 1; i <= t->rows; i++) {
 564                 mono_metadata_decode_row (t, i-1, cols, MONO_GENERICPARAM_SIZE);
 565                 own_tok = cols [MONO_GENERICPARAM_OWNER];
 566                 table = own_tok & MONO_TYPEORMETHOD_MASK;
 567                 idx = own_tok >> MONO_TYPEORMETHOD_BITS;
 568
 569                 if (table != table_type || idx != row)
 570                         continue;
 571
 572                 if (found_count == 0)
 573                         g_string_append_printf (result, "<%s",
 574                                         mono_metadata_string_heap (m, cols [MONO_GENERICPARAM_NAME]));
 575                 else
 576                         g_string_append_printf (result, ", %s",
 577                                         mono_metadata_string_heap (m, cols [MONO_GENERICPARAM_NAME]));
 578                 found_count++;
 579         }
 580
 581         if (found_count)
 582                 g_string_append_c (result, '>');
 583         retval = result->str;
 584         g_string_free (result, FALSE);
 585         return retval;
 586 }
 587
 588 char*
 589 dis_stringify_method_signature (MonoImage *m, MonoMethodSignature *method, int methoddef_row, gboolean fully_qualified)
 590 {
 591         guint32 cols [MONO_METHOD_SIZE];
 592         guint32 pcols [MONO_PARAM_SIZE];
 593         guint32 param_index = 0;
 594         const char *name = "";
 595         int free_method = 0;
 596         char *retval, *esname;
 597         char *type = NULL;
 598         char *gen_param = NULL;
 599         GString *result = g_string_new ("");
 600         int i;
 601
 602         g_assert (method || methoddef_row);
 603
 604         if (methoddef_row) {
 605                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD], methoddef_row -1, cols, MONO_METHOD_SIZE);
 606                 if (fully_qualified)
 607                         type = get_typedef (m, mono_metadata_typedef_from_method (m, methoddef_row));
 608                 name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]);
 609                 param_index = cols [MONO_METHOD_PARAMLIST];
 610                 if (!method) {
 611                         const char *sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
 612                         mono_metadata_decode_blob_size (sig, &sig);
 613                         method = mono_metadata_parse_method_signature (m, methoddef_row, sig, &sig);
 614                         free_method = 1;
 615                 }
 616                 gen_param = get_generic_param (m, 1, methoddef_row);
 617         }
 618
 619         retval = dis_stringify_param (m, method->ret);
 620         if (method->hasthis)
 621                 g_string_append (result, "instance ");
 622         g_string_append (result, map (method->call_convention, call_conv_type_map));
 623         g_string_sprintfa (result, " %s ", retval);
 624         if (type) {
 625                 char *estype = get_escaped_name (type);
 626                 g_string_sprintfa (result, "%s::", estype);
 627                 g_free (estype);
 628         }
 629         esname = get_escaped_name (name);
 630         g_string_append (result, esname);
 631         g_free (esname);
 632         if (gen_param) {
 633                 g_string_append (result, gen_param);
 634                 g_free (gen_param);
 635         }
 636         g_string_append (result, " (");
 637         g_free (retval);
 638         for (i = 0; i < method->param_count; ++i) {
 639                 if (param_index && param_index <= m->tables [MONO_TABLE_PARAM].rows) {
 640                         mono_metadata_decode_row (&m->tables [MONO_TABLE_PARAM], param_index - 1, pcols, MONO_PARAM_SIZE);
 641                         name = mono_metadata_string_heap (m, pcols [MONO_PARAM_NAME]);
 642                         method->params [i]->attrs = pcols [MONO_PARAM_FLAGS];
 643                         param_index++;
 644                 } else {
 645                         name = "";
 646                 }
 647                 if (i)
 648                         g_string_append (result, ", ");
 649                 retval = dis_stringify_param (m, method->params [i]);
 650                 esname = get_escaped_name (name);
 651                 g_string_append_printf (result, "%s %s", retval, esname);
 652                 g_free (retval);
 653                 g_free (esname);
 654         }
 655         g_string_append (result, ") ");
 656
 657         if (show_method_tokens && methoddef_row)
 658                 g_string_append_printf (result, " /* 0x%X */ ",
 659                                 (methoddef_row >> MONO_TYPEORMETHOD_BITS) | MONO_TOKEN_METHOD_DEF);
 660
 661         if (free_method)
 662                 mono_metadata_free_method_signature (method);
 663         retval = result->str;
 664         g_string_free (result, FALSE);
 665
 666         return retval;
 667 }
 668
 669 static char *
 670 dis_stringify_object_with_class (MonoImage *m, MonoClass *c)
 671 {
 672         /* FIXME: handle MONO_TYPE_OBJECT ... */
 673         const char *otype = c->byval_arg.type == MONO_TYPE_CLASS? "class" : "valuetype";
 674         char *assemblyref = NULL, *result, *esname;
 675         if (m != c->image) {
 676                 if (c->image->assembly_name) {
 677                         /* we cheat */
 678                         if (substitute_with_mscorlib_p && !strcmp ("corlib", c->image->assembly_name))
 679                                 assemblyref = g_strdup_printf ("[%s]", "mscorlib");
 680                         else
 681                                 assemblyref = g_strdup_printf ("[%s]", c->image->assembly->aname.name);
 682                 } else {
 683                         assemblyref = g_strdup_printf ("[.module %s]", c->image->module_name);
 684                 }
 685         }
 686
 687         if (c->nested_in) {
 688                 result = g_strdup_printf ("%s%s%s/%s", c->nested_in->name_space,
 689                                 *c->nested_in->name_space?".":"", c->nested_in->name,
 690                                 c->name);
 691         } else {
 692                 result = g_strdup_printf ("%s%s%s", c->name_space,
 693                                 *c->name_space?".":"", c->name);
 694         }
 695
 696         esname = get_escaped_name (result);
 697         g_free (result);
 698
 699         result = g_strdup_printf ("%s %s%s", otype, assemblyref?assemblyref:"", esname);
 700
 701         g_free (assemblyref);
 702         g_free (esname);
 703
 704         return result;
 705 }
 706
 707 static char *
 708 dis_stringify_object (MonoImage *m, MonoType *type)
 709 {
 710         MonoClass *c = mono_class_from_mono_type (type);
 711         return dis_stringify_object_with_class (m, c);
 712 }
 713
 714 char*
 715 dis_stringify_type (MonoImage *m, MonoType *type)
 716 {
 717         const char *pinned = "", *byref = "";
 718         char *bare = NULL, *mods = NULL;
 719         char *result;
 720
 721         if (type->num_mods)
 722                 mods = dis_stringify_modifiers (m, type->num_mods, type->modifiers);
 723
 724         switch (type->type){
 725         case MONO_TYPE_BOOLEAN:
 726         case MONO_TYPE_CHAR:
 727         case MONO_TYPE_I1:
 728         case MONO_TYPE_U1:
 729         case MONO_TYPE_I2:
 730         case MONO_TYPE_U2:
 731         case MONO_TYPE_I4:
 732         case MONO_TYPE_U4:
 733         case MONO_TYPE_I8:
 734         case MONO_TYPE_U8:
 735         case MONO_TYPE_R4:
 736         case MONO_TYPE_R8:
 737         case MONO_TYPE_I:
 738         case MONO_TYPE_U:
 739         case MONO_TYPE_STRING:
 740         case MONO_TYPE_OBJECT:
 741         case MONO_TYPE_TYPEDBYREF:
 742                 bare = g_strdup (map (type->type, element_type_map));
 743                 break;
 744
 745         case MONO_TYPE_VALUETYPE:
 746         case MONO_TYPE_CLASS:
 747                 bare = dis_stringify_object (m, type);
 748                 break;
 749
 750         case MONO_TYPE_FNPTR:
 751                 bare = dis_stringify_method_signature (m, type->data.method, 0, FALSE);
 752                 break;
 753         case MONO_TYPE_PTR: {
 754                 char *child_type;
 755                 child_type = dis_stringify_type (m, type->data.type);
 756
 757                 bare = g_strdup_printf ("%s*", child_type);
 758                 g_free (child_type);
 759                 break;
 760         }
 761         case MONO_TYPE_SZARRAY: {
 762                 char *child_type;
 763                 child_type = dis_stringify_type (m, &type->data.klass->byval_arg);
 764
 765                 bare = g_strdup_printf ("%s[]", child_type);
 766                 g_free (child_type);
 767                 break;
 768         }
 769         case MONO_TYPE_ARRAY:
 770                 bare = dis_stringify_array (m, type->data.array);
 771                 break;
 772         case MONO_TYPE_VOID:
 773                 bare = g_strdup ("void");
 774                 break;
 775         case MONO_TYPE_MVAR:
 776                 bare = g_strdup_printf ("!!%d", type->data.generic_param->num);
 777                 break;
 778         case MONO_TYPE_VAR:
 779                 bare = g_strdup_printf ("!%d", type->data.generic_param->num);
 780                 break;
 781         case MONO_TYPE_GENERICINST: {
 782                 GString *str = g_string_new ("");
 783                 int i;
 784                 char *generic_type = dis_stringify_type (m, type->data.generic_inst->generic_type);
 785
 786                 for (i = 0; i < type->data.generic_inst->type_argc; i++){
 787                         char *t = dis_stringify_type (m, type->data.generic_inst->type_argv [i]);
 788
 789                         g_string_append (str, t);
 790                         if (i+1 != type->data.generic_inst->type_argc)
 791                                 g_string_append (str, ", ");
 792                         g_free (t);
 793                 }
 794                 bare = g_strdup_printf ("%s<%s>", generic_type, str->str);
 795                 g_string_free (str, TRUE);
 796                 break;
 797         }
 798
 799         default:
 800                 g_error ("Do not know how to stringify type 0x%x", type->type);
 801         }
 802
 803         if (type->pinned)
 804                 pinned = " pinned";
 805
 806         if (type->byref)
 807                 byref = "&";
 808
 809         result = g_strconcat (mods ? mods : "", bare, byref, pinned, NULL);
 810
 811         g_free (bare);
 812
 813         return result;
 814 }
 815
 816 /**
 817  * get_type:
 818  * @m: metadata context
 819  * @ptr: location to decode from.
 820  * @result: pointer to string where resulting decoded string is stored
 821  *
 822  * This routine returs in @result the stringified type pointed by @ptr.
 823  * (22.2.12)
 824  *
 825  * Returns: the new ptr to continue decoding
 826  */
 827 const char *
 828 get_type (MonoImage *m, const char *ptr, char **result)
 829 {
 830         const char *start = ptr;
 831         guint32 type;
 832         MonoType *t;
 833
 834         if (*ptr == MONO_TYPE_BYREF)
 835                 ++ptr;
 836
 837         type = mono_metadata_decode_value (ptr, &ptr);
 838
 839         switch (type){
 840         case MONO_TYPE_VALUETYPE:
 841         case MONO_TYPE_CLASS: {
 842                 guint32 token = mono_metadata_parse_typedef_or_ref (m, ptr, &ptr);
 843                 MonoClass *klass = mono_class_get (m, token);
 844                 char *temp = dis_stringify_object_with_class (m, klass);
 845
 846                 if (show_tokens) {
 847                         *result = g_strdup_printf ("%s/*%08x*/", temp, token);
 848                         g_free (temp);
 849                 } else
 850                         *result = temp;
 851                 break;
 852         }
 853
 854         case MONO_TYPE_GENERICINST: {
 855                 GString *str = g_string_new ("");
 856                 int count, i;
 857                 char *temp;
 858
 859                 ptr = get_type (m, ptr, &temp);
 860                 g_string_append (str, temp);
 861                 g_free (temp);
 862
 863                 count = mono_metadata_decode_value (ptr, &ptr);
 864                 g_string_append (str, "<");
 865
 866                 for (i = 0; i < count; i++) {
 867                         if (i)
 868                                 g_string_append (str, ",");
 869                         ptr = get_type (m, ptr, &temp);
 870                         g_string_append (str, temp);
 871                 }
 872
 873                 g_string_append (str, ">");
 874                 *result = str->str;
 875                 g_string_free (str, FALSE);
 876                 break;
 877         }
 878
 879         default:
 880                 t = mono_metadata_parse_type (m, MONO_PARSE_TYPE, 0, start, &ptr);
 881                 *result = dis_stringify_type (m, t);
 882                 mono_metadata_free_type (t);
 883                 break;
 884         }
 885
 886         return ptr;
 887 }
 888
 889 /**
 890  *
 891  * Returns a stringified representation of a FieldSig (22.2.4)
 892  */
 893 char *
 894 get_field_signature (MonoImage *m, guint32 blob_signature)
 895 {
 896         char *allocated_modifier_string, *allocated_type_string;
 897         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
 898         const char *base;
 899         char *res;
 900         int len;
 901
 902         len = mono_metadata_decode_value (ptr, &ptr);
 903         base = ptr;
 904         /* FIELD is 0x06 */
 905         g_assert (*ptr == 0x06);
 906 /*      hex_dump (ptr, 0, len); */
 907         ptr++; len--;
 908
 909         ptr = get_custom_mod (m, ptr, &allocated_modifier_string);
 910         ptr = get_type (m, ptr, &allocated_type_string);
 911
 912         res = g_strdup_printf (
 913                 "%s %s",
 914                 allocated_modifier_string ? allocated_modifier_string : "",
 915                 allocated_type_string);
 916
 917         if (allocated_modifier_string)
 918                 g_free (allocated_modifier_string);
 919         if (allocated_type_string)
 920                 g_free (allocated_type_string);
 921
 922         return res;
 923 }
 924
 925 MonoTypeEnum
 926 get_field_literal_type (MonoImage *m, guint32 blob_signature)
 927 {
 928         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
 929         int len;
 930         char *allocated_modifier_string;
 931
 932         len = mono_metadata_decode_value (ptr, &ptr);
 933
 934         /* FIELD is 0x06 */
 935         g_assert (*ptr == 0x06);
 936         ptr++; len--;
 937
 938         ptr = get_custom_mod (m, ptr, &allocated_modifier_string);
 939         if (allocated_modifier_string)
 940                 g_free (allocated_modifier_string);
 941
 942         return (MonoTypeEnum) *ptr;
 943
 944 }
 945
 946 /**
 947  * decode_literal:
 948  * @m: metadata context
 949  * @token: token to decode
 950  *
 951  * decodes the literal indexed by @token.
 952  */
 953 char *
 954 decode_literal (MonoImage *m, guint32 token)
 955 {
 956         return g_strdup ("LITERAL_VALUE");
 957 }
 958
 959 /**
 960  * get_ret_type:
 961  * @m: metadata context
 962  * @ptr: location to decode from.
 963  * @result: pointer to string where resulting decoded string is stored
 964  *
 965  * This routine returns in @result the stringified RetType (22.2.11)
 966  *
 967  * Returns: the new ptr to continue decoding.
 968  */
 969 const char *
 970 get_ret_type (MonoImage *m, const char *ptr, char **ret_type)
 971 {
 972         GString *str = g_string_new ("");
 973         char *mod = NULL;
 974         char *allocated_type_string;
 975
 976         ptr = get_custom_mod (m, ptr, &mod);
 977         if (mod){
 978                 g_string_append (str, mod);
 979                 g_string_append_c (str, ' ');
 980                 g_free (mod);
 981         }
 982
 983         if (*ptr == MONO_TYPE_TYPEDBYREF){
 984                 g_string_append (str, "typedbyref");
 985                 ptr++;
 986         } else if (*ptr == MONO_TYPE_VOID){
 987                  g_string_append (str, "void");
 988                  ptr++;
 989         } else {
 990                 if (*ptr == MONO_TYPE_BYREF){
 991                         g_string_append (str, "[out] ");
 992                         ptr++;
 993                 }
 994
 995                 ptr = get_type (m, ptr, &allocated_type_string);
 996                 g_string_append (str, allocated_type_string);
 997                 g_free (allocated_type_string);
 998         }
 999
1000         *ret_type = str->str;
1001         g_string_free (str, FALSE);
1002
1003         return ptr;
1004 }
1005
1006 /**
1007  * get_param:
1008  * @m: metadata context
1009  * @ptr: location to decode from.
1010  * @result: pointer to string where resulting decoded string is stored
1011  *
1012  * This routine returns in @result the stringified Param (22.2.10)
1013  *
1014  * Returns: the new ptr to continue decoding.
1015  */
1016 const char *
1017 get_param (MonoImage *m, const char *ptr, char **retval)
1018 {
1019         GString *str = g_string_new ("");
1020         char *allocated_mod_string, *allocated_type_string;
1021
1022         ptr = get_custom_mod (m, ptr, &allocated_mod_string);
1023         if (allocated_mod_string){
1024                 g_string_append (str, allocated_mod_string);
1025                 g_string_append_c (str, ' ');
1026                 g_free (allocated_mod_string);
1027         }
1028
1029         if (*ptr == MONO_TYPE_TYPEDBYREF){
1030                 g_string_append (str, " typedbyref ");
1031                 ptr++;
1032         } else {
1033                 gboolean by_ref = 0;
1034                  if (*ptr == MONO_TYPE_BYREF){
1035                         g_string_append (str, "[out] ");
1036                         ptr++;
1037                         by_ref = 1;
1038                 }
1039                 ptr = get_type (m, ptr, &allocated_type_string);
1040                 g_string_append (str, allocated_type_string);
1041                 if (by_ref)
1042                         g_string_append_c (str, '&');
1043                 g_free (allocated_type_string);
1044         }
1045
1046         *retval = str->str;
1047         g_string_free (str, FALSE);
1048         return ptr;
1049 }
1050
1051 /**
1052  * get_escaped_name
1053  *
1054  * Returns: An allocated escaped name. A name needs to be escaped
1055  * because it might be an ilasm keyword.
1056  */
1057 char*
1058 get_escaped_name (const char *name)
1059 {
1060         const char *s;
1061
1062         g_assert (key_table);
1063
1064         if (strcmp (name, ".ctor") == 0 || strcmp (name, ".cctor") == 0)
1065                 return g_strdup (name);
1066
1067         s = name;
1068         while (s++) {
1069                 if (isalnum (*s) || *s == '_' || *s == '$' || *s == '@' || *s == '?' || *s == '.')
1070                         continue;
1071                 return g_strdup_printf ("'%s'", name);
1072         }
1073
1074         if (g_hash_table_lookup (key_table, name))
1075                 return g_strdup_printf ("'%s'", name);
1076
1077         return g_strdup (name);
1078 }
1079
1080 static dis_map_t param_map [] = {
1081         { PARAM_ATTRIBUTE_IN,                "[in] " },
1082         { PARAM_ATTRIBUTE_OUT,               "[out] " },
1083         { PARAM_ATTRIBUTE_OPTIONAL,          "optional " },
1084         { PARAM_ATTRIBUTE_HAS_DEFAULT,       "hasdefault " },
1085         { PARAM_ATTRIBUTE_HAS_FIELD_MARSHAL, "fieldmarshal " },
1086         { 0, NULL }
1087 };
1088
1089 char *
1090 param_flags (guint32 f)
1091 {
1092         return g_strdup (flags (f, param_map));
1093 }
1094
1095 static dis_map_t field_access_map [] = {
1096         { FIELD_ATTRIBUTE_COMPILER_CONTROLLED, "compilercontrolled " },
1097         { FIELD_ATTRIBUTE_PRIVATE,             "private " },
1098         { FIELD_ATTRIBUTE_FAM_AND_ASSEM,       "famandassem " },
1099         { FIELD_ATTRIBUTE_ASSEMBLY,            "assembly " },
1100         { FIELD_ATTRIBUTE_FAMILY,              "family " },
1101         { FIELD_ATTRIBUTE_FAM_OR_ASSEM,        "famorassem " },
1102         { FIELD_ATTRIBUTE_PUBLIC,              "public " },
1103         { 0, NULL }
1104 };
1105
1106 static dis_map_t field_flags_map [] = {
1107         { FIELD_ATTRIBUTE_STATIC,              "static " },
1108         { FIELD_ATTRIBUTE_INIT_ONLY,           "initonly " },
1109         { FIELD_ATTRIBUTE_LITERAL,             "literal " },
1110         { FIELD_ATTRIBUTE_NOT_SERIALIZED,      "notserialized " },
1111         { FIELD_ATTRIBUTE_SPECIAL_NAME,        "specialname " },
1112         { FIELD_ATTRIBUTE_PINVOKE_IMPL,        "FIXME:pinvokeimpl " },
1113         { FIELD_ATTRIBUTE_RT_SPECIAL_NAME,        "rtspecialname " },
1114         { FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL,        "hasfieldmarshal " },
1115         { 0, NULL }
1116 };
1117
1118 /**
1119  * field_flags:
1120  *
1121  * Returns a stringified version of a Field's flags
1122  */
1123 char *
1124 field_flags (guint32 f)
1125 {
1126         char buffer [1024];
1127         int access = f & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK;
1128
1129         buffer [0] = 0;
1130
1131         strcat (buffer, map (access, field_access_map));
1132         strcat (buffer, flags (f, field_flags_map));
1133         return g_strdup (buffer);
1134 }
1135
1136 /**
1137  * Returns a stringifed representation of a MethodRefSig (22.2.2)
1138  */
1139 char *
1140 get_methodref_signature (MonoImage *m, guint32 blob_signature, const char *fancy_name)
1141 {
1142         GString *res = g_string_new ("");
1143         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
1144         char *allocated_ret_type, *s;
1145         gboolean seen_vararg = 0;
1146         int param_count, signature_len;
1147         int i, gen_count = 0;
1148         int cconv;
1149
1150         signature_len = mono_metadata_decode_value (ptr, &ptr);
1151
1152         if (*ptr & 0x20){
1153                 if (*ptr & 0x40)
1154                         g_string_append (res, "explicit-this ");
1155                 else
1156                         g_string_append (res, "instance "); /* has-this */
1157         }
1158
1159         if (*ptr & 0x05)
1160                 seen_vararg = 1;
1161         if (*ptr & 0x10)
1162                 gen_count = 1;
1163         cconv = *ptr & 0x0f;
1164         ptr++;
1165         if (gen_count)
1166                 gen_count = mono_metadata_decode_value (ptr, &ptr);
1167         param_count = mono_metadata_decode_value (ptr, &ptr);
1168         if (cconv != 0xa) {
1169                 ptr = get_ret_type (m, ptr, &allocated_ret_type);
1170                 g_string_append (res, allocated_ret_type);
1171                 g_free (allocated_ret_type);
1172         }
1173
1174         if (fancy_name){
1175                 g_string_append_c (res, ' ');
1176                 g_string_append (res, fancy_name);
1177         }
1178
1179         g_string_append (res, "(");
1180
1181         /*
1182          * param_count describes parameters *before* and *after*
1183          * the vararg sentinel
1184          */
1185         for (i = 0; i < param_count; i++){
1186                 char *param = NULL;
1187
1188                 /*
1189                  * If ptr is a SENTINEL
1190                  */
1191                 if (*ptr == 0x41){
1192                         g_string_append (res, " varargs ");
1193                         continue;
1194                 }
1195
1196                 ptr = get_param (m, ptr, &param);
1197                 g_string_append (res, param);
1198                 if (i+1 != param_count)
1199                         g_string_append (res, ", ");
1200                 g_free (param);
1201         }
1202         g_string_append (res, ")");
1203
1204         /*
1205          * cleanup and return
1206          */
1207         s = res->str;
1208         g_string_free (res, FALSE);
1209         return s;
1210 }
1211
1212 /**
1213  * Returns a stringifed representation of a field ref
1214  */
1215 char *
1216 get_fieldref_signature (MonoImage *m, int idx)
1217 {
1218         guint32 cols [MONO_MEMBERREF_SIZE];
1219         char *sig;
1220         char *full_sig;
1221
1222         mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1223                         idx - 1, cols, MONO_MEMBERREF_SIZE);
1224
1225         sig = get_field_signature (m, cols [MONO_MEMBERREF_SIGNATURE]);
1226         full_sig = g_strdup_printf ("%s %s::%s", sig,
1227                         get_memberref_parent (m, cols [MONO_MEMBERREF_CLASS]),
1228                         mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));
1229         g_free (sig);
1230
1231         return full_sig;
1232 }
1233
1234 /**
1235  * get_field:
1236  * @m: metadata context
1237  * @token: a FIELD_DEF token
1238  *
1239  * This routine has to locate the TypeDef that "owns" this Field.
1240  * Since there is no backpointer in the Field table, we have to scan
1241  * the TypeDef table and locate the actual "owner" of the field
1242  */
1243 char *
1244 get_field (MonoImage *m, guint32 token)
1245 {
1246         int idx = mono_metadata_token_index (token);
1247         guint32 cols [MONO_FIELD_SIZE];
1248         char *sig, *res, *type, *estype, *esname;
1249         guint32 type_idx;
1250
1251         /*
1252          * We can get here also with a MenberRef token (for a field
1253          * defined in another module/assembly, just like in get_method ()
1254          */
1255         if (mono_metadata_token_code (token) == MONO_TOKEN_MEMBER_REF) {
1256                 return get_fieldref_signature (m, idx);
1257         }
1258         g_assert (mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF);
1259
1260         mono_metadata_decode_row (&m->tables [MONO_TABLE_FIELD], idx - 1, cols, MONO_FIELD_SIZE);
1261         sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE]);
1262
1263         /*
1264          * To locate the actual "container" for this field, we have to scan
1265          * the TypeDef table.  LAME!
1266          */
1267         type_idx = mono_metadata_typedef_from_field (m, idx);
1268
1269         type = get_typedef (m, type_idx);
1270         estype = get_escaped_name (type);
1271         esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_FIELD_NAME]));
1272         res = g_strdup_printf ("%s %s::%s",
1273                         sig, estype, esname);
1274
1275         g_free (type);
1276         g_free (sig);
1277         g_free (estype);
1278         g_free (esname);
1279
1280         return res;
1281 }
1282
1283 static char *
1284 get_memberref_parent (MonoImage *m, guint32 mrp_token)
1285 {
1286         /*
1287          * mrp_index is a MemberRefParent coded index
1288          */
1289         guint32 table = mrp_token & 7;
1290         guint32 idx = mrp_token >> 3;
1291
1292         switch (table){
1293         case 0: /* TypeDef */
1294                 return get_typedef (m, idx);
1295
1296         case 1: /* TypeRef */
1297                 return get_typeref (m, idx);
1298
1299         case 2: /* ModuleRef */
1300                 return g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
1301
1302         case 3: /* MethodDef */
1303                 return g_strdup ("TODO:MethodDef");
1304
1305         case 4: /* TypeSpec */
1306                 return get_typespec (m, idx);
1307         }
1308         g_assert_not_reached ();
1309         return NULL;
1310 }
1311
1312 /**
1313  * get_method:
1314  * @m: metadata context
1315  * @token: a METHOD_DEF or MEMBER_REF token
1316  *
1317  * This routine has to locate the TypeDef that "owns" this Field.
1318  * Since there is no backpointer in the Field table, we have to scan
1319  * the TypeDef table and locate the actual "owner" of the field
1320  */
1321 char *
1322 get_method (MonoImage *m, guint32 token)
1323 {
1324         int idx = mono_metadata_token_index (token);
1325         guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
1326         char *sig, *esname;
1327         const char *name;
1328
1329         MonoMethod *mh;
1330
1331         mh = mono_get_method (m, token, NULL);
1332         if (mh) {
1333                 esname = get_escaped_name (mh->name);
1334                 sig = dis_stringify_object_with_class (m, mh->klass);
1335                 if (show_tokens)
1336                         name = g_strdup_printf ("%s/*%08x*/::%s", sig, token, esname);
1337                 else
1338                         name = g_strdup_printf ("%s::%s", sig, esname);
1339                 g_free (sig);
1340                 g_free (esname);
1341         } else
1342                 name = NULL;
1343
1344         switch (mono_metadata_token_code (token)){
1345         case MONO_TOKEN_METHOD_DEF:
1346                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1347                                           idx - 1, method_cols, MONO_METHOD_SIZE);
1348
1349                 sig = get_methodref_signature (m, method_cols [MONO_METHOD_SIGNATURE], name);
1350                 break;
1351
1352         case MONO_TOKEN_MEMBER_REF: {
1353                 mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1354                                           idx - 1, member_cols, MONO_MEMBERREF_SIZE);
1355                 if (!name)
1356                         name = g_strdup_printf ("%s::%s",
1357                                         get_memberref_parent (m, member_cols [MONO_MEMBERREF_CLASS]),
1358                                         mono_metadata_string_heap (m, member_cols [MONO_MEMBERREF_NAME]));
1359                 sig = get_methodref_signature (
1360                         m, member_cols [MONO_MEMBERREF_SIGNATURE], name);
1361                 break;
1362         }
1363         case MONO_TOKEN_METHOD_SPEC: {
1364                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHODSPEC],
1365                                 idx - 1, member_cols, MONO_METHODSPEC_SIZE);
1366                 token = member_cols [MONO_METHODSPEC_METHOD];
1367                 sig = get_methodspec (m, idx, token, name);
1368                 break;
1369         }
1370
1371         default:
1372                 g_assert_not_reached ();
1373         }
1374
1375         if (show_tokens) {
1376                 char *retval = g_strdup_printf ("%s /* %08x */", sig, token);
1377                 g_free (sig);
1378                 return retval;
1379         } else
1380                 return sig;
1381 }
1382
1383 /**
1384  * get_methoddef
1385  * @m: metadata context
1386  * @idx: index into the method table
1387  *
1388  * Returns: A stringified version of the method signature.
1389  */
1390 char *
1391 get_methoddef (MonoImage *m, guint32 idx)
1392 {
1393         guint32 cols [MONO_METHOD_SIZE];
1394         char *sig;
1395         const char *name;
1396
1397         MonoMethod *mh;
1398
1399         mh = mono_get_method (m, MONO_TOKEN_METHOD_DEF | idx, NULL);
1400         if (mh) {
1401                 sig = dis_stringify_object_with_class (m, mh->klass);
1402                 name = g_strdup_printf ("%s::%s", sig, mh->name);
1403                 g_free (sig);
1404         } else
1405                 name = NULL;
1406         mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1407                         idx - 1, cols, MONO_METHOD_SIZE);
1408         sig = get_methodref_signature (m, cols [MONO_METHOD_SIGNATURE], name);
1409
1410         return sig;
1411 }
1412
1413 char *
1414 get_method_type_param (MonoImage *m, guint32 blob_signature)
1415 {
1416         GString *res = g_string_new ("");
1417         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
1418         int param_count;
1419         int i = 0;
1420         char *s;
1421
1422         mono_metadata_decode_value (ptr, &ptr);
1423         ptr++;
1424         param_count = mono_metadata_decode_value (ptr, &ptr);
1425
1426         g_string_append_c (res, '<');
1427
1428         for (i = 0; i < param_count; i++){
1429                 char *param = NULL;
1430
1431                 ptr = get_param (m, ptr, &param);
1432                 g_string_append (res, param);
1433                 if (i+1 != param_count)
1434                         g_string_append (res, ", ");
1435                 g_free (param);
1436         }
1437         g_string_append_c (res, '>');
1438
1439         s = res->str;
1440         g_string_free (res, FALSE);
1441         return s;
1442 }
1443
1444 /**
1445  * get_methodspec
1446  *
1447  * Returns: An allocated stringified version of the methodspec signature.
1448  */
1449
1450 char *
1451 get_methodspec (MonoImage *m, int idx, guint32 token, const char *fancy_name)
1452 {
1453         GString *res = g_string_new ("");
1454         guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
1455         char *s, *type_param;
1456         const char *ptr;
1457         guint32 sig;
1458         int param_count, cconv, i, gen_count = 0;
1459
1460         switch (token & METHODDEFORREF_MASK) {
1461         case METHODDEFORREF_METHODDEF:
1462                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1463                                           (token >> METHODDEFORREF_BITS) - 1,
1464                                           method_cols, MONO_METHOD_SIZE);
1465                 sig = method_cols [MONO_METHOD_SIGNATURE];
1466                 break;
1467         case METHODDEFORREF_METHODREF:
1468                 mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1469                                           (token >> METHODDEFORREF_BITS) - 1,
1470                                           member_cols, MONO_MEMBERREF_SIZE);
1471                 sig = member_cols [MONO_MEMBERREF_SIGNATURE];
1472                 break;
1473         default:
1474                 g_assert_not_reached ();
1475         }
1476
1477         ptr = mono_metadata_blob_heap (m, sig);
1478         mono_metadata_decode_value (ptr, &ptr);
1479
1480         if (*ptr & 0x20){
1481                 if (*ptr & 0x40)
1482                         g_string_append (res, "explicit-this ");
1483                 else
1484                         g_string_append (res, "instance "); /* has-this */
1485         }
1486
1487         if (*ptr & 0x10)
1488                 gen_count = 1;
1489         cconv = *ptr & 0x0f;
1490         ptr++;
1491         if (gen_count)
1492                 gen_count = mono_metadata_decode_value (ptr, &ptr);
1493         param_count = mono_metadata_decode_value (ptr, &ptr);
1494         if (cconv != 0xa) {
1495                 char *allocated_ret_type;
1496                 ptr = get_ret_type (m, ptr, &allocated_ret_type);
1497                 g_string_append (res, allocated_ret_type);
1498                 g_free (allocated_ret_type);
1499         }
1500
1501         if (fancy_name){
1502                 g_string_append_c (res, ' ');
1503                 g_string_append (res, fancy_name);
1504         }
1505
1506         mono_metadata_decode_row (&m->tables [MONO_TABLE_METHODSPEC],
1507                         idx - 1, member_cols, MONO_METHODSPEC_SIZE);
1508         token = member_cols [MONO_METHODSPEC_SIGNATURE];
1509         type_param = get_method_type_param (m, token);
1510         g_string_append (res, type_param);
1511         g_string_append (res, " (");
1512
1513         /*
1514          * methodspecs can not be varargs so we don't need to worry about that here
1515          */
1516
1517         for (i = 0; i < param_count; i++){
1518                 char *param = NULL;
1519
1520                 ptr = get_param (m, ptr, &param);
1521                 g_string_append (res, param);
1522                 if (i+1 != param_count)
1523                         g_string_append (res, ", ");
1524                 g_free (param);
1525         }
1526         g_string_append (res, ")");
1527
1528         /*
1529          * cleanup and return
1530          */
1531         s = res->str;
1532         g_string_free (res, FALSE);
1533         return s;
1534 }
1535
1536
1537 /**
1538  * get_constant:
1539  * @m: metadata context
1540  * @blob_index: index into the blob where the constant is stored
1541  *
1542  * Returns: An allocated value representing a stringified version of the
1543  * constant.
1544  */
1545 char *
1546 get_constant (MonoImage *m, MonoTypeEnum t, guint32 blob_index)
1547 {
1548         const char *ptr = mono_metadata_blob_heap (m, blob_index);
1549         int len;
1550
1551         len = mono_metadata_decode_value (ptr, &ptr);
1552
1553         switch (t){
1554         case MONO_TYPE_BOOLEAN:
1555                 return g_strdup_printf ("%s", *ptr ? "bool(true)" : "bool(false)");
1556
1557         case MONO_TYPE_CHAR:
1558                 return g_strdup_printf ("%c", *ptr); /* FIXME: unicode char */
1559
1560         case MONO_TYPE_U1:
1561         case MONO_TYPE_I1:
1562                 return g_strdup_printf ("int8(0x%02x)", (int) (*ptr));
1563                 break;
1564
1565         case MONO_TYPE_U2:
1566         case MONO_TYPE_I2:
1567                 return g_strdup_printf ("int16(0x%08x)", (int) read16 (ptr));
1568
1569         case MONO_TYPE_U4:
1570         case MONO_TYPE_I4:
1571                 return g_strdup_printf ("int32(%d)", read32 (ptr));
1572
1573         case MONO_TYPE_I8: {
1574                 guint32 low, high;
1575                 low = read32 (ptr);
1576                 high = read32 (ptr + 4);
1577                 return g_strdup_printf ("0x%08x%08x", high, low);
1578         }
1579         case MONO_TYPE_U8: {
1580                 guint32 low, high;
1581                 low = read32 (ptr);
1582                 high = read32 (ptr + 4);
1583                 return g_strdup_printf ("0x%08x%08x", high, low);
1584         }
1585         case MONO_TYPE_R4: {
1586                 float r;
1587                 readr4 (ptr, &r);
1588                 return g_strdup_printf ("%g", (double) r);
1589         }
1590         case MONO_TYPE_R8: {
1591                 double r;
1592                 readr8 (ptr, &r);
1593                 return g_strdup_printf ("%g", r);
1594         }
1595         case MONO_TYPE_STRING: {
1596                 int i, j, e;
1597                 char *res;
1598                 e = len = 0;
1599                 for (i = 0; !ptr [i+1]; i += 2){
1600                         len++;
1601                         switch (ptr [i]) {
1602                         case '"':
1603                         case '\\':
1604                         case '\n': /* add more */
1605                                 e++;
1606                         }
1607                 }
1608                 res = g_malloc (len + e + 3);
1609                 j = 1;
1610                 res [0] = '"';
1611
1612                 for (i = 0; i < len; i += 2){
1613                         switch(ptr[i]) {
1614                         case '"':
1615                                 res[j++] = '\\';
1616                                 res[j++] = '"';
1617                         case '\\':
1618                                 res[j++] = '\\';
1619                                 res[j++] = '\\';
1620                         case '\n':
1621                                 res[j++] = '\\';
1622                                 res[j++] = 'n';
1623                                 break;
1624                         default:
1625                                 res[j++] = isprint (ptr [i]) ? ptr [i] : '.';
1626                                 break;
1627                         }
1628                 }
1629                 res[j++] = '"';
1630                 res[j] = 0;
1631                 return res;
1632         }
1633
1634         case MONO_TYPE_CLASS:
1635                 return g_strdup ("CLASS CONSTANT.  MUST BE ZERO");
1636
1637         default:
1638                 g_error ("Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n",
1639                          (int) *ptr, blob_index);
1640                 return g_strdup_printf ("Unknown");
1641         }
1642
1643 }
1644
1645 /**
1646  * get_token:
1647  * @m: metadata context
1648  * @token: token that we want to decode.
1649  *
1650  * Returns: An allocated value representing a stringified version of the
1651  * constant.
1652  */
1653 char *
1654 get_token (MonoImage *m, guint32 token)
1655 {
1656         char *temp, *result;
1657         guint32 idx = mono_metadata_token_index (token);
1658
1659         switch (mono_metadata_token_code (token)){
1660         case MONO_TOKEN_FIELD_DEF:
1661                 temp = get_field (m, token);
1662                 result = g_strdup_printf ("field %s", temp);
1663                 g_free (temp);
1664                 return result;
1665         case MONO_TOKEN_TYPE_DEF:
1666                 return get_typedef (m, idx);
1667         case MONO_TOKEN_TYPE_REF:
1668                 return get_typeref (m, idx);
1669         case MONO_TOKEN_TYPE_SPEC:
1670                 return get_typespec (m, idx);
1671         default:
1672                 g_error ("Do not know how to decode tokens of type 0x%08x", token);
1673         }
1674
1675         g_assert_not_reached ();
1676         return g_strdup ("ERROR");
1677 }
1678
1679 /**
1680  * get_token_type:
1681  * @m: metadata context
1682  * @token: the token can belong to any of the following tables:
1683  * MONO_TOKEN_TYPE_REF, MONO_TOKEN_TYPE_DEF, MONO_TOKEN_TYPE_SPEC
1684  *
1685  * Returns: a stringified version of the MethodDef or MethodRef or TypeSpecn
1686  * at (token & 0xffffff)
1687  */
1688 char *
1689 get_token_type (MonoImage *m, guint32 token)
1690 {
1691         char *temp = NULL, *s = NULL;
1692         int idx;
1693
1694         idx = mono_metadata_token_index (token);
1695
1696         switch (mono_metadata_token_code (token)){
1697         case MONO_TOKEN_TYPE_DEF:
1698                 temp = get_typedef (m, idx);
1699                 s = g_strdup_printf ("%s", temp);
1700                 break;
1701
1702         case MONO_TOKEN_TYPE_REF:
1703                 temp = get_typeref (m, idx);
1704                 s = g_strdup_printf ("%s", temp);
1705                 break;
1706
1707         case MONO_TOKEN_TYPE_SPEC:
1708                 s = get_typespec (m, idx);
1709                 break;
1710
1711         default:
1712                 g_error ("Unhandled encoding for token 0x%08x", token);
1713
1714         }
1715
1716         if (temp)
1717                 g_free (temp);
1718
1719         return s;
1720 }
1721
1722 char *
1723 get_guid (MonoImage *m, guint32 guid_index)
1724 {
1725         const unsigned char *guid;
1726         char *result;
1727
1728         guid = mono_metadata_guid_heap (m, guid_index);
1729
1730         result = g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
1731                         guid [3], guid [2], guid [1], guid [0], guid [5], guid [4], guid [7], guid [6],
1732                         guid [8], guid [9], guid [10], guid [11], guid [12], guid [13], guid [14], guid [15]);
1733         return result;
1734 }
1735
1736 GList *
1737 dis_get_custom_attrs (MonoImage *m, guint32 token)
1738 {
1739         GList *list = NULL;
1740         guint32 idx, i, len, mtoken;
1741         guint32 cols [MONO_CUSTOM_ATTR_SIZE];
1742         MonoTableInfo *ca;
1743         char *method;
1744         GString *attr;
1745         const char *val;
1746
1747         idx = mono_metadata_token_index (token);
1748         idx <<= CUSTOM_ATTR_BITS;
1749
1750         switch (mono_metadata_token_table (token)) {
1751         case MONO_TABLE_TYPEDEF:
1752                 idx |= CUSTOM_ATTR_TYPEDEF;
1753                 break;
1754         case MONO_TABLE_ASSEMBLY:
1755                 idx |= CUSTOM_ATTR_ASSEMBLY;
1756                 break;
1757         case MONO_TABLE_MODULE:
1758                 idx |= CUSTOM_ATTR_MODULE;
1759                 break;
1760         case MONO_TABLE_PROPERTY:
1761                 idx |= CUSTOM_ATTR_PROPERTY;
1762                 break;
1763         case MONO_TABLE_EVENT:
1764                 idx |= CUSTOM_ATTR_EVENT;
1765                 break;
1766         case MONO_TABLE_FIELD:
1767                 idx |= CUSTOM_ATTR_FIELDDEF;
1768                 break;
1769         case MONO_TABLE_METHOD:
1770                 idx |= CUSTOM_ATTR_METHODDEF;
1771                 break;
1772         case MONO_TABLE_PARAM:
1773                 idx |= CUSTOM_ATTR_PARAMDEF;
1774                 break;
1775         default:
1776                 g_print ("Missing custom attr get support for token 0x%08x\n", token);
1777                 return NULL;
1778         }
1779
1780         ca = &m->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1781         /* the table is not sorted */
1782         for (i = 0; i < ca->rows; ++i) {
1783                 char *dump;
1784                 mono_metadata_decode_row (ca, i, cols, MONO_CUSTOM_ATTR_SIZE);
1785                 if (cols [MONO_CUSTOM_ATTR_PARENT] != idx)
1786                         continue;
1787                 mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> CUSTOM_ATTR_TYPE_BITS;
1788                 switch (cols [MONO_CUSTOM_ATTR_TYPE] & CUSTOM_ATTR_TYPE_MASK) {
1789                 case CUSTOM_ATTR_TYPE_METHODDEF:
1790                         mtoken |= MONO_TOKEN_METHOD_DEF;
1791                         break;
1792                 case CUSTOM_ATTR_TYPE_MEMBERREF:
1793                         mtoken |= MONO_TOKEN_MEMBER_REF;
1794                         break;
1795                 default:
1796                         g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
1797                         break;
1798                 }
1799                 method = get_method (m, mtoken);
1800                 val = mono_metadata_blob_heap (m, cols [MONO_CUSTOM_ATTR_VALUE]);
1801                 len = mono_metadata_decode_value (val, &val);
1802                 attr = g_string_new (".custom ");
1803                 dump = data_dump (val, len, "\t\t");
1804                 g_string_sprintfa (attr, "%s = %s", method, dump);
1805                 g_free (dump);
1806                 list = g_list_append (list, attr->str);
1807                 g_string_free (attr, FALSE);
1808                 g_free (method);
1809         }
1810         return list;
1811 }
1812
1813 char*
1814 get_marshal_info (MonoImage *m, const char *blob) {
1815         int len, size = 0;
1816
1817         len = mono_metadata_decode_blob_size (blob, &blob);
1818
1819         switch (*blob) {
1820         case MONO_NATIVE_BOOLEAN:
1821                 return g_strdup ("bool");
1822         case MONO_NATIVE_I1:
1823                 return g_strdup ("int8");
1824         case MONO_NATIVE_U1:
1825                 return g_strdup ("unsigned int8");
1826         case MONO_NATIVE_I2:
1827                 return g_strdup ("int16");
1828         case MONO_NATIVE_U2:
1829                 return g_strdup ("unsigned int16");
1830         case MONO_NATIVE_I4:
1831                 return g_strdup ("int32");
1832         case MONO_NATIVE_U4:
1833                 return g_strdup ("unsigned int32");
1834         case MONO_NATIVE_I8:
1835                 return g_strdup ("int64");
1836         case MONO_NATIVE_U8:
1837                 return g_strdup ("unsigned int64");
1838         case MONO_NATIVE_R4:
1839                 return g_strdup ("float32");
1840         case MONO_NATIVE_R8:
1841                 return g_strdup ("float64");
1842         case MONO_NATIVE_CURRENCY:
1843                 return g_strdup ("currency");
1844         case MONO_NATIVE_BSTR:
1845                 return g_strdup ("bstr");
1846         case MONO_NATIVE_LPSTR:
1847                 return g_strdup ("lpstr");
1848         case MONO_NATIVE_LPWSTR:
1849                 return g_strdup ("lpwstr");
1850         case MONO_NATIVE_LPTSTR:
1851                 return g_strdup ("lptstr");
1852         case MONO_NATIVE_BYVALTSTR:
1853                 size = mono_metadata_decode_value (blob + 1, &blob);
1854                 return g_strdup_printf ("fixed sysstring [%d]", size);
1855         case MONO_NATIVE_IUNKNOWN:
1856                 return g_strdup ("iunknown");
1857         case MONO_NATIVE_IDISPATCH:
1858                 return g_strdup ("idispatch");
1859         case MONO_NATIVE_STRUCT:
1860                 return g_strdup ("struct");
1861         case MONO_NATIVE_INTERFACE:
1862                 return g_strdup ("interface");
1863         case MONO_NATIVE_SAFEARRAY:
1864                 return g_strdup ("safearray");
1865         case MONO_NATIVE_BYVALARRAY:
1866                 size = mono_metadata_decode_value (blob + 1, &blob);
1867                 return g_strdup_printf ("fixed array [%d]", size);
1868         case MONO_NATIVE_INT:
1869                 return g_strdup ("int");
1870         case MONO_NATIVE_UINT:
1871                 return g_strdup ("unsigned int");
1872         case MONO_NATIVE_VBBYREFSTR:
1873                 return g_strdup ("vbbyrefstr");
1874         case MONO_NATIVE_ANSIBSTR:
1875                 return g_strdup ("ansi bstr");
1876         case MONO_NATIVE_TBSTR:
1877                 return g_strdup ("tbstr");
1878         case MONO_NATIVE_VARIANTBOOL:
1879                 return g_strdup ("variant bool");
1880         case MONO_NATIVE_FUNC:
1881                 return g_strdup ("method");
1882         case MONO_NATIVE_ASANY:
1883                 return g_strdup ("as any");
1884         case MONO_NATIVE_LPARRAY:
1885                 return g_strdup ("[]");
1886         case MONO_NATIVE_LPSTRUCT:
1887                 return g_strdup ("lpstruct");
1888         case MONO_NATIVE_CUSTOM:
1889                 return g_strdup ("custom");
1890         case MONO_NATIVE_ERROR:
1891                 return g_strdup ("error");
1892         default:
1893                 return g_strdup ("unknown");
1894         }
1895 }
1896
1897 void
1898 init_key_table (void)
1899 {
1900         key_table = g_hash_table_new (g_str_hash, g_str_equal);
1901
1902         /* auto generated */
1903         g_hash_table_insert (key_table, (char *) "abstract", GINT_TO_POINTER (TRUE));
1904         g_hash_table_insert (key_table, (char *) "add", GINT_TO_POINTER (TRUE));
1905         g_hash_table_insert (key_table, (char *) "add.ovf", GINT_TO_POINTER (TRUE));
1906         g_hash_table_insert (key_table, (char *) "add.ovf.un", GINT_TO_POINTER (TRUE));
1907         g_hash_table_insert (key_table, (char *) "algorithm", GINT_TO_POINTER (TRUE));
1908         g_hash_table_insert (key_table, (char *) "alignment", GINT_TO_POINTER (TRUE));
1909         g_hash_table_insert (key_table, (char *) "and", GINT_TO_POINTER (TRUE));
1910         g_hash_table_insert (key_table, (char *) "ansi", GINT_TO_POINTER (TRUE));
1911         g_hash_table_insert (key_table, (char *) "any", GINT_TO_POINTER (TRUE));
1912         g_hash_table_insert (key_table, (char *) "arglist", GINT_TO_POINTER (TRUE));
1913         g_hash_table_insert (key_table, (char *) "array", GINT_TO_POINTER (TRUE));
1914         g_hash_table_insert (key_table, (char *) "as", GINT_TO_POINTER (TRUE));
1915         g_hash_table_insert (key_table, (char *) "assembly", GINT_TO_POINTER (TRUE));
1916         g_hash_table_insert (key_table, (char *) "assert", GINT_TO_POINTER (TRUE));
1917         g_hash_table_insert (key_table, (char *) "at", GINT_TO_POINTER (TRUE));
1918         g_hash_table_insert (key_table, (char *) "auto", GINT_TO_POINTER (TRUE));
1919         g_hash_table_insert (key_table, (char *) "autochar", GINT_TO_POINTER (TRUE));
1920         g_hash_table_insert (key_table, (char *) "beforefieldinit", GINT_TO_POINTER (TRUE));
1921         g_hash_table_insert (key_table, (char *) "beq", GINT_TO_POINTER (TRUE));
1922         g_hash_table_insert (key_table, (char *) "beq.s", GINT_TO_POINTER (TRUE));
1923         g_hash_table_insert (key_table, (char *) "bge", GINT_TO_POINTER (TRUE));
1924         g_hash_table_insert (key_table, (char *) "bge.s", GINT_TO_POINTER (TRUE));
1925         g_hash_table_insert (key_table, (char *) "bge.un", GINT_TO_POINTER (TRUE));
1926         g_hash_table_insert (key_table, (char *) "bge.un.s", GINT_TO_POINTER (TRUE));
1927         g_hash_table_insert (key_table, (char *) "bgt", GINT_TO_POINTER (TRUE));
1928         g_hash_table_insert (key_table, (char *) "bgt.s", GINT_TO_POINTER (TRUE));
1929         g_hash_table_insert (key_table, (char *) "bgt.un", GINT_TO_POINTER (TRUE));
1930         g_hash_table_insert (key_table, (char *) "9", GINT_TO_POINTER (TRUE));
1931         g_hash_table_insert (key_table, (char *) "bgt.un.s", GINT_TO_POINTER (TRUE));
1932         g_hash_table_insert (key_table, (char *) "ble", GINT_TO_POINTER (TRUE));
1933         g_hash_table_insert (key_table, (char *) "ble.s", GINT_TO_POINTER (TRUE));
1934         g_hash_table_insert (key_table, (char *) "ble.un", GINT_TO_POINTER (TRUE));
1935         g_hash_table_insert (key_table, (char *) "ble.un.s", GINT_TO_POINTER (TRUE));
1936         g_hash_table_insert (key_table, (char *) "blob", GINT_TO_POINTER (TRUE));
1937         g_hash_table_insert (key_table, (char *) "blob_object", GINT_TO_POINTER (TRUE));
1938         g_hash_table_insert (key_table, (char *) "blt", GINT_TO_POINTER (TRUE));
1939         g_hash_table_insert (key_table, (char *) "blt.s", GINT_TO_POINTER (TRUE));
1940         g_hash_table_insert (key_table, (char *) "blt.un", GINT_TO_POINTER (TRUE));
1941         g_hash_table_insert (key_table, (char *) "blt.un.s", GINT_TO_POINTER (TRUE));
1942         g_hash_table_insert (key_table, (char *) "bne.un", GINT_TO_POINTER (TRUE));
1943         g_hash_table_insert (key_table, (char *) "bne.un.s", GINT_TO_POINTER (TRUE));
1944         g_hash_table_insert (key_table, (char *) "bool", GINT_TO_POINTER (TRUE));
1945         g_hash_table_insert (key_table, (char *) "box", GINT_TO_POINTER (TRUE));
1946         g_hash_table_insert (key_table, (char *) "br", GINT_TO_POINTER (TRUE));
1947         g_hash_table_insert (key_table, (char *) "br.s", GINT_TO_POINTER (TRUE));
1948         g_hash_table_insert (key_table, (char *) "break", GINT_TO_POINTER (TRUE));
1949         g_hash_table_insert (key_table, (char *) "brfalse", GINT_TO_POINTER (TRUE));
1950         g_hash_table_insert (key_table, (char *) "brfalse.s", GINT_TO_POINTER (TRUE));
1951         g_hash_table_insert (key_table, (char *) "brinst", GINT_TO_POINTER (TRUE));
1952         g_hash_table_insert (key_table, (char *) "brinst.s", GINT_TO_POINTER (TRUE));
1953         g_hash_table_insert (key_table, (char *) "brnull", GINT_TO_POINTER (TRUE));
1954         g_hash_table_insert (key_table, (char *) "brnull.s", GINT_TO_POINTER (TRUE));
1955         g_hash_table_insert (key_table, (char *) "brtrue", GINT_TO_POINTER (TRUE));
1956         g_hash_table_insert (key_table, (char *) "brtrue.s", GINT_TO_POINTER (TRUE));
1957         g_hash_table_insert (key_table, (char *) "brzero", GINT_TO_POINTER (TRUE));
1958         g_hash_table_insert (key_table, (char *) "brzero.s", GINT_TO_POINTER (TRUE));
1959         g_hash_table_insert (key_table, (char *) "bstr", GINT_TO_POINTER (TRUE));
1960         g_hash_table_insert (key_table, (char *) "bytearray", GINT_TO_POINTER (TRUE));
1961         g_hash_table_insert (key_table, (char *) "byvalstr", GINT_TO_POINTER (TRUE));
1962         g_hash_table_insert (key_table, (char *) "call", GINT_TO_POINTER (TRUE));
1963         g_hash_table_insert (key_table, (char *) "calli", GINT_TO_POINTER (TRUE));
1964         g_hash_table_insert (key_table, (char *) "callmostderived", GINT_TO_POINTER (TRUE));
1965         g_hash_table_insert (key_table, (char *) "callvirt", GINT_TO_POINTER (TRUE));
1966         g_hash_table_insert (key_table, (char *) "carray", GINT_TO_POINTER (TRUE));
1967         g_hash_table_insert (key_table, (char *) "castclass", GINT_TO_POINTER (TRUE));
1968         g_hash_table_insert (key_table, (char *) "catch", GINT_TO_POINTER (TRUE));
1969         g_hash_table_insert (key_table, (char *) "cdecl", GINT_TO_POINTER (TRUE));
1970         g_hash_table_insert (key_table, (char *) "ceq", GINT_TO_POINTER (TRUE));
1971         g_hash_table_insert (key_table, (char *) "cf", GINT_TO_POINTER (TRUE));
1972         g_hash_table_insert (key_table, (char *) "cgt", GINT_TO_POINTER (TRUE));
1973         g_hash_table_insert (key_table, (char *) "cgt.un", GINT_TO_POINTER (TRUE));
1974         g_hash_table_insert (key_table, (char *) "char", GINT_TO_POINTER (TRUE));
1975         g_hash_table_insert (key_table, (char *) "cil", GINT_TO_POINTER (TRUE));
1976         g_hash_table_insert (key_table, (char *) "ckfinite", GINT_TO_POINTER (TRUE));
1977         g_hash_table_insert (key_table, (char *) "class", GINT_TO_POINTER (TRUE));
1978         g_hash_table_insert (key_table, (char *) "clsid", GINT_TO_POINTER (TRUE));
1979         g_hash_table_insert (key_table, (char *) "clt", GINT_TO_POINTER (TRUE));
1980         g_hash_table_insert (key_table, (char *) "clt.un", GINT_TO_POINTER (TRUE));
1981         g_hash_table_insert (key_table, (char *) "const", GINT_TO_POINTER (TRUE));
1982         g_hash_table_insert (key_table, (char *) "conv.i", GINT_TO_POINTER (TRUE));
1983         g_hash_table_insert (key_table, (char *) "conv.i1", GINT_TO_POINTER (TRUE));
1984         g_hash_table_insert (key_table, (char *) "conv.i2", GINT_TO_POINTER (TRUE));
1985         g_hash_table_insert (key_table, (char *) "conv.i4", GINT_TO_POINTER (TRUE));
1986         g_hash_table_insert (key_table, (char *) "conv.i8", GINT_TO_POINTER (TRUE));
1987         g_hash_table_insert (key_table, (char *) "conv.ovf.i", GINT_TO_POINTER (TRUE));
1988         g_hash_table_insert (key_table, (char *) "conv.ovf.i.un", GINT_TO_POINTER (TRUE));
1989         g_hash_table_insert (key_table, (char *) "conv.ovf.i1", GINT_TO_POINTER (TRUE));
1990         g_hash_table_insert (key_table, (char *) "conv.ovf.i1.un", GINT_TO_POINTER (TRUE));
1991         g_hash_table_insert (key_table, (char *) "conv.ovf.i2", GINT_TO_POINTER (TRUE));
1992         g_hash_table_insert (key_table, (char *) "conv.ovf.i2.un", GINT_TO_POINTER (TRUE));
1993         g_hash_table_insert (key_table, (char *) "conv.ovf.i4", GINT_TO_POINTER (TRUE));
1994         g_hash_table_insert (key_table, (char *) "conv.ovf.i4.un", GINT_TO_POINTER (TRUE));
1995         g_hash_table_insert (key_table, (char *) "conv.ovf.i8", GINT_TO_POINTER (TRUE));
1996         g_hash_table_insert (key_table, (char *) "conv.ovf.i8.un", GINT_TO_POINTER (TRUE));
1997         g_hash_table_insert (key_table, (char *) "conv.ovf.u", GINT_TO_POINTER (TRUE));
1998         g_hash_table_insert (key_table, (char *) "conv.ovf.u.un", GINT_TO_POINTER (TRUE));
1999         g_hash_table_insert (key_table, (char *) "conv.ovf.u1", GINT_TO_POINTER (TRUE));
2000         g_hash_table_insert (key_table, (char *) "conv.ovf.u1.un", GINT_TO_POINTER (TRUE));
2001         g_hash_table_insert (key_table, (char *) "conv.ovf.u2", GINT_TO_POINTER (TRUE));
2002         g_hash_table_insert (key_table, (char *) "conv.ovf.u2.un", GINT_TO_POINTER (TRUE));
2003         g_hash_table_insert (key_table, (char *) "conv.ovf.u4", GINT_TO_POINTER (TRUE));
2004         g_hash_table_insert (key_table, (char *) "conv.ovf.u4.un", GINT_TO_POINTER (TRUE));
2005         g_hash_table_insert (key_table, (char *) "conv.ovf.u8", GINT_TO_POINTER (TRUE));
2006         g_hash_table_insert (key_table, (char *) "conv.ovf.u8.un", GINT_TO_POINTER (TRUE));
2007         g_hash_table_insert (key_table, (char *) "conv.r.un", GINT_TO_POINTER (TRUE));
2008         g_hash_table_insert (key_table, (char *) "conv.r4", GINT_TO_POINTER (TRUE));
2009         g_hash_table_insert (key_table, (char *) "conv.r8", GINT_TO_POINTER (TRUE));
2010         g_hash_table_insert (key_table, (char *) "conv.u", GINT_TO_POINTER (TRUE));
2011         g_hash_table_insert (key_table, (char *) "conv.u1", GINT_TO_POINTER (TRUE));
2012         g_hash_table_insert (key_table, (char *) "conv.u2", GINT_TO_POINTER (TRUE));
2013         g_hash_table_insert (key_table, (char *) "conv.u4", GINT_TO_POINTER (TRUE));
2014         g_hash_table_insert (key_table, (char *) "conv.u8", GINT_TO_POINTER (TRUE));
2015         g_hash_table_insert (key_table, (char *) "cpblk", GINT_TO_POINTER (TRUE));
2016         g_hash_table_insert (key_table, (char *) "cpobj", GINT_TO_POINTER (TRUE));
2017         g_hash_table_insert (key_table, (char *) "currency", GINT_TO_POINTER (TRUE));
2018         g_hash_table_insert (key_table, (char *) "custom", GINT_TO_POINTER (TRUE));
2019         g_hash_table_insert (key_table, (char *) "date", GINT_TO_POINTER (TRUE));
2020         g_hash_table_insert (key_table, (char *) "decimal", GINT_TO_POINTER (TRUE));
2021         g_hash_table_insert (key_table, (char *) "default", GINT_TO_POINTER (TRUE));
2022         g_hash_table_insert (key_table, (char *) "default", GINT_TO_POINTER (TRUE));
2023         g_hash_table_insert (key_table, (char *) "demand", GINT_TO_POINTER (TRUE));
2024         g_hash_table_insert (key_table, (char *) "deny", GINT_TO_POINTER (TRUE));
2025         g_hash_table_insert (key_table, (char *) "div", GINT_TO_POINTER (TRUE));
2026         g_hash_table_insert (key_table, (char *) "div.un", GINT_TO_POINTER (TRUE));
2027         g_hash_table_insert (key_table, (char *) "dup", GINT_TO_POINTER (TRUE));
2028         g_hash_table_insert (key_table, (char *) "endfault", GINT_TO_POINTER (TRUE));
2029         g_hash_table_insert (key_table, (char *) "endfilter", GINT_TO_POINTER (TRUE));
2030         g_hash_table_insert (key_table, (char *) "endfinally", GINT_TO_POINTER (TRUE));
2031         g_hash_table_insert (key_table, (char *) "endmac", GINT_TO_POINTER (TRUE));
2032         g_hash_table_insert (key_table, (char *) "enum", GINT_TO_POINTER (TRUE));
2033         g_hash_table_insert (key_table, (char *) "error", GINT_TO_POINTER (TRUE));
2034         g_hash_table_insert (key_table, (char *) "explicit", GINT_TO_POINTER (TRUE));
2035         g_hash_table_insert (key_table, (char *) "extends", GINT_TO_POINTER (TRUE));
2036         g_hash_table_insert (key_table, (char *) "extern", GINT_TO_POINTER (TRUE));
2037         g_hash_table_insert (key_table, (char *) "false", GINT_TO_POINTER (TRUE));
2038         g_hash_table_insert (key_table, (char *) "famandassem", GINT_TO_POINTER (TRUE));
2039         g_hash_table_insert (key_table, (char *) "family", GINT_TO_POINTER (TRUE));
2040         g_hash_table_insert (key_table, (char *) "famorassem", GINT_TO_POINTER (TRUE));
2041         g_hash_table_insert (key_table, (char *) "fastcall", GINT_TO_POINTER (TRUE));
2042         g_hash_table_insert (key_table, (char *) "fastcall", GINT_TO_POINTER (TRUE));
2043         g_hash_table_insert (key_table, (char *) "fault", GINT_TO_POINTER (TRUE));
2044         g_hash_table_insert (key_table, (char *) "field", GINT_TO_POINTER (TRUE));
2045         g_hash_table_insert (key_table, (char *) "filetime", GINT_TO_POINTER (TRUE));
2046         g_hash_table_insert (key_table, (char *) "filter", GINT_TO_POINTER (TRUE));
2047         g_hash_table_insert (key_table, (char *) "final", GINT_TO_POINTER (TRUE));
2048         g_hash_table_insert (key_table, (char *) "finally", GINT_TO_POINTER (TRUE));
2049         g_hash_table_insert (key_table, (char *) "fixed", GINT_TO_POINTER (TRUE));
2050         g_hash_table_insert (key_table, (char *) "float", GINT_TO_POINTER (TRUE));
2051         g_hash_table_insert (key_table, (char *) "float32", GINT_TO_POINTER (TRUE));
2052         g_hash_table_insert (key_table, (char *) "float64", GINT_TO_POINTER (TRUE));
2053         g_hash_table_insert (key_table, (char *) "forwardref", GINT_TO_POINTER (TRUE));
2054         g_hash_table_insert (key_table, (char *) "fromunmanaged", GINT_TO_POINTER (TRUE));
2055         g_hash_table_insert (key_table, (char *) "handler", GINT_TO_POINTER (TRUE));
2056         g_hash_table_insert (key_table, (char *) "hidebysig", GINT_TO_POINTER (TRUE));
2057         g_hash_table_insert (key_table, (char *) "hresult", GINT_TO_POINTER (TRUE));
2058         g_hash_table_insert (key_table, (char *) "idispatch", GINT_TO_POINTER (TRUE));
2059         g_hash_table_insert (key_table, (char *) "il", GINT_TO_POINTER (TRUE));
2060         g_hash_table_insert (key_table, (char *) "illegal", GINT_TO_POINTER (TRUE));
2061         g_hash_table_insert (key_table, (char *) "implements", GINT_TO_POINTER (TRUE));
2062         g_hash_table_insert (key_table, (char *) "implicitcom", GINT_TO_POINTER (TRUE));
2063         g_hash_table_insert (key_table, (char *) "implicitres", GINT_TO_POINTER (TRUE));
2064         g_hash_table_insert (key_table, (char *) "import", GINT_TO_POINTER (TRUE));
2065         g_hash_table_insert (key_table, (char *) "in", GINT_TO_POINTER (TRUE));
2066         g_hash_table_insert (key_table, (char *) "inheritcheck", GINT_TO_POINTER (TRUE));
2067         g_hash_table_insert (key_table, (char *) "init", GINT_TO_POINTER (TRUE));
2068         g_hash_table_insert (key_table, (char *) "initblk", GINT_TO_POINTER (TRUE));
2069         g_hash_table_insert (key_table, (char *) "initobj", GINT_TO_POINTER (TRUE));
2070         g_hash_table_insert (key_table, (char *) "initonly", GINT_TO_POINTER (TRUE));
2071         g_hash_table_insert (key_table, (char *) "instance", GINT_TO_POINTER (TRUE));
2072         g_hash_table_insert (key_table, (char *) "int", GINT_TO_POINTER (TRUE));
2073         g_hash_table_insert (key_table, (char *) "int16", GINT_TO_POINTER (TRUE));
2074         g_hash_table_insert (key_table, (char *) "int32", GINT_TO_POINTER (TRUE));
2075         g_hash_table_insert (key_table, (char *) "int64", GINT_TO_POINTER (TRUE));
2076         g_hash_table_insert (key_table, (char *) "int8", GINT_TO_POINTER (TRUE));
2077         g_hash_table_insert (key_table, (char *) "interface", GINT_TO_POINTER (TRUE));
2078         g_hash_table_insert (key_table, (char *) "internalcall", GINT_TO_POINTER (TRUE));
2079         g_hash_table_insert (key_table, (char *) "isinst", GINT_TO_POINTER (TRUE));
2080         g_hash_table_insert (key_table, (char *) "iunknown", GINT_TO_POINTER (TRUE));
2081         g_hash_table_insert (key_table, (char *) "jmp", GINT_TO_POINTER (TRUE));
2082         g_hash_table_insert (key_table, (char *) "lasterr", GINT_TO_POINTER (TRUE));
2083         g_hash_table_insert (key_table, (char *) "lcid", GINT_TO_POINTER (TRUE));
2084         g_hash_table_insert (key_table, (char *) "ldarg", GINT_TO_POINTER (TRUE));
2085         g_hash_table_insert (key_table, (char *) "ldarg.0", GINT_TO_POINTER (TRUE));
2086         g_hash_table_insert (key_table, (char *) "ldarg.1", GINT_TO_POINTER (TRUE));
2087         g_hash_table_insert (key_table, (char *) "ldarg.2", GINT_TO_POINTER (TRUE));
2088         g_hash_table_insert (key_table, (char *) "ldarg.3", GINT_TO_POINTER (TRUE));
2089         g_hash_table_insert (key_table, (char *) "ldarg.s", GINT_TO_POINTER (TRUE));
2090         g_hash_table_insert (key_table, (char *) "ldarga", GINT_TO_POINTER (TRUE));
2091         g_hash_table_insert (key_table, (char *) "ldarga.s", GINT_TO_POINTER (TRUE));
2092         g_hash_table_insert (key_table, (char *) "ldc.i4", GINT_TO_POINTER (TRUE));
2093         g_hash_table_insert (key_table, (char *) "ldc.i4.0", GINT_TO_POINTER (TRUE));
2094         g_hash_table_insert (key_table, (char *) "ldc.i4.1", GINT_TO_POINTER (TRUE));
2095         g_hash_table_insert (key_table, (char *) "ldc.i4.2", GINT_TO_POINTER (TRUE));
2096         g_hash_table_insert (key_table, (char *) "ldc.i4.3", GINT_TO_POINTER (TRUE));
2097         g_hash_table_insert (key_table, (char *) "ldc.i4.4", GINT_TO_POINTER (TRUE));
2098         g_hash_table_insert (key_table, (char *) "ldc.i4.5", GINT_TO_POINTER (TRUE));
2099         g_hash_table_insert (key_table, (char *) "ldc.i4.6", GINT_TO_POINTER (TRUE));
2100         g_hash_table_insert (key_table, (char *) "ldc.i4.7", GINT_TO_POINTER (TRUE));
2101         g_hash_table_insert (key_table, (char *) "ldc.i4.8", GINT_TO_POINTER (TRUE));
2102         g_hash_table_insert (key_table, (char *) "ldc.i4.M1", GINT_TO_POINTER (TRUE));
2103         g_hash_table_insert (key_table, (char *) "ldc.i4.m1", GINT_TO_POINTER (TRUE));
2104         g_hash_table_insert (key_table, (char *) "ldc.i4.s", GINT_TO_POINTER (TRUE));
2105         g_hash_table_insert (key_table, (char *) "ldc.i8", GINT_TO_POINTER (TRUE));
2106         g_hash_table_insert (key_table, (char *) "ldc.r4", GINT_TO_POINTER (TRUE));
2107         g_hash_table_insert (key_table, (char *) "ldc.r8", GINT_TO_POINTER (TRUE));
2108         g_hash_table_insert (key_table, (char *) "ldelem.i", GINT_TO_POINTER (TRUE));
2109         g_hash_table_insert (key_table, (char *) "ldelem.i1", GINT_TO_POINTER (TRUE));
2110         g_hash_table_insert (key_table, (char *) "ldelem.i2", GINT_TO_POINTER (TRUE));
2111         g_hash_table_insert (key_table, (char *) "ldelem.i4", GINT_TO_POINTER (TRUE));
2112         g_hash_table_insert (key_table, (char *) "ldelem.i8", GINT_TO_POINTER (TRUE));
2113         g_hash_table_insert (key_table, (char *) "ldelem.r4", GINT_TO_POINTER (TRUE));
2114         g_hash_table_insert (key_table, (char *) "ldelem.r8", GINT_TO_POINTER (TRUE));
2115         g_hash_table_insert (key_table, (char *) "ldelem.ref", GINT_TO_POINTER (TRUE));
2116         g_hash_table_insert (key_table, (char *) "ldelem.u1", GINT_TO_POINTER (TRUE));
2117         g_hash_table_insert (key_table, (char *) "ldelem.u2", GINT_TO_POINTER (TRUE));
2118         g_hash_table_insert (key_table, (char *) "ldelem.u4", GINT_TO_POINTER (TRUE));
2119         g_hash_table_insert (key_table, (char *) "ldelem.u8", GINT_TO_POINTER (TRUE));
2120         g_hash_table_insert (key_table, (char *) "ldelema", GINT_TO_POINTER (TRUE));
2121         g_hash_table_insert (key_table, (char *) "ldfld", GINT_TO_POINTER (TRUE));
2122         g_hash_table_insert (key_table, (char *) "ldflda", GINT_TO_POINTER (TRUE));
2123         g_hash_table_insert (key_table, (char *) "ldftn", GINT_TO_POINTER (TRUE));
2124         g_hash_table_insert (key_table, (char *) "ldind.i", GINT_TO_POINTER (TRUE));
2125         g_hash_table_insert (key_table, (char *) "ldind.i1", GINT_TO_POINTER (TRUE));
2126         g_hash_table_insert (key_table, (char *) "ldind.i2", GINT_TO_POINTER (TRUE));
2127         g_hash_table_insert (key_table, (char *) "ldind.i4", GINT_TO_POINTER (TRUE));
2128         g_hash_table_insert (key_table, (char *) "ldind.i8", GINT_TO_POINTER (TRUE));
2129         g_hash_table_insert (key_table, (char *) "ldind.r4", GINT_TO_POINTER (TRUE));
2130         g_hash_table_insert (key_table, (char *) "ldind.r8", GINT_TO_POINTER (TRUE));
2131         g_hash_table_insert (key_table, (char *) "ldind.ref", GINT_TO_POINTER (TRUE));
2132         g_hash_table_insert (key_table, (char *) "ldind.u1", GINT_TO_POINTER (TRUE));
2133         g_hash_table_insert (key_table, (char *) "ldind.u2", GINT_TO_POINTER (TRUE));
2134         g_hash_table_insert (key_table, (char *) "ldind.u4", GINT_TO_POINTER (TRUE));
2135         g_hash_table_insert (key_table, (char *) "ldind.u8", GINT_TO_POINTER (TRUE));
2136         g_hash_table_insert (key_table, (char *) "ldlen", GINT_TO_POINTER (TRUE));
2137         g_hash_table_insert (key_table, (char *) "ldloc", GINT_TO_POINTER (TRUE));
2138         g_hash_table_insert (key_table, (char *) "ldloc.0", GINT_TO_POINTER (TRUE));
2139         g_hash_table_insert (key_table, (char *) "ldloc.1", GINT_TO_POINTER (TRUE));
2140         g_hash_table_insert (key_table, (char *) "ldloc.2", GINT_TO_POINTER (TRUE));
2141         g_hash_table_insert (key_table, (char *) "ldloc.3", GINT_TO_POINTER (TRUE));
2142         g_hash_table_insert (key_table, (char *) "ldloc.s", GINT_TO_POINTER (TRUE));
2143         g_hash_table_insert (key_table, (char *) "ldloca", GINT_TO_POINTER (TRUE));
2144         g_hash_table_insert (key_table, (char *) "ldloca.s", GINT_TO_POINTER (TRUE));
2145         g_hash_table_insert (key_table, (char *) "ldnull", GINT_TO_POINTER (TRUE));
2146         g_hash_table_insert (key_table, (char *) "ldobj", GINT_TO_POINTER (TRUE));
2147         g_hash_table_insert (key_table, (char *) "ldsfld", GINT_TO_POINTER (TRUE));
2148         g_hash_table_insert (key_table, (char *) "ldsflda", GINT_TO_POINTER (TRUE));
2149         g_hash_table_insert (key_table, (char *) "ldstr", GINT_TO_POINTER (TRUE));
2150         g_hash_table_insert (key_table, (char *) "ldtoken", GINT_TO_POINTER (TRUE));
2151         g_hash_table_insert (key_table, (char *) "ldvirtftn", GINT_TO_POINTER (TRUE));
2152         g_hash_table_insert (key_table, (char *) "leave", GINT_TO_POINTER (TRUE));
2153         g_hash_table_insert (key_table, (char *) "leave.s", GINT_TO_POINTER (TRUE));
2154         g_hash_table_insert (key_table, (char *) "linkcheck", GINT_TO_POINTER (TRUE));
2155         g_hash_table_insert (key_table, (char *) "literal", GINT_TO_POINTER (TRUE));
2156         g_hash_table_insert (key_table, (char *) "localloc", GINT_TO_POINTER (TRUE));
2157         g_hash_table_insert (key_table, (char *) "lpstr", GINT_TO_POINTER (TRUE));
2158         g_hash_table_insert (key_table, (char *) "lpstruct", GINT_TO_POINTER (TRUE));
2159         g_hash_table_insert (key_table, (char *) "lptstr", GINT_TO_POINTER (TRUE));
2160         g_hash_table_insert (key_table, (char *) "lpvoid", GINT_TO_POINTER (TRUE));
2161         g_hash_table_insert (key_table, (char *) "lpwstr", GINT_TO_POINTER (TRUE));
2162         g_hash_table_insert (key_table, (char *) "managed", GINT_TO_POINTER (TRUE));
2163         g_hash_table_insert (key_table, (char *) "marshal", GINT_TO_POINTER (TRUE));
2164         g_hash_table_insert (key_table, (char *) "method", GINT_TO_POINTER (TRUE));
2165         g_hash_table_insert (key_table, (char *) "mkrefany", GINT_TO_POINTER (TRUE));
2166         g_hash_table_insert (key_table, (char *) "modopt", GINT_TO_POINTER (TRUE));
2167         g_hash_table_insert (key_table, (char *) "modreq", GINT_TO_POINTER (TRUE));
2168         g_hash_table_insert (key_table, (char *) "mul", GINT_TO_POINTER (TRUE));
2169         g_hash_table_insert (key_table, (char *) "mul.ovf", GINT_TO_POINTER (TRUE));
2170         g_hash_table_insert (key_table, (char *) "mul.ovf.un", GINT_TO_POINTER (TRUE));
2171         g_hash_table_insert (key_table, (char *) "native", GINT_TO_POINTER (TRUE));
2172         g_hash_table_insert (key_table, (char *) "neg", GINT_TO_POINTER (TRUE));
2173         g_hash_table_insert (key_table, (char *) "nested", GINT_TO_POINTER (TRUE));
2174         g_hash_table_insert (key_table, (char *) "newarr", GINT_TO_POINTER (TRUE));
2175         g_hash_table_insert (key_table, (char *) "newobj", GINT_TO_POINTER (TRUE));
2176         g_hash_table_insert (key_table, (char *) "newslot", GINT_TO_POINTER (TRUE));
2177         g_hash_table_insert (key_table, (char *) "noappdomain", GINT_TO_POINTER (TRUE));
2178         g_hash_table_insert (key_table, (char *) "noinlining", GINT_TO_POINTER (TRUE));
2179         g_hash_table_insert (key_table, (char *) "nomachine", GINT_TO_POINTER (TRUE));
2180         g_hash_table_insert (key_table, (char *) "nomangle", GINT_TO_POINTER (TRUE));
2181         g_hash_table_insert (key_table, (char *) "nometadata", GINT_TO_POINTER (TRUE));
2182         g_hash_table_insert (key_table, (char *) "noncasdemand", GINT_TO_POINTER (TRUE));
2183         g_hash_table_insert (key_table, (char *) "noncasinheritance", GINT_TO_POINTER (TRUE));
2184         g_hash_table_insert (key_table, (char *) "noncaslinkdemand", GINT_TO_POINTER (TRUE));
2185         g_hash_table_insert (key_table, (char *) "nop", GINT_TO_POINTER (TRUE));
2186         g_hash_table_insert (key_table, (char *) "noprocess", GINT_TO_POINTER (TRUE));
2187         g_hash_table_insert (key_table, (char *) "not", GINT_TO_POINTER (TRUE));
2188         g_hash_table_insert (key_table, (char *) "not_in_gc_heap", GINT_TO_POINTER (TRUE));
2189         g_hash_table_insert (key_table, (char *) "notremotable", GINT_TO_POINTER (TRUE));
2190         g_hash_table_insert (key_table, (char *) "notserialized", GINT_TO_POINTER (TRUE));
2191         g_hash_table_insert (key_table, (char *) "null", GINT_TO_POINTER (TRUE));
2192         g_hash_table_insert (key_table, (char *) "nullref", GINT_TO_POINTER (TRUE));
2193         g_hash_table_insert (key_table, (char *) "object", GINT_TO_POINTER (TRUE));
2194         g_hash_table_insert (key_table, (char *) "objectref", GINT_TO_POINTER (TRUE));
2195         g_hash_table_insert (key_table, (char *) "opt", GINT_TO_POINTER (TRUE));
2196         g_hash_table_insert (key_table, (char *) "optil", GINT_TO_POINTER (TRUE));
2197         g_hash_table_insert (key_table, (char *) "or", GINT_TO_POINTER (TRUE));
2198         g_hash_table_insert (key_table, (char *) "out", GINT_TO_POINTER (TRUE));
2199         g_hash_table_insert (key_table, (char *) "permitonly", GINT_TO_POINTER (TRUE));
2200         g_hash_table_insert (key_table, (char *) "pinned", GINT_TO_POINTER (TRUE));
2201         g_hash_table_insert (key_table, (char *) "pinvokeimpl", GINT_TO_POINTER (TRUE));
2202         g_hash_table_insert (key_table, (char *) "pop", GINT_TO_POINTER (TRUE));
2203         g_hash_table_insert (key_table, (char *) "prefix1", GINT_TO_POINTER (TRUE));
2204         g_hash_table_insert (key_table, (char *) "prefix2", GINT_TO_POINTER (TRUE));
2205         g_hash_table_insert (key_table, (char *) "prefix3", GINT_TO_POINTER (TRUE));
2206         g_hash_table_insert (key_table, (char *) "prefix4", GINT_TO_POINTER (TRUE));
2207         g_hash_table_insert (key_table, (char *) "prefix5", GINT_TO_POINTER (TRUE));
2208         g_hash_table_insert (key_table, (char *) "prefix6", GINT_TO_POINTER (TRUE));
2209         g_hash_table_insert (key_table, (char *) "prefix7", GINT_TO_POINTER (TRUE));
2210         g_hash_table_insert (key_table, (char *) "prefixref", GINT_TO_POINTER (TRUE));
2211         g_hash_table_insert (key_table, (char *) "prejitdeny", GINT_TO_POINTER (TRUE));
2212         g_hash_table_insert (key_table, (char *) "prejitgrant", GINT_TO_POINTER (TRUE));
2213         g_hash_table_insert (key_table, (char *) "preservesig", GINT_TO_POINTER (TRUE));
2214         g_hash_table_insert (key_table, (char *) "private", GINT_TO_POINTER (TRUE));
2215         g_hash_table_insert (key_table, (char *) "Compilercontrolled", GINT_TO_POINTER (TRUE));
2216         g_hash_table_insert (key_table, (char *) "protected", GINT_TO_POINTER (TRUE));
2217         g_hash_table_insert (key_table, (char *) "public", GINT_TO_POINTER (TRUE));
2218         g_hash_table_insert (key_table, (char *) "readonly", GINT_TO_POINTER (TRUE));
2219         g_hash_table_insert (key_table, (char *) "record", GINT_TO_POINTER (TRUE));
2220         g_hash_table_insert (key_table, (char *) "refany", GINT_TO_POINTER (TRUE));
2221         g_hash_table_insert (key_table, (char *) "refanytype", GINT_TO_POINTER (TRUE));
2222         g_hash_table_insert (key_table, (char *) "refanyval", GINT_TO_POINTER (TRUE));
2223         g_hash_table_insert (key_table, (char *) "rem", GINT_TO_POINTER (TRUE));
2224         g_hash_table_insert (key_table, (char *) "rem.un", GINT_TO_POINTER (TRUE));
2225         g_hash_table_insert (key_table, (char *) "reqmin", GINT_TO_POINTER (TRUE));
2226         g_hash_table_insert (key_table, (char *) "reqopt", GINT_TO_POINTER (TRUE));
2227         g_hash_table_insert (key_table, (char *) "reqrefuse", GINT_TO_POINTER (TRUE));
2228         g_hash_table_insert (key_table, (char *) "reqsecobj", GINT_TO_POINTER (TRUE));
2229         g_hash_table_insert (key_table, (char *) "request", GINT_TO_POINTER (TRUE));
2230         g_hash_table_insert (key_table, (char *) "ret", GINT_TO_POINTER (TRUE));
2231         g_hash_table_insert (key_table, (char *) "rethrow", GINT_TO_POINTER (TRUE));
2232         g_hash_table_insert (key_table, (char *) "retval", GINT_TO_POINTER (TRUE));
2233         g_hash_table_insert (key_table, (char *) "rtspecialname", GINT_TO_POINTER (TRUE));
2234         g_hash_table_insert (key_table, (char *) "runtime", GINT_TO_POINTER (TRUE));
2235         g_hash_table_insert (key_table, (char *) "safearray", GINT_TO_POINTER (TRUE));
2236         g_hash_table_insert (key_table, (char *) "sealed", GINT_TO_POINTER (TRUE));
2237         g_hash_table_insert (key_table, (char *) "sequential", GINT_TO_POINTER (TRUE));
2238         g_hash_table_insert (key_table, (char *) "serializable", GINT_TO_POINTER (TRUE));
2239         g_hash_table_insert (key_table, (char *) "shl", GINT_TO_POINTER (TRUE));
2240         g_hash_table_insert (key_table, (char *) "shr", GINT_TO_POINTER (TRUE));
2241         g_hash_table_insert (key_table, (char *) "shr.un", GINT_TO_POINTER (TRUE));
2242         g_hash_table_insert (key_table, (char *) "sizeof", GINT_TO_POINTER (TRUE));
2243         g_hash_table_insert (key_table, (char *) "special", GINT_TO_POINTER (TRUE));
2244         g_hash_table_insert (key_table, (char *) "specialname", GINT_TO_POINTER (TRUE));
2245         g_hash_table_insert (key_table, (char *) "starg", GINT_TO_POINTER (TRUE));
2246         g_hash_table_insert (key_table, (char *) "starg.s", GINT_TO_POINTER (TRUE));
2247         g_hash_table_insert (key_table, (char *) "static", GINT_TO_POINTER (TRUE));
2248         g_hash_table_insert (key_table, (char *) "stdcall", GINT_TO_POINTER (TRUE));
2249         g_hash_table_insert (key_table, (char *) "stdcall", GINT_TO_POINTER (TRUE));
2250         g_hash_table_insert (key_table, (char *) "stelem.i", GINT_TO_POINTER (TRUE));
2251         g_hash_table_insert (key_table, (char *) "stelem.i1", GINT_TO_POINTER (TRUE));
2252         g_hash_table_insert (key_table, (char *) "stelem.i2", GINT_TO_POINTER (TRUE));
2253         g_hash_table_insert (key_table, (char *) "stelem.i4", GINT_TO_POINTER (TRUE));
2254         g_hash_table_insert (key_table, (char *) "stelem.i8", GINT_TO_POINTER (TRUE));
2255         g_hash_table_insert (key_table, (char *) "stelem.r4", GINT_TO_POINTER (TRUE));
2256         g_hash_table_insert (key_table, (char *) "stelem.r8", GINT_TO_POINTER (TRUE));
2257         g_hash_table_insert (key_table, (char *) "stelem.ref", GINT_TO_POINTER (TRUE));
2258         g_hash_table_insert (key_table, (char *) "stfld", GINT_TO_POINTER (TRUE));
2259         g_hash_table_insert (key_table, (char *) "stind.i", GINT_TO_POINTER (TRUE));
2260         g_hash_table_insert (key_table, (char *) "stind.i1", GINT_TO_POINTER (TRUE));
2261         g_hash_table_insert (key_table, (char *) "stind.i2", GINT_TO_POINTER (TRUE));
2262         g_hash_table_insert (key_table, (char *) "stind.i4", GINT_TO_POINTER (TRUE));
2263         g_hash_table_insert (key_table, (char *) "stind.i8", GINT_TO_POINTER (TRUE));
2264         g_hash_table_insert (key_table, (char *) "stind.r4", GINT_TO_POINTER (TRUE));
2265         g_hash_table_insert (key_table, (char *) "stind.r8", GINT_TO_POINTER (TRUE));
2266 }