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 (strlen (name) == 0)
1065                 return g_strdup (name);
1066
1067         for (s = name; *s; s++) {
1068                 if (isalnum (*s) || *s == '_' || *s == '$' || *s == '@' || *s == '?' || *s == '.' || *s == 0)
1069                         continue;
1070                 return g_strdup_printf ("'%s'", name);
1071         }
1072
1073         if (g_hash_table_lookup (key_table, name))
1074                 return g_strdup_printf ("'%s'", name);
1075
1076         return g_strdup (name);
1077 }
1078
1079 static dis_map_t param_map [] = {
1080         { PARAM_ATTRIBUTE_IN,                "[in] " },
1081         { PARAM_ATTRIBUTE_OUT,               "[out] " },
1082         { PARAM_ATTRIBUTE_OPTIONAL,          "optional " },
1083         { PARAM_ATTRIBUTE_HAS_DEFAULT,       "hasdefault " },
1084         { PARAM_ATTRIBUTE_HAS_FIELD_MARSHAL, "fieldmarshal " },
1085         { 0, NULL }
1086 };
1087
1088 char *
1089 param_flags (guint32 f)
1090 {
1091         return g_strdup (flags (f, param_map));
1092 }
1093
1094 static dis_map_t field_access_map [] = {
1095         { FIELD_ATTRIBUTE_COMPILER_CONTROLLED, "compilercontrolled " },
1096         { FIELD_ATTRIBUTE_PRIVATE,             "private " },
1097         { FIELD_ATTRIBUTE_FAM_AND_ASSEM,       "famandassem " },
1098         { FIELD_ATTRIBUTE_ASSEMBLY,            "assembly " },
1099         { FIELD_ATTRIBUTE_FAMILY,              "family " },
1100         { FIELD_ATTRIBUTE_FAM_OR_ASSEM,        "famorassem " },
1101         { FIELD_ATTRIBUTE_PUBLIC,              "public " },
1102         { 0, NULL }
1103 };
1104
1105 static dis_map_t field_flags_map [] = {
1106         { FIELD_ATTRIBUTE_STATIC,              "static " },
1107         { FIELD_ATTRIBUTE_INIT_ONLY,           "initonly " },
1108         { FIELD_ATTRIBUTE_LITERAL,             "literal " },
1109         { FIELD_ATTRIBUTE_NOT_SERIALIZED,      "notserialized " },
1110         { FIELD_ATTRIBUTE_SPECIAL_NAME,        "specialname " },
1111         { FIELD_ATTRIBUTE_PINVOKE_IMPL,        "FIXME:pinvokeimpl " },
1112         { FIELD_ATTRIBUTE_RT_SPECIAL_NAME,        "rtspecialname " },
1113         { FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL,        "hasfieldmarshal " },
1114         { 0, NULL }
1115 };
1116
1117 /**
1118  * field_flags:
1119  *
1120  * Returns a stringified version of a Field's flags
1121  */
1122 char *
1123 field_flags (guint32 f)
1124 {
1125         char buffer [1024];
1126         int access = f & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK;
1127
1128         buffer [0] = 0;
1129
1130         strcat (buffer, map (access, field_access_map));
1131         strcat (buffer, flags (f, field_flags_map));
1132         return g_strdup (buffer);
1133 }
1134
1135 /**
1136  * Returns a stringifed representation of a MethodRefSig (22.2.2)
1137  */
1138 char *
1139 get_methodref_signature (MonoImage *m, guint32 blob_signature, const char *fancy_name)
1140 {
1141         GString *res = g_string_new ("");
1142         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
1143         char *allocated_ret_type, *s;
1144         gboolean has_vararg = 0, seen_vararg = 0;
1145         int param_count, signature_len;
1146         int i, gen_count = 0;
1147         int cconv;
1148
1149         signature_len = mono_metadata_decode_value (ptr, &ptr);
1150
1151         if (*ptr & 0x05){
1152                 g_string_append (res, "vararg ");
1153                 has_vararg = 1;
1154         }
1155
1156         if (*ptr & 0x20){
1157                 if (*ptr & 0x40)
1158                         g_string_append (res, "explicit-this ");
1159                 else
1160                         g_string_append (res, "instance "); /* has-this */
1161         }
1162
1163         if (*ptr & 0x10)
1164                 gen_count = 1;
1165         cconv = *ptr & 0x0f;
1166         ptr++;
1167         if (gen_count)
1168                 gen_count = mono_metadata_decode_value (ptr, &ptr);
1169         param_count = mono_metadata_decode_value (ptr, &ptr);
1170         if (cconv != 0xa) {
1171                 ptr = get_ret_type (m, ptr, &allocated_ret_type);
1172                 g_string_append (res, allocated_ret_type);
1173                 g_free (allocated_ret_type);
1174         }
1175
1176         if (fancy_name){
1177                 g_string_append_c (res, ' ');
1178                 g_string_append (res, fancy_name);
1179         }
1180
1181         g_string_append (res, "(");
1182
1183         /*
1184          * param_count describes parameters *before* and *after*
1185          * the vararg sentinel
1186          */
1187         for (i = 0; i < param_count; i++){
1188                 char *param = NULL;
1189
1190                 /*
1191                  * If ptr is a SENTINEL
1192                  */
1193                 if (*ptr == 0x41){
1194                         if (!seen_vararg){
1195                                 g_string_append (res, "..., ");
1196                                 seen_vararg = 1;
1197                         }
1198
1199                         ptr++;
1200                 }
1201
1202                 ptr = get_param (m, ptr, &param);
1203                 g_string_append (res, param);
1204                 if (i+1 != param_count)
1205                         g_string_append (res, ", ");
1206                 g_free (param);
1207         }
1208         g_string_append (res, ")");
1209
1210         /*
1211          * cleanup and return
1212          */
1213         s = res->str;
1214         g_string_free (res, FALSE);
1215         return s;
1216 }
1217
1218 /**
1219  * Returns a stringifed representation of a field ref
1220  */
1221 char *
1222 get_fieldref_signature (MonoImage *m, int idx)
1223 {
1224         guint32 cols [MONO_MEMBERREF_SIZE];
1225         char *sig;
1226         char *full_sig;
1227
1228         mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1229                         idx - 1, cols, MONO_MEMBERREF_SIZE);
1230
1231         sig = get_field_signature (m, cols [MONO_MEMBERREF_SIGNATURE]);
1232         full_sig = g_strdup_printf ("%s %s::%s", sig,
1233                         get_memberref_parent (m, cols [MONO_MEMBERREF_CLASS]),
1234                         mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));
1235         g_free (sig);
1236
1237         return full_sig;
1238 }
1239
1240 /**
1241  * get_field:
1242  * @m: metadata context
1243  * @token: a FIELD_DEF token
1244  *
1245  * This routine has to locate the TypeDef that "owns" this Field.
1246  * Since there is no backpointer in the Field table, we have to scan
1247  * the TypeDef table and locate the actual "owner" of the field
1248  */
1249 char *
1250 get_field (MonoImage *m, guint32 token)
1251 {
1252         int idx = mono_metadata_token_index (token);
1253         guint32 cols [MONO_FIELD_SIZE];
1254         char *sig, *res, *type, *estype, *esname;
1255         guint32 type_idx;
1256
1257         /*
1258          * We can get here also with a MenberRef token (for a field
1259          * defined in another module/assembly, just like in get_method ()
1260          */
1261         if (mono_metadata_token_code (token) == MONO_TOKEN_MEMBER_REF) {
1262                 return get_fieldref_signature (m, idx);
1263         }
1264         g_assert (mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF);
1265
1266         mono_metadata_decode_row (&m->tables [MONO_TABLE_FIELD], idx - 1, cols, MONO_FIELD_SIZE);
1267         sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE]);
1268
1269         /*
1270          * To locate the actual "container" for this field, we have to scan
1271          * the TypeDef table.  LAME!
1272          */
1273         type_idx = mono_metadata_typedef_from_field (m, idx);
1274
1275         type = get_typedef (m, type_idx);
1276         estype = get_escaped_name (type);
1277         esname = get_escaped_name (mono_metadata_string_heap (m, cols [MONO_FIELD_NAME]));
1278         res = g_strdup_printf ("%s %s::%s",
1279                         sig, estype, esname);
1280
1281         g_free (type);
1282         g_free (sig);
1283         g_free (estype);
1284         g_free (esname);
1285
1286         return res;
1287 }
1288
1289 static char *
1290 get_memberref_parent (MonoImage *m, guint32 mrp_token)
1291 {
1292         /*
1293          * mrp_index is a MemberRefParent coded index
1294          */
1295         guint32 table = mrp_token & 7;
1296         guint32 idx = mrp_token >> 3;
1297
1298         switch (table){
1299         case 0: /* TypeDef */
1300                 return get_typedef (m, idx);
1301
1302         case 1: /* TypeRef */
1303                 return get_typeref (m, idx);
1304
1305         case 2: /* ModuleRef */
1306                 return g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
1307
1308         case 3: /* MethodDef */
1309                 return g_strdup ("TODO:MethodDef");
1310
1311         case 4: /* TypeSpec */
1312                 return get_typespec (m, idx);
1313         }
1314         g_assert_not_reached ();
1315         return NULL;
1316 }
1317
1318 /**
1319  * get_method:
1320  * @m: metadata context
1321  * @token: a METHOD_DEF or MEMBER_REF token
1322  *
1323  * This routine has to locate the TypeDef that "owns" this Field.
1324  * Since there is no backpointer in the Field table, we have to scan
1325  * the TypeDef table and locate the actual "owner" of the field
1326  */
1327 char *
1328 get_method (MonoImage *m, guint32 token)
1329 {
1330         int idx = mono_metadata_token_index (token);
1331         guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
1332         char *sig, *esname;
1333         const char *name;
1334
1335         MonoMethod *mh;
1336
1337         mh = mono_get_method (m, token, NULL);
1338         if (mh) {
1339                 esname = get_escaped_name (mh->name);
1340                 sig = dis_stringify_object_with_class (m, mh->klass);
1341                 if (show_tokens)
1342                         name = g_strdup_printf ("%s/*%08x*/::%s", sig, token, esname);
1343                 else
1344                         name = g_strdup_printf ("%s::%s", sig, esname);
1345                 g_free (sig);
1346                 g_free (esname);
1347         } else
1348                 name = NULL;
1349
1350         switch (mono_metadata_token_code (token)){
1351         case MONO_TOKEN_METHOD_DEF:
1352                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1353                                           idx - 1, method_cols, MONO_METHOD_SIZE);
1354
1355                 sig = get_methodref_signature (m, method_cols [MONO_METHOD_SIGNATURE], name);
1356                 break;
1357
1358         case MONO_TOKEN_MEMBER_REF: {
1359                 mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1360                                           idx - 1, member_cols, MONO_MEMBERREF_SIZE);
1361                 if (!name)
1362                         name = g_strdup_printf ("%s::%s",
1363                                         get_memberref_parent (m, member_cols [MONO_MEMBERREF_CLASS]),
1364                                         mono_metadata_string_heap (m, member_cols [MONO_MEMBERREF_NAME]));
1365                 sig = get_methodref_signature (
1366                         m, member_cols [MONO_MEMBERREF_SIGNATURE], name);
1367                 break;
1368         }
1369         case MONO_TOKEN_METHOD_SPEC: {
1370                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHODSPEC],
1371                                 idx - 1, member_cols, MONO_METHODSPEC_SIZE);
1372                 token = member_cols [MONO_METHODSPEC_METHOD];
1373                 sig = get_methodspec (m, idx, token, name);
1374                 break;
1375         }
1376
1377         default:
1378                 g_assert_not_reached ();
1379         }
1380
1381         if (show_tokens) {
1382                 char *retval = g_strdup_printf ("%s /* %08x */", sig, token);
1383                 g_free (sig);
1384                 return retval;
1385         } else
1386                 return sig;
1387 }
1388
1389 /**
1390  * get_methoddef
1391  * @m: metadata context
1392  * @idx: index into the method table
1393  *
1394  * Returns: A stringified version of the method signature.
1395  */
1396 char *
1397 get_methoddef (MonoImage *m, guint32 idx)
1398 {
1399         guint32 cols [MONO_METHOD_SIZE];
1400         char *sig;
1401         const char *name;
1402
1403         MonoMethod *mh;
1404
1405         mh = mono_get_method (m, MONO_TOKEN_METHOD_DEF | idx, NULL);
1406         if (mh) {
1407                 sig = dis_stringify_object_with_class (m, mh->klass);
1408                 name = g_strdup_printf ("%s::%s", sig, mh->name);
1409                 g_free (sig);
1410         } else
1411                 name = NULL;
1412         mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1413                         idx - 1, cols, MONO_METHOD_SIZE);
1414         sig = get_methodref_signature (m, cols [MONO_METHOD_SIGNATURE], name);
1415
1416         return sig;
1417 }
1418
1419 char *
1420 get_method_type_param (MonoImage *m, guint32 blob_signature)
1421 {
1422         GString *res = g_string_new ("");
1423         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
1424         int param_count;
1425         int i = 0;
1426         char *s;
1427
1428         mono_metadata_decode_value (ptr, &ptr);
1429         ptr++;
1430         param_count = mono_metadata_decode_value (ptr, &ptr);
1431
1432         g_string_append_c (res, '<');
1433
1434         for (i = 0; i < param_count; i++){
1435                 char *param = NULL;
1436
1437                 ptr = get_param (m, ptr, &param);
1438                 g_string_append (res, param);
1439                 if (i+1 != param_count)
1440                         g_string_append (res, ", ");
1441                 g_free (param);
1442         }
1443         g_string_append_c (res, '>');
1444
1445         s = res->str;
1446         g_string_free (res, FALSE);
1447         return s;
1448 }
1449
1450 /**
1451  * get_methodspec
1452  *
1453  * Returns: An allocated stringified version of the methodspec signature.
1454  */
1455
1456 char *
1457 get_methodspec (MonoImage *m, int idx, guint32 token, const char *fancy_name)
1458 {
1459         GString *res = g_string_new ("");
1460         guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
1461         char *s, *type_param;
1462         const char *ptr;
1463         guint32 sig;
1464         int param_count, cconv, i, gen_count = 0;
1465
1466         switch (token & METHODDEFORREF_MASK) {
1467         case METHODDEFORREF_METHODDEF:
1468                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1469                                           (token >> METHODDEFORREF_BITS) - 1,
1470                                           method_cols, MONO_METHOD_SIZE);
1471                 sig = method_cols [MONO_METHOD_SIGNATURE];
1472                 break;
1473         case METHODDEFORREF_METHODREF:
1474                 mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1475                                           (token >> METHODDEFORREF_BITS) - 1,
1476                                           member_cols, MONO_MEMBERREF_SIZE);
1477                 sig = member_cols [MONO_MEMBERREF_SIGNATURE];
1478                 break;
1479         default:
1480                 g_assert_not_reached ();
1481         }
1482
1483         ptr = mono_metadata_blob_heap (m, sig);
1484         mono_metadata_decode_value (ptr, &ptr);
1485
1486         if (*ptr & 0x20){
1487                 if (*ptr & 0x40)
1488                         g_string_append (res, "explicit-this ");
1489                 else
1490                         g_string_append (res, "instance "); /* has-this */
1491         }
1492
1493         if (*ptr & 0x10)
1494                 gen_count = 1;
1495         cconv = *ptr & 0x0f;
1496         ptr++;
1497         if (gen_count)
1498                 gen_count = mono_metadata_decode_value (ptr, &ptr);
1499         param_count = mono_metadata_decode_value (ptr, &ptr);
1500         if (cconv != 0xa) {
1501                 char *allocated_ret_type;
1502                 ptr = get_ret_type (m, ptr, &allocated_ret_type);
1503                 g_string_append (res, allocated_ret_type);
1504                 g_free (allocated_ret_type);
1505         }
1506
1507         if (fancy_name){
1508                 g_string_append_c (res, ' ');
1509                 g_string_append (res, fancy_name);
1510         }
1511
1512         mono_metadata_decode_row (&m->tables [MONO_TABLE_METHODSPEC],
1513                         idx - 1, member_cols, MONO_METHODSPEC_SIZE);
1514         token = member_cols [MONO_METHODSPEC_SIGNATURE];
1515         type_param = get_method_type_param (m, token);
1516         g_string_append (res, type_param);
1517         g_string_append (res, " (");
1518
1519         /*
1520          * methodspecs can not be varargs so we don't need to worry about that here
1521          */
1522
1523         for (i = 0; i < param_count; i++){
1524                 char *param = NULL;
1525
1526                 ptr = get_param (m, ptr, &param);
1527                 g_string_append (res, param);
1528                 if (i+1 != param_count)
1529                         g_string_append (res, ", ");
1530                 g_free (param);
1531         }
1532         g_string_append (res, ")");
1533
1534         /*
1535          * cleanup and return
1536          */
1537         s = res->str;
1538         g_string_free (res, FALSE);
1539         return s;
1540 }
1541
1542
1543 /**
1544  * get_constant:
1545  * @m: metadata context
1546  * @blob_index: index into the blob where the constant is stored
1547  *
1548  * Returns: An allocated value representing a stringified version of the
1549  * constant.
1550  */
1551 char *
1552 get_constant (MonoImage *m, MonoTypeEnum t, guint32 blob_index)
1553 {
1554         const char *ptr = mono_metadata_blob_heap (m, blob_index);
1555         int len;
1556
1557         len = mono_metadata_decode_value (ptr, &ptr);
1558
1559         switch (t){
1560         case MONO_TYPE_BOOLEAN:
1561                 return g_strdup_printf ("%s", *ptr ? "bool(true)" : "bool(false)");
1562
1563         case MONO_TYPE_CHAR:
1564                 return g_strdup_printf ("%c", *ptr); /* FIXME: unicode char */
1565
1566         case MONO_TYPE_U1:
1567         case MONO_TYPE_I1:
1568                 return g_strdup_printf ("int8(0x%02x)", (int) (*ptr));
1569                 break;
1570
1571         case MONO_TYPE_U2:
1572         case MONO_TYPE_I2:
1573                 return g_strdup_printf ("int16(0x%08x)", (int) read16 (ptr));
1574
1575         case MONO_TYPE_U4:
1576         case MONO_TYPE_I4:
1577                 return g_strdup_printf ("int32(%d)", read32 (ptr));
1578
1579         case MONO_TYPE_I8: {
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_U8: {
1586                 guint32 low, high;
1587                 low = read32 (ptr);
1588                 high = read32 (ptr + 4);
1589                 return g_strdup_printf ("0x%08x%08x", high, low);
1590         }
1591         case MONO_TYPE_R4: {
1592                 float r;
1593                 readr4 (ptr, &r);
1594                 return g_strdup_printf ("%g", (double) r);
1595         }
1596         case MONO_TYPE_R8: {
1597                 double r;
1598                 readr8 (ptr, &r);
1599                 return g_strdup_printf ("%g", r);
1600         }
1601         case MONO_TYPE_STRING: {
1602                 int i, j, e;
1603                 char *res;
1604                 e = len = 0;
1605                 for (i = 0; !ptr [i+1]; i += 2){
1606                         len++;
1607                         switch (ptr [i]) {
1608                         case '"':
1609                         case '\\':
1610                         case '\n': /* add more */
1611                                 e++;
1612                         }
1613                 }
1614                 res = g_malloc (len + e + 3);
1615                 j = 1;
1616                 res [0] = '"';
1617
1618                 for (i = 0; i < len; i += 2){
1619                         switch(ptr[i]) {
1620                         case '"':
1621                                 res[j++] = '\\';
1622                                 res[j++] = '"';
1623                         case '\\':
1624                                 res[j++] = '\\';
1625                                 res[j++] = '\\';
1626                         case '\n':
1627                                 res[j++] = '\\';
1628                                 res[j++] = 'n';
1629                                 break;
1630                         default:
1631                                 res[j++] = isprint (ptr [i]) ? ptr [i] : '.';
1632                                 break;
1633                         }
1634                 }
1635                 res[j++] = '"';
1636                 res[j] = 0;
1637                 return res;
1638         }
1639
1640         case MONO_TYPE_CLASS:
1641                 return g_strdup ("CLASS CONSTANT.  MUST BE ZERO");
1642
1643         default:
1644                 g_error ("Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n",
1645                          (int) *ptr, blob_index);
1646                 return g_strdup_printf ("Unknown");
1647         }
1648
1649 }
1650
1651 /**
1652  * get_token:
1653  * @m: metadata context
1654  * @token: token that we want to decode.
1655  *
1656  * Returns: An allocated value representing a stringified version of the
1657  * constant.
1658  */
1659 char *
1660 get_token (MonoImage *m, guint32 token)
1661 {
1662         char *temp, *result;
1663         guint32 idx = mono_metadata_token_index (token);
1664
1665         switch (mono_metadata_token_code (token)){
1666         case MONO_TOKEN_FIELD_DEF:
1667                 temp = get_field (m, token);
1668                 result = g_strdup_printf ("field %s", temp);
1669                 g_free (temp);
1670                 return result;
1671         case MONO_TOKEN_TYPE_DEF:
1672                 return get_typedef (m, idx);
1673         case MONO_TOKEN_TYPE_REF:
1674                 return get_typeref (m, idx);
1675         case MONO_TOKEN_TYPE_SPEC:
1676                 return get_typespec (m, idx);
1677         default:
1678                 g_error ("Do not know how to decode tokens of type 0x%08x", token);
1679         }
1680
1681         g_assert_not_reached ();
1682         return g_strdup ("ERROR");
1683 }
1684
1685 /**
1686  * get_token_type:
1687  * @m: metadata context
1688  * @token: the token can belong to any of the following tables:
1689  * MONO_TOKEN_TYPE_REF, MONO_TOKEN_TYPE_DEF, MONO_TOKEN_TYPE_SPEC
1690  *
1691  * Returns: a stringified version of the MethodDef or MethodRef or TypeSpecn
1692  * at (token & 0xffffff)
1693  */
1694 char *
1695 get_token_type (MonoImage *m, guint32 token)
1696 {
1697         char *temp = NULL, *s = NULL;
1698         int idx;
1699
1700         idx = mono_metadata_token_index (token);
1701
1702         switch (mono_metadata_token_code (token)){
1703         case MONO_TOKEN_TYPE_DEF:
1704                 temp = get_typedef (m, idx);
1705                 s = g_strdup_printf ("%s", temp);
1706                 break;
1707
1708         case MONO_TOKEN_TYPE_REF:
1709                 temp = get_typeref (m, idx);
1710                 s = g_strdup_printf ("%s", temp);
1711                 break;
1712
1713         case MONO_TOKEN_TYPE_SPEC:
1714                 s = get_typespec (m, idx);
1715                 break;
1716
1717         default:
1718                 g_error ("Unhandled encoding for token 0x%08x", token);
1719
1720         }
1721
1722         if (temp)
1723                 g_free (temp);
1724
1725         return s;
1726 }
1727
1728 char *
1729 get_guid (MonoImage *m, guint32 guid_index)
1730 {
1731         const unsigned char *guid;
1732         char *result;
1733
1734         guid = mono_metadata_guid_heap (m, guid_index);
1735
1736         result = g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
1737                         guid [3], guid [2], guid [1], guid [0], guid [5], guid [4], guid [7], guid [6],
1738                         guid [8], guid [9], guid [10], guid [11], guid [12], guid [13], guid [14], guid [15]);
1739         return result;
1740 }
1741
1742 GList *
1743 dis_get_custom_attrs (MonoImage *m, guint32 token)
1744 {
1745         GList *list = NULL;
1746         guint32 idx, i, len, mtoken;
1747         guint32 cols [MONO_CUSTOM_ATTR_SIZE];
1748         MonoTableInfo *ca;
1749         char *method;
1750         GString *attr;
1751         const char *val;
1752
1753         idx = mono_metadata_token_index (token);
1754         idx <<= CUSTOM_ATTR_BITS;
1755
1756         switch (mono_metadata_token_table (token)) {
1757         case MONO_TABLE_TYPEDEF:
1758                 idx |= CUSTOM_ATTR_TYPEDEF;
1759                 break;
1760         case MONO_TABLE_ASSEMBLY:
1761                 idx |= CUSTOM_ATTR_ASSEMBLY;
1762                 break;
1763         case MONO_TABLE_MODULE:
1764                 idx |= CUSTOM_ATTR_MODULE;
1765                 break;
1766         case MONO_TABLE_PROPERTY:
1767                 idx |= CUSTOM_ATTR_PROPERTY;
1768                 break;
1769         case MONO_TABLE_EVENT:
1770                 idx |= CUSTOM_ATTR_EVENT;
1771                 break;
1772         case MONO_TABLE_FIELD:
1773                 idx |= CUSTOM_ATTR_FIELDDEF;
1774                 break;
1775         case MONO_TABLE_METHOD:
1776                 idx |= CUSTOM_ATTR_METHODDEF;
1777                 break;
1778         case MONO_TABLE_PARAM:
1779                 idx |= CUSTOM_ATTR_PARAMDEF;
1780                 break;
1781         default:
1782                 g_print ("Missing custom attr get support for token 0x%08x\n", token);
1783                 return NULL;
1784         }
1785
1786         ca = &m->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1787         /* the table is not sorted */
1788         for (i = 0; i < ca->rows; ++i) {
1789                 char *dump;
1790                 mono_metadata_decode_row (ca, i, cols, MONO_CUSTOM_ATTR_SIZE);
1791                 if (cols [MONO_CUSTOM_ATTR_PARENT] != idx)
1792                         continue;
1793                 mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> CUSTOM_ATTR_TYPE_BITS;
1794                 switch (cols [MONO_CUSTOM_ATTR_TYPE] & CUSTOM_ATTR_TYPE_MASK) {
1795                 case CUSTOM_ATTR_TYPE_METHODDEF:
1796                         mtoken |= MONO_TOKEN_METHOD_DEF;
1797                         break;
1798                 case CUSTOM_ATTR_TYPE_MEMBERREF:
1799                         mtoken |= MONO_TOKEN_MEMBER_REF;
1800                         break;
1801                 default:
1802                         g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
1803                         break;
1804                 }
1805                 method = get_method (m, mtoken);
1806                 val = mono_metadata_blob_heap (m, cols [MONO_CUSTOM_ATTR_VALUE]);
1807                 len = mono_metadata_decode_value (val, &val);
1808                 attr = g_string_new (".custom ");
1809                 dump = data_dump (val, len, "\t\t");
1810                 g_string_sprintfa (attr, "%s = %s", method, dump);
1811                 g_free (dump);
1812                 list = g_list_append (list, attr->str);
1813                 g_string_free (attr, FALSE);
1814                 g_free (method);
1815         }
1816         return list;
1817 }
1818
1819 char*
1820 get_marshal_info (MonoImage *m, const char *blob) {
1821         int len, size = 0;
1822
1823         len = mono_metadata_decode_blob_size (blob, &blob);
1824
1825         switch (*blob) {
1826         case MONO_NATIVE_BOOLEAN:
1827                 return g_strdup ("bool");
1828         case MONO_NATIVE_I1:
1829                 return g_strdup ("int8");
1830         case MONO_NATIVE_U1:
1831                 return g_strdup ("unsigned int8");
1832         case MONO_NATIVE_I2:
1833                 return g_strdup ("int16");
1834         case MONO_NATIVE_U2:
1835                 return g_strdup ("unsigned int16");
1836         case MONO_NATIVE_I4:
1837                 return g_strdup ("int32");
1838         case MONO_NATIVE_U4:
1839                 return g_strdup ("unsigned int32");
1840         case MONO_NATIVE_I8:
1841                 return g_strdup ("int64");
1842         case MONO_NATIVE_U8:
1843                 return g_strdup ("unsigned int64");
1844         case MONO_NATIVE_R4:
1845                 return g_strdup ("float32");
1846         case MONO_NATIVE_R8:
1847                 return g_strdup ("float64");
1848         case MONO_NATIVE_CURRENCY:
1849                 return g_strdup ("currency");
1850         case MONO_NATIVE_BSTR:
1851                 return g_strdup ("bstr");
1852         case MONO_NATIVE_LPSTR:
1853                 return g_strdup ("lpstr");
1854         case MONO_NATIVE_LPWSTR:
1855                 return g_strdup ("lpwstr");
1856         case MONO_NATIVE_LPTSTR:
1857                 return g_strdup ("lptstr");
1858         case MONO_NATIVE_BYVALTSTR:
1859                 size = mono_metadata_decode_value (blob + 1, &blob);
1860                 return g_strdup_printf ("fixed sysstring [%d]", size);
1861         case MONO_NATIVE_IUNKNOWN:
1862                 return g_strdup ("iunknown");
1863         case MONO_NATIVE_IDISPATCH:
1864                 return g_strdup ("idispatch");
1865         case MONO_NATIVE_STRUCT:
1866                 return g_strdup ("struct");
1867         case MONO_NATIVE_INTERFACE:
1868                 return g_strdup ("interface");
1869         case MONO_NATIVE_SAFEARRAY:
1870                 return g_strdup ("safearray");
1871         case MONO_NATIVE_BYVALARRAY:
1872                 size = mono_metadata_decode_value (blob + 1, &blob);
1873                 return g_strdup_printf ("fixed array [%d]", size);
1874         case MONO_NATIVE_INT:
1875                 return g_strdup ("int");
1876         case MONO_NATIVE_UINT:
1877                 return g_strdup ("unsigned int");
1878         case MONO_NATIVE_VBBYREFSTR:
1879                 return g_strdup ("vbbyrefstr");
1880         case MONO_NATIVE_ANSIBSTR:
1881                 return g_strdup ("ansi bstr");
1882         case MONO_NATIVE_TBSTR:
1883                 return g_strdup ("tbstr");
1884         case MONO_NATIVE_VARIANTBOOL:
1885                 return g_strdup ("variant bool");
1886         case MONO_NATIVE_FUNC:
1887                 return g_strdup ("method");
1888         case MONO_NATIVE_ASANY:
1889                 return g_strdup ("as any");
1890         case MONO_NATIVE_LPARRAY:
1891                 return g_strdup ("[]");
1892         case MONO_NATIVE_LPSTRUCT:
1893                 return g_strdup ("lpstruct");
1894         case MONO_NATIVE_CUSTOM:
1895                 return g_strdup ("custom");
1896         case MONO_NATIVE_ERROR:
1897                 return g_strdup ("error");
1898         default:
1899                 return g_strdup ("unknown");
1900         }
1901 }
1902
1903 void
1904 init_key_table (void)
1905 {
1906         key_table = g_hash_table_new (g_str_hash, g_str_equal);
1907
1908         /* auto generated */
1909         g_hash_table_insert (key_table, (char *) "abstract", GINT_TO_POINTER (TRUE));
1910         g_hash_table_insert (key_table, (char *) "add", GINT_TO_POINTER (TRUE));
1911         g_hash_table_insert (key_table, (char *) "add.ovf", GINT_TO_POINTER (TRUE));
1912         g_hash_table_insert (key_table, (char *) "add.ovf.un", GINT_TO_POINTER (TRUE));
1913         g_hash_table_insert (key_table, (char *) "algorithm", GINT_TO_POINTER (TRUE));
1914         g_hash_table_insert (key_table, (char *) "alignment", GINT_TO_POINTER (TRUE));
1915         g_hash_table_insert (key_table, (char *) "and", GINT_TO_POINTER (TRUE));
1916         g_hash_table_insert (key_table, (char *) "ansi", GINT_TO_POINTER (TRUE));
1917         g_hash_table_insert (key_table, (char *) "any", GINT_TO_POINTER (TRUE));
1918         g_hash_table_insert (key_table, (char *) "arglist", GINT_TO_POINTER (TRUE));
1919         g_hash_table_insert (key_table, (char *) "array", GINT_TO_POINTER (TRUE));
1920         g_hash_table_insert (key_table, (char *) "as", GINT_TO_POINTER (TRUE));
1921         g_hash_table_insert (key_table, (char *) "assembly", GINT_TO_POINTER (TRUE));
1922         g_hash_table_insert (key_table, (char *) "assert", GINT_TO_POINTER (TRUE));
1923         g_hash_table_insert (key_table, (char *) "at", GINT_TO_POINTER (TRUE));
1924         g_hash_table_insert (key_table, (char *) "auto", GINT_TO_POINTER (TRUE));
1925         g_hash_table_insert (key_table, (char *) "autochar", GINT_TO_POINTER (TRUE));
1926         g_hash_table_insert (key_table, (char *) "beforefieldinit", GINT_TO_POINTER (TRUE));
1927         g_hash_table_insert (key_table, (char *) "beq", GINT_TO_POINTER (TRUE));
1928         g_hash_table_insert (key_table, (char *) "beq.s", GINT_TO_POINTER (TRUE));
1929         g_hash_table_insert (key_table, (char *) "bge", GINT_TO_POINTER (TRUE));
1930         g_hash_table_insert (key_table, (char *) "bge.s", GINT_TO_POINTER (TRUE));
1931         g_hash_table_insert (key_table, (char *) "bge.un", GINT_TO_POINTER (TRUE));
1932         g_hash_table_insert (key_table, (char *) "bge.un.s", GINT_TO_POINTER (TRUE));
1933         g_hash_table_insert (key_table, (char *) "bgt", GINT_TO_POINTER (TRUE));
1934         g_hash_table_insert (key_table, (char *) "bgt.s", GINT_TO_POINTER (TRUE));
1935         g_hash_table_insert (key_table, (char *) "bgt.un", GINT_TO_POINTER (TRUE));
1936         g_hash_table_insert (key_table, (char *) "9", GINT_TO_POINTER (TRUE));
1937         g_hash_table_insert (key_table, (char *) "bgt.un.s", GINT_TO_POINTER (TRUE));
1938         g_hash_table_insert (key_table, (char *) "ble", GINT_TO_POINTER (TRUE));
1939         g_hash_table_insert (key_table, (char *) "ble.s", GINT_TO_POINTER (TRUE));
1940         g_hash_table_insert (key_table, (char *) "ble.un", GINT_TO_POINTER (TRUE));
1941         g_hash_table_insert (key_table, (char *) "ble.un.s", GINT_TO_POINTER (TRUE));
1942         g_hash_table_insert (key_table, (char *) "blob", GINT_TO_POINTER (TRUE));
1943         g_hash_table_insert (key_table, (char *) "blob_object", GINT_TO_POINTER (TRUE));
1944         g_hash_table_insert (key_table, (char *) "blt", GINT_TO_POINTER (TRUE));
1945         g_hash_table_insert (key_table, (char *) "blt.s", GINT_TO_POINTER (TRUE));
1946         g_hash_table_insert (key_table, (char *) "blt.un", GINT_TO_POINTER (TRUE));
1947         g_hash_table_insert (key_table, (char *) "blt.un.s", GINT_TO_POINTER (TRUE));
1948         g_hash_table_insert (key_table, (char *) "bne.un", GINT_TO_POINTER (TRUE));
1949         g_hash_table_insert (key_table, (char *) "bne.un.s", GINT_TO_POINTER (TRUE));
1950         g_hash_table_insert (key_table, (char *) "bool", GINT_TO_POINTER (TRUE));
1951         g_hash_table_insert (key_table, (char *) "box", GINT_TO_POINTER (TRUE));
1952         g_hash_table_insert (key_table, (char *) "br", GINT_TO_POINTER (TRUE));
1953         g_hash_table_insert (key_table, (char *) "br.s", GINT_TO_POINTER (TRUE));
1954         g_hash_table_insert (key_table, (char *) "break", GINT_TO_POINTER (TRUE));
1955         g_hash_table_insert (key_table, (char *) "brfalse", GINT_TO_POINTER (TRUE));
1956         g_hash_table_insert (key_table, (char *) "brfalse.s", GINT_TO_POINTER (TRUE));
1957         g_hash_table_insert (key_table, (char *) "brinst", GINT_TO_POINTER (TRUE));
1958         g_hash_table_insert (key_table, (char *) "brinst.s", GINT_TO_POINTER (TRUE));
1959         g_hash_table_insert (key_table, (char *) "brnull", GINT_TO_POINTER (TRUE));
1960         g_hash_table_insert (key_table, (char *) "brnull.s", GINT_TO_POINTER (TRUE));
1961         g_hash_table_insert (key_table, (char *) "brtrue", GINT_TO_POINTER (TRUE));
1962         g_hash_table_insert (key_table, (char *) "brtrue.s", GINT_TO_POINTER (TRUE));
1963         g_hash_table_insert (key_table, (char *) "brzero", GINT_TO_POINTER (TRUE));
1964         g_hash_table_insert (key_table, (char *) "brzero.s", GINT_TO_POINTER (TRUE));
1965         g_hash_table_insert (key_table, (char *) "bstr", GINT_TO_POINTER (TRUE));
1966         g_hash_table_insert (key_table, (char *) "bytearray", GINT_TO_POINTER (TRUE));
1967         g_hash_table_insert (key_table, (char *) "byvalstr", GINT_TO_POINTER (TRUE));
1968         g_hash_table_insert (key_table, (char *) "call", GINT_TO_POINTER (TRUE));
1969         g_hash_table_insert (key_table, (char *) "calli", GINT_TO_POINTER (TRUE));
1970         g_hash_table_insert (key_table, (char *) "callmostderived", GINT_TO_POINTER (TRUE));
1971         g_hash_table_insert (key_table, (char *) "callvirt", GINT_TO_POINTER (TRUE));
1972         g_hash_table_insert (key_table, (char *) "carray", GINT_TO_POINTER (TRUE));
1973         g_hash_table_insert (key_table, (char *) "castclass", GINT_TO_POINTER (TRUE));
1974         g_hash_table_insert (key_table, (char *) "catch", GINT_TO_POINTER (TRUE));
1975         g_hash_table_insert (key_table, (char *) "cdecl", GINT_TO_POINTER (TRUE));
1976         g_hash_table_insert (key_table, (char *) "ceq", GINT_TO_POINTER (TRUE));
1977         g_hash_table_insert (key_table, (char *) "cf", GINT_TO_POINTER (TRUE));
1978         g_hash_table_insert (key_table, (char *) "cgt", GINT_TO_POINTER (TRUE));
1979         g_hash_table_insert (key_table, (char *) "cgt.un", GINT_TO_POINTER (TRUE));
1980         g_hash_table_insert (key_table, (char *) "char", GINT_TO_POINTER (TRUE));
1981         g_hash_table_insert (key_table, (char *) "cil", GINT_TO_POINTER (TRUE));
1982         g_hash_table_insert (key_table, (char *) "ckfinite", GINT_TO_POINTER (TRUE));
1983         g_hash_table_insert (key_table, (char *) "class", GINT_TO_POINTER (TRUE));
1984         g_hash_table_insert (key_table, (char *) "clsid", GINT_TO_POINTER (TRUE));
1985         g_hash_table_insert (key_table, (char *) "clt", GINT_TO_POINTER (TRUE));
1986         g_hash_table_insert (key_table, (char *) "clt.un", GINT_TO_POINTER (TRUE));
1987         g_hash_table_insert (key_table, (char *) "const", GINT_TO_POINTER (TRUE));
1988         g_hash_table_insert (key_table, (char *) "conv.i", GINT_TO_POINTER (TRUE));
1989         g_hash_table_insert (key_table, (char *) "conv.i1", GINT_TO_POINTER (TRUE));
1990         g_hash_table_insert (key_table, (char *) "conv.i2", GINT_TO_POINTER (TRUE));
1991         g_hash_table_insert (key_table, (char *) "conv.i4", GINT_TO_POINTER (TRUE));
1992         g_hash_table_insert (key_table, (char *) "conv.i8", GINT_TO_POINTER (TRUE));
1993         g_hash_table_insert (key_table, (char *) "conv.ovf.i", GINT_TO_POINTER (TRUE));
1994         g_hash_table_insert (key_table, (char *) "conv.ovf.i.un", GINT_TO_POINTER (TRUE));
1995         g_hash_table_insert (key_table, (char *) "conv.ovf.i1", GINT_TO_POINTER (TRUE));
1996         g_hash_table_insert (key_table, (char *) "conv.ovf.i1.un", GINT_TO_POINTER (TRUE));
1997         g_hash_table_insert (key_table, (char *) "conv.ovf.i2", GINT_TO_POINTER (TRUE));
1998         g_hash_table_insert (key_table, (char *) "conv.ovf.i2.un", GINT_TO_POINTER (TRUE));
1999         g_hash_table_insert (key_table, (char *) "conv.ovf.i4", GINT_TO_POINTER (TRUE));
2000         g_hash_table_insert (key_table, (char *) "conv.ovf.i4.un", GINT_TO_POINTER (TRUE));
2001         g_hash_table_insert (key_table, (char *) "conv.ovf.i8", GINT_TO_POINTER (TRUE));
2002         g_hash_table_insert (key_table, (char *) "conv.ovf.i8.un", GINT_TO_POINTER (TRUE));
2003         g_hash_table_insert (key_table, (char *) "conv.ovf.u", GINT_TO_POINTER (TRUE));
2004         g_hash_table_insert (key_table, (char *) "conv.ovf.u.un", GINT_TO_POINTER (TRUE));
2005         g_hash_table_insert (key_table, (char *) "conv.ovf.u1", GINT_TO_POINTER (TRUE));
2006         g_hash_table_insert (key_table, (char *) "conv.ovf.u1.un", GINT_TO_POINTER (TRUE));
2007         g_hash_table_insert (key_table, (char *) "conv.ovf.u2", GINT_TO_POINTER (TRUE));
2008         g_hash_table_insert (key_table, (char *) "conv.ovf.u2.un", GINT_TO_POINTER (TRUE));
2009         g_hash_table_insert (key_table, (char *) "conv.ovf.u4", GINT_TO_POINTER (TRUE));
2010         g_hash_table_insert (key_table, (char *) "conv.ovf.u4.un", GINT_TO_POINTER (TRUE));
2011         g_hash_table_insert (key_table, (char *) "conv.ovf.u8", GINT_TO_POINTER (TRUE));
2012         g_hash_table_insert (key_table, (char *) "conv.ovf.u8.un", GINT_TO_POINTER (TRUE));
2013         g_hash_table_insert (key_table, (char *) "conv.r.un", GINT_TO_POINTER (TRUE));
2014         g_hash_table_insert (key_table, (char *) "conv.r4", GINT_TO_POINTER (TRUE));
2015         g_hash_table_insert (key_table, (char *) "conv.r8", GINT_TO_POINTER (TRUE));
2016         g_hash_table_insert (key_table, (char *) "conv.u", GINT_TO_POINTER (TRUE));
2017         g_hash_table_insert (key_table, (char *) "conv.u1", GINT_TO_POINTER (TRUE));
2018         g_hash_table_insert (key_table, (char *) "conv.u2", GINT_TO_POINTER (TRUE));
2019         g_hash_table_insert (key_table, (char *) "conv.u4", GINT_TO_POINTER (TRUE));
2020         g_hash_table_insert (key_table, (char *) "conv.u8", GINT_TO_POINTER (TRUE));
2021         g_hash_table_insert (key_table, (char *) "cpblk", GINT_TO_POINTER (TRUE));
2022         g_hash_table_insert (key_table, (char *) "cpobj", GINT_TO_POINTER (TRUE));
2023         g_hash_table_insert (key_table, (char *) "currency", GINT_TO_POINTER (TRUE));
2024         g_hash_table_insert (key_table, (char *) "custom", GINT_TO_POINTER (TRUE));
2025         g_hash_table_insert (key_table, (char *) "date", GINT_TO_POINTER (TRUE));
2026         g_hash_table_insert (key_table, (char *) "decimal", GINT_TO_POINTER (TRUE));
2027         g_hash_table_insert (key_table, (char *) "default", GINT_TO_POINTER (TRUE));
2028         g_hash_table_insert (key_table, (char *) "default", GINT_TO_POINTER (TRUE));
2029         g_hash_table_insert (key_table, (char *) "demand", GINT_TO_POINTER (TRUE));
2030         g_hash_table_insert (key_table, (char *) "deny", GINT_TO_POINTER (TRUE));
2031         g_hash_table_insert (key_table, (char *) "div", GINT_TO_POINTER (TRUE));
2032         g_hash_table_insert (key_table, (char *) "div.un", GINT_TO_POINTER (TRUE));
2033         g_hash_table_insert (key_table, (char *) "dup", GINT_TO_POINTER (TRUE));
2034         g_hash_table_insert (key_table, (char *) "endfault", GINT_TO_POINTER (TRUE));
2035         g_hash_table_insert (key_table, (char *) "endfilter", GINT_TO_POINTER (TRUE));
2036         g_hash_table_insert (key_table, (char *) "endfinally", GINT_TO_POINTER (TRUE));
2037         g_hash_table_insert (key_table, (char *) "endmac", GINT_TO_POINTER (TRUE));
2038         g_hash_table_insert (key_table, (char *) "enum", GINT_TO_POINTER (TRUE));
2039         g_hash_table_insert (key_table, (char *) "error", GINT_TO_POINTER (TRUE));
2040         g_hash_table_insert (key_table, (char *) "explicit", GINT_TO_POINTER (TRUE));
2041         g_hash_table_insert (key_table, (char *) "extends", GINT_TO_POINTER (TRUE));
2042         g_hash_table_insert (key_table, (char *) "extern", GINT_TO_POINTER (TRUE));
2043         g_hash_table_insert (key_table, (char *) "false", GINT_TO_POINTER (TRUE));
2044         g_hash_table_insert (key_table, (char *) "famandassem", GINT_TO_POINTER (TRUE));
2045         g_hash_table_insert (key_table, (char *) "family", GINT_TO_POINTER (TRUE));
2046         g_hash_table_insert (key_table, (char *) "famorassem", GINT_TO_POINTER (TRUE));
2047         g_hash_table_insert (key_table, (char *) "fastcall", GINT_TO_POINTER (TRUE));
2048         g_hash_table_insert (key_table, (char *) "fastcall", GINT_TO_POINTER (TRUE));
2049         g_hash_table_insert (key_table, (char *) "fault", GINT_TO_POINTER (TRUE));
2050         g_hash_table_insert (key_table, (char *) "field", GINT_TO_POINTER (TRUE));
2051         g_hash_table_insert (key_table, (char *) "filetime", GINT_TO_POINTER (TRUE));
2052         g_hash_table_insert (key_table, (char *) "filter", GINT_TO_POINTER (TRUE));
2053         g_hash_table_insert (key_table, (char *) "final", GINT_TO_POINTER (TRUE));
2054         g_hash_table_insert (key_table, (char *) "finally", GINT_TO_POINTER (TRUE));
2055         g_hash_table_insert (key_table, (char *) "fixed", GINT_TO_POINTER (TRUE));
2056         g_hash_table_insert (key_table, (char *) "float", GINT_TO_POINTER (TRUE));
2057         g_hash_table_insert (key_table, (char *) "float32", GINT_TO_POINTER (TRUE));
2058         g_hash_table_insert (key_table, (char *) "float64", GINT_TO_POINTER (TRUE));
2059         g_hash_table_insert (key_table, (char *) "forwardref", GINT_TO_POINTER (TRUE));
2060         g_hash_table_insert (key_table, (char *) "fromunmanaged", GINT_TO_POINTER (TRUE));
2061         g_hash_table_insert (key_table, (char *) "handler", GINT_TO_POINTER (TRUE));
2062         g_hash_table_insert (key_table, (char *) "hidebysig", GINT_TO_POINTER (TRUE));
2063         g_hash_table_insert (key_table, (char *) "hresult", GINT_TO_POINTER (TRUE));
2064         g_hash_table_insert (key_table, (char *) "idispatch", GINT_TO_POINTER (TRUE));
2065         g_hash_table_insert (key_table, (char *) "il", GINT_TO_POINTER (TRUE));
2066         g_hash_table_insert (key_table, (char *) "illegal", GINT_TO_POINTER (TRUE));
2067         g_hash_table_insert (key_table, (char *) "implements", GINT_TO_POINTER (TRUE));
2068         g_hash_table_insert (key_table, (char *) "implicitcom", GINT_TO_POINTER (TRUE));
2069         g_hash_table_insert (key_table, (char *) "implicitres", GINT_TO_POINTER (TRUE));
2070         g_hash_table_insert (key_table, (char *) "import", GINT_TO_POINTER (TRUE));
2071         g_hash_table_insert (key_table, (char *) "in", GINT_TO_POINTER (TRUE));
2072         g_hash_table_insert (key_table, (char *) "inheritcheck", GINT_TO_POINTER (TRUE));
2073         g_hash_table_insert (key_table, (char *) "init", GINT_TO_POINTER (TRUE));
2074         g_hash_table_insert (key_table, (char *) "initblk", GINT_TO_POINTER (TRUE));
2075         g_hash_table_insert (key_table, (char *) "initobj", GINT_TO_POINTER (TRUE));
2076         g_hash_table_insert (key_table, (char *) "initonly", GINT_TO_POINTER (TRUE));
2077         g_hash_table_insert (key_table, (char *) "instance", GINT_TO_POINTER (TRUE));
2078         g_hash_table_insert (key_table, (char *) "int", GINT_TO_POINTER (TRUE));
2079         g_hash_table_insert (key_table, (char *) "int16", GINT_TO_POINTER (TRUE));
2080         g_hash_table_insert (key_table, (char *) "int32", GINT_TO_POINTER (TRUE));
2081         g_hash_table_insert (key_table, (char *) "int64", GINT_TO_POINTER (TRUE));
2082         g_hash_table_insert (key_table, (char *) "int8", GINT_TO_POINTER (TRUE));
2083         g_hash_table_insert (key_table, (char *) "interface", GINT_TO_POINTER (TRUE));
2084         g_hash_table_insert (key_table, (char *) "internalcall", GINT_TO_POINTER (TRUE));
2085         g_hash_table_insert (key_table, (char *) "isinst", GINT_TO_POINTER (TRUE));
2086         g_hash_table_insert (key_table, (char *) "iunknown", GINT_TO_POINTER (TRUE));
2087         g_hash_table_insert (key_table, (char *) "jmp", GINT_TO_POINTER (TRUE));
2088         g_hash_table_insert (key_table, (char *) "lasterr", GINT_TO_POINTER (TRUE));
2089         g_hash_table_insert (key_table, (char *) "lcid", GINT_TO_POINTER (TRUE));
2090         g_hash_table_insert (key_table, (char *) "ldarg", GINT_TO_POINTER (TRUE));
2091         g_hash_table_insert (key_table, (char *) "ldarg.0", GINT_TO_POINTER (TRUE));
2092         g_hash_table_insert (key_table, (char *) "ldarg.1", GINT_TO_POINTER (TRUE));
2093         g_hash_table_insert (key_table, (char *) "ldarg.2", GINT_TO_POINTER (TRUE));
2094         g_hash_table_insert (key_table, (char *) "ldarg.3", GINT_TO_POINTER (TRUE));
2095         g_hash_table_insert (key_table, (char *) "ldarg.s", GINT_TO_POINTER (TRUE));
2096         g_hash_table_insert (key_table, (char *) "ldarga", GINT_TO_POINTER (TRUE));
2097         g_hash_table_insert (key_table, (char *) "ldarga.s", GINT_TO_POINTER (TRUE));
2098         g_hash_table_insert (key_table, (char *) "ldc.i4", GINT_TO_POINTER (TRUE));
2099         g_hash_table_insert (key_table, (char *) "ldc.i4.0", GINT_TO_POINTER (TRUE));
2100         g_hash_table_insert (key_table, (char *) "ldc.i4.1", GINT_TO_POINTER (TRUE));
2101         g_hash_table_insert (key_table, (char *) "ldc.i4.2", GINT_TO_POINTER (TRUE));
2102         g_hash_table_insert (key_table, (char *) "ldc.i4.3", GINT_TO_POINTER (TRUE));
2103         g_hash_table_insert (key_table, (char *) "ldc.i4.4", GINT_TO_POINTER (TRUE));
2104         g_hash_table_insert (key_table, (char *) "ldc.i4.5", GINT_TO_POINTER (TRUE));
2105         g_hash_table_insert (key_table, (char *) "ldc.i4.6", GINT_TO_POINTER (TRUE));
2106         g_hash_table_insert (key_table, (char *) "ldc.i4.7", GINT_TO_POINTER (TRUE));
2107         g_hash_table_insert (key_table, (char *) "ldc.i4.8", GINT_TO_POINTER (TRUE));
2108         g_hash_table_insert (key_table, (char *) "ldc.i4.M1", GINT_TO_POINTER (TRUE));
2109         g_hash_table_insert (key_table, (char *) "ldc.i4.m1", GINT_TO_POINTER (TRUE));
2110         g_hash_table_insert (key_table, (char *) "ldc.i4.s", GINT_TO_POINTER (TRUE));
2111         g_hash_table_insert (key_table, (char *) "ldc.i8", GINT_TO_POINTER (TRUE));
2112         g_hash_table_insert (key_table, (char *) "ldc.r4", GINT_TO_POINTER (TRUE));
2113         g_hash_table_insert (key_table, (char *) "ldc.r8", GINT_TO_POINTER (TRUE));
2114         g_hash_table_insert (key_table, (char *) "ldelem.i", GINT_TO_POINTER (TRUE));
2115         g_hash_table_insert (key_table, (char *) "ldelem.i1", GINT_TO_POINTER (TRUE));
2116         g_hash_table_insert (key_table, (char *) "ldelem.i2", GINT_TO_POINTER (TRUE));
2117         g_hash_table_insert (key_table, (char *) "ldelem.i4", GINT_TO_POINTER (TRUE));
2118         g_hash_table_insert (key_table, (char *) "ldelem.i8", GINT_TO_POINTER (TRUE));
2119         g_hash_table_insert (key_table, (char *) "ldelem.r4", GINT_TO_POINTER (TRUE));
2120         g_hash_table_insert (key_table, (char *) "ldelem.r8", GINT_TO_POINTER (TRUE));
2121         g_hash_table_insert (key_table, (char *) "ldelem.ref", GINT_TO_POINTER (TRUE));
2122         g_hash_table_insert (key_table, (char *) "ldelem.u1", GINT_TO_POINTER (TRUE));
2123         g_hash_table_insert (key_table, (char *) "ldelem.u2", GINT_TO_POINTER (TRUE));
2124         g_hash_table_insert (key_table, (char *) "ldelem.u4", GINT_TO_POINTER (TRUE));
2125         g_hash_table_insert (key_table, (char *) "ldelem.u8", GINT_TO_POINTER (TRUE));
2126         g_hash_table_insert (key_table, (char *) "ldelema", GINT_TO_POINTER (TRUE));
2127         g_hash_table_insert (key_table, (char *) "ldfld", GINT_TO_POINTER (TRUE));
2128         g_hash_table_insert (key_table, (char *) "ldflda", GINT_TO_POINTER (TRUE));
2129         g_hash_table_insert (key_table, (char *) "ldftn", GINT_TO_POINTER (TRUE));
2130         g_hash_table_insert (key_table, (char *) "ldind.i", GINT_TO_POINTER (TRUE));
2131         g_hash_table_insert (key_table, (char *) "ldind.i1", GINT_TO_POINTER (TRUE));
2132         g_hash_table_insert (key_table, (char *) "ldind.i2", GINT_TO_POINTER (TRUE));
2133         g_hash_table_insert (key_table, (char *) "ldind.i4", GINT_TO_POINTER (TRUE));
2134         g_hash_table_insert (key_table, (char *) "ldind.i8", GINT_TO_POINTER (TRUE));
2135         g_hash_table_insert (key_table, (char *) "ldind.r4", GINT_TO_POINTER (TRUE));
2136         g_hash_table_insert (key_table, (char *) "ldind.r8", GINT_TO_POINTER (TRUE));
2137         g_hash_table_insert (key_table, (char *) "ldind.ref", GINT_TO_POINTER (TRUE));
2138         g_hash_table_insert (key_table, (char *) "ldind.u1", GINT_TO_POINTER (TRUE));
2139         g_hash_table_insert (key_table, (char *) "ldind.u2", GINT_TO_POINTER (TRUE));
2140         g_hash_table_insert (key_table, (char *) "ldind.u4", GINT_TO_POINTER (TRUE));
2141         g_hash_table_insert (key_table, (char *) "ldind.u8", GINT_TO_POINTER (TRUE));
2142         g_hash_table_insert (key_table, (char *) "ldlen", GINT_TO_POINTER (TRUE));
2143         g_hash_table_insert (key_table, (char *) "ldloc", GINT_TO_POINTER (TRUE));
2144         g_hash_table_insert (key_table, (char *) "ldloc.0", GINT_TO_POINTER (TRUE));
2145         g_hash_table_insert (key_table, (char *) "ldloc.1", GINT_TO_POINTER (TRUE));
2146         g_hash_table_insert (key_table, (char *) "ldloc.2", GINT_TO_POINTER (TRUE));
2147         g_hash_table_insert (key_table, (char *) "ldloc.3", GINT_TO_POINTER (TRUE));
2148         g_hash_table_insert (key_table, (char *) "ldloc.s", GINT_TO_POINTER (TRUE));
2149         g_hash_table_insert (key_table, (char *) "ldloca", GINT_TO_POINTER (TRUE));
2150         g_hash_table_insert (key_table, (char *) "ldloca.s", GINT_TO_POINTER (TRUE));
2151         g_hash_table_insert (key_table, (char *) "ldnull", GINT_TO_POINTER (TRUE));
2152         g_hash_table_insert (key_table, (char *) "ldobj", GINT_TO_POINTER (TRUE));
2153         g_hash_table_insert (key_table, (char *) "ldsfld", GINT_TO_POINTER (TRUE));
2154         g_hash_table_insert (key_table, (char *) "ldsflda", GINT_TO_POINTER (TRUE));
2155         g_hash_table_insert (key_table, (char *) "ldstr", GINT_TO_POINTER (TRUE));
2156         g_hash_table_insert (key_table, (char *) "ldtoken", GINT_TO_POINTER (TRUE));
2157         g_hash_table_insert (key_table, (char *) "ldvirtftn", GINT_TO_POINTER (TRUE));
2158         g_hash_table_insert (key_table, (char *) "leave", GINT_TO_POINTER (TRUE));
2159         g_hash_table_insert (key_table, (char *) "leave.s", GINT_TO_POINTER (TRUE));
2160         g_hash_table_insert (key_table, (char *) "linkcheck", GINT_TO_POINTER (TRUE));
2161         g_hash_table_insert (key_table, (char *) "literal", GINT_TO_POINTER (TRUE));
2162         g_hash_table_insert (key_table, (char *) "localloc", GINT_TO_POINTER (TRUE));
2163         g_hash_table_insert (key_table, (char *) "lpstr", GINT_TO_POINTER (TRUE));
2164         g_hash_table_insert (key_table, (char *) "lpstruct", GINT_TO_POINTER (TRUE));
2165         g_hash_table_insert (key_table, (char *) "lptstr", GINT_TO_POINTER (TRUE));
2166         g_hash_table_insert (key_table, (char *) "lpvoid", GINT_TO_POINTER (TRUE));
2167         g_hash_table_insert (key_table, (char *) "lpwstr", GINT_TO_POINTER (TRUE));
2168         g_hash_table_insert (key_table, (char *) "managed", GINT_TO_POINTER (TRUE));
2169         g_hash_table_insert (key_table, (char *) "marshal", GINT_TO_POINTER (TRUE));
2170         g_hash_table_insert (key_table, (char *) "method", GINT_TO_POINTER (TRUE));
2171         g_hash_table_insert (key_table, (char *) "mkrefany", GINT_TO_POINTER (TRUE));
2172         g_hash_table_insert (key_table, (char *) "modopt", GINT_TO_POINTER (TRUE));
2173         g_hash_table_insert (key_table, (char *) "modreq", GINT_TO_POINTER (TRUE));
2174         g_hash_table_insert (key_table, (char *) "mul", GINT_TO_POINTER (TRUE));
2175         g_hash_table_insert (key_table, (char *) "mul.ovf", GINT_TO_POINTER (TRUE));
2176         g_hash_table_insert (key_table, (char *) "mul.ovf.un", GINT_TO_POINTER (TRUE));
2177         g_hash_table_insert (key_table, (char *) "native", GINT_TO_POINTER (TRUE));
2178         g_hash_table_insert (key_table, (char *) "neg", GINT_TO_POINTER (TRUE));
2179         g_hash_table_insert (key_table, (char *) "nested", GINT_TO_POINTER (TRUE));
2180         g_hash_table_insert (key_table, (char *) "newarr", GINT_TO_POINTER (TRUE));
2181         g_hash_table_insert (key_table, (char *) "newobj", GINT_TO_POINTER (TRUE));
2182         g_hash_table_insert (key_table, (char *) "newslot", GINT_TO_POINTER (TRUE));
2183         g_hash_table_insert (key_table, (char *) "noappdomain", GINT_TO_POINTER (TRUE));
2184         g_hash_table_insert (key_table, (char *) "noinlining", GINT_TO_POINTER (TRUE));
2185         g_hash_table_insert (key_table, (char *) "nomachine", GINT_TO_POINTER (TRUE));
2186         g_hash_table_insert (key_table, (char *) "nomangle", GINT_TO_POINTER (TRUE));
2187         g_hash_table_insert (key_table, (char *) "nometadata", GINT_TO_POINTER (TRUE));
2188         g_hash_table_insert (key_table, (char *) "noncasdemand", GINT_TO_POINTER (TRUE));
2189         g_hash_table_insert (key_table, (char *) "noncasinheritance", GINT_TO_POINTER (TRUE));
2190         g_hash_table_insert (key_table, (char *) "noncaslinkdemand", GINT_TO_POINTER (TRUE));
2191         g_hash_table_insert (key_table, (char *) "nop", GINT_TO_POINTER (TRUE));
2192         g_hash_table_insert (key_table, (char *) "noprocess", GINT_TO_POINTER (TRUE));
2193         g_hash_table_insert (key_table, (char *) "not", GINT_TO_POINTER (TRUE));
2194         g_hash_table_insert (key_table, (char *) "not_in_gc_heap", GINT_TO_POINTER (TRUE));
2195         g_hash_table_insert (key_table, (char *) "notremotable", GINT_TO_POINTER (TRUE));
2196         g_hash_table_insert (key_table, (char *) "notserialized", GINT_TO_POINTER (TRUE));
2197         g_hash_table_insert (key_table, (char *) "null", GINT_TO_POINTER (TRUE));
2198         g_hash_table_insert (key_table, (char *) "nullref", GINT_TO_POINTER (TRUE));
2199         g_hash_table_insert (key_table, (char *) "object", GINT_TO_POINTER (TRUE));
2200         g_hash_table_insert (key_table, (char *) "objectref", GINT_TO_POINTER (TRUE));
2201         g_hash_table_insert (key_table, (char *) "opt", GINT_TO_POINTER (TRUE));
2202         g_hash_table_insert (key_table, (char *) "optil", GINT_TO_POINTER (TRUE));
2203         g_hash_table_insert (key_table, (char *) "or", GINT_TO_POINTER (TRUE));
2204         g_hash_table_insert (key_table, (char *) "out", GINT_TO_POINTER (TRUE));
2205         g_hash_table_insert (key_table, (char *) "permitonly", GINT_TO_POINTER (TRUE));
2206         g_hash_table_insert (key_table, (char *) "pinned", GINT_TO_POINTER (TRUE));
2207         g_hash_table_insert (key_table, (char *) "pinvokeimpl", GINT_TO_POINTER (TRUE));
2208         g_hash_table_insert (key_table, (char *) "pop", GINT_TO_POINTER (TRUE));
2209         g_hash_table_insert (key_table, (char *) "prefix1", GINT_TO_POINTER (TRUE));
2210         g_hash_table_insert (key_table, (char *) "prefix2", GINT_TO_POINTER (TRUE));
2211         g_hash_table_insert (key_table, (char *) "prefix3", GINT_TO_POINTER (TRUE));
2212         g_hash_table_insert (key_table, (char *) "prefix4", GINT_TO_POINTER (TRUE));
2213         g_hash_table_insert (key_table, (char *) "prefix5", GINT_TO_POINTER (TRUE));
2214         g_hash_table_insert (key_table, (char *) "prefix6", GINT_TO_POINTER (TRUE));
2215         g_hash_table_insert (key_table, (char *) "prefix7", GINT_TO_POINTER (TRUE));
2216         g_hash_table_insert (key_table, (char *) "prefixref", GINT_TO_POINTER (TRUE));
2217         g_hash_table_insert (key_table, (char *) "prejitdeny", GINT_TO_POINTER (TRUE));
2218         g_hash_table_insert (key_table, (char *) "prejitgrant", GINT_TO_POINTER (TRUE));
2219         g_hash_table_insert (key_table, (char *) "preservesig", GINT_TO_POINTER (TRUE));
2220         g_hash_table_insert (key_table, (char *) "private", GINT_TO_POINTER (TRUE));
2221         g_hash_table_insert (key_table, (char *) "Compilercontrolled", GINT_TO_POINTER (TRUE));
2222         g_hash_table_insert (key_table, (char *) "protected", GINT_TO_POINTER (TRUE));
2223         g_hash_table_insert (key_table, (char *) "public", GINT_TO_POINTER (TRUE));
2224         g_hash_table_insert (key_table, (char *) "readonly", GINT_TO_POINTER (TRUE));
2225         g_hash_table_insert (key_table, (char *) "record", GINT_TO_POINTER (TRUE));
2226         g_hash_table_insert (key_table, (char *) "refany", GINT_TO_POINTER (TRUE));
2227         g_hash_table_insert (key_table, (char *) "refanytype", GINT_TO_POINTER (TRUE));
2228         g_hash_table_insert (key_table, (char *) "refanyval", GINT_TO_POINTER (TRUE));
2229         g_hash_table_insert (key_table, (char *) "rem", GINT_TO_POINTER (TRUE));
2230         g_hash_table_insert (key_table, (char *) "rem.un", GINT_TO_POINTER (TRUE));
2231         g_hash_table_insert (key_table, (char *) "reqmin", GINT_TO_POINTER (TRUE));
2232         g_hash_table_insert (key_table, (char *) "reqopt", GINT_TO_POINTER (TRUE));
2233         g_hash_table_insert (key_table, (char *) "reqrefuse", GINT_TO_POINTER (TRUE));
2234         g_hash_table_insert (key_table, (char *) "reqsecobj", GINT_TO_POINTER (TRUE));
2235         g_hash_table_insert (key_table, (char *) "request", GINT_TO_POINTER (TRUE));
2236         g_hash_table_insert (key_table, (char *) "ret", GINT_TO_POINTER (TRUE));
2237         g_hash_table_insert (key_table, (char *) "rethrow", GINT_TO_POINTER (TRUE));
2238         g_hash_table_insert (key_table, (char *) "retval", GINT_TO_POINTER (TRUE));
2239         g_hash_table_insert (key_table, (char *) "rtspecialname", GINT_TO_POINTER (TRUE));
2240         g_hash_table_insert (key_table, (char *) "runtime", GINT_TO_POINTER (TRUE));
2241         g_hash_table_insert (key_table, (char *) "safearray", GINT_TO_POINTER (TRUE));
2242         g_hash_table_insert (key_table, (char *) "sealed", GINT_TO_POINTER (TRUE));
2243         g_hash_table_insert (key_table, (char *) "sequential", GINT_TO_POINTER (TRUE));
2244         g_hash_table_insert (key_table, (char *) "serializable", GINT_TO_POINTER (TRUE));
2245         g_hash_table_insert (key_table, (char *) "shl", GINT_TO_POINTER (TRUE));
2246         g_hash_table_insert (key_table, (char *) "shr", GINT_TO_POINTER (TRUE));
2247         g_hash_table_insert (key_table, (char *) "shr.un", GINT_TO_POINTER (TRUE));
2248         g_hash_table_insert (key_table, (char *) "sizeof", GINT_TO_POINTER (TRUE));
2249         g_hash_table_insert (key_table, (char *) "special", GINT_TO_POINTER (TRUE));
2250         g_hash_table_insert (key_table, (char *) "specialname", GINT_TO_POINTER (TRUE));
2251         g_hash_table_insert (key_table, (char *) "starg", GINT_TO_POINTER (TRUE));
2252         g_hash_table_insert (key_table, (char *) "starg.s", GINT_TO_POINTER (TRUE));
2253         g_hash_table_insert (key_table, (char *) "static", GINT_TO_POINTER (TRUE));
2254         g_hash_table_insert (key_table, (char *) "stdcall", GINT_TO_POINTER (TRUE));
2255         g_hash_table_insert (key_table, (char *) "stdcall", GINT_TO_POINTER (TRUE));
2256         g_hash_table_insert (key_table, (char *) "stelem.i", GINT_TO_POINTER (TRUE));
2257         g_hash_table_insert (key_table, (char *) "stelem.i1", GINT_TO_POINTER (TRUE));
2258         g_hash_table_insert (key_table, (char *) "stelem.i2", GINT_TO_POINTER (TRUE));
2259         g_hash_table_insert (key_table, (char *) "stelem.i4", GINT_TO_POINTER (TRUE));
2260         g_hash_table_insert (key_table, (char *) "stelem.i8", GINT_TO_POINTER (TRUE));
2261         g_hash_table_insert (key_table, (char *) "stelem.r4", GINT_TO_POINTER (TRUE));
2262         g_hash_table_insert (key_table, (char *) "stelem.r8", GINT_TO_POINTER (TRUE));
2263         g_hash_table_insert (key_table, (char *) "stelem.ref", GINT_TO_POINTER (TRUE));
2264         g_hash_table_insert (key_table, (char *) "stfld", GINT_TO_POINTER (TRUE));
2265         g_hash_table_insert (key_table, (char *) "stind.i", GINT_TO_POINTER (TRUE));
2266         g_hash_table_insert (key_table, (char *) "stind.i1", GINT_TO_POINTER (TRUE));
2267         g_hash_table_insert (key_table, (char *) "stind.i2", GINT_TO_POINTER (TRUE));
2268         g_hash_table_insert (key_table, (char *) "stind.i4", GINT_TO_POINTER (TRUE));
2269         g_hash_table_insert (key_table, (char *) "stind.i8", GINT_TO_POINTER (TRUE));
2270         g_hash_table_insert (key_table, (char *) "stind.r4", GINT_TO_POINTER (TRUE));
2271         g_hash_table_insert (key_table, (char *) "stind.r8", GINT_TO_POINTER (TRUE));
2272 }