+Tue Jul 31 17:45:44 CEST 2001 Paolo Molaro <lupus@ximian.com>
+
+ * class.c, cli.h, loader.c: massive namespace cleanup.
+
2001-07-31 Dietmar Maurer <dietmar@ximian.com>
* cli.h: added pinvoke flags to MonoMethodPInvoke, moved method
MonoType *t = ft->type;
switch (t->type){
- case ELEMENT_TYPE_BOOLEAN:
+ case MONO_TYPE_BOOLEAN:
return sizeof (m_boolean);
- case ELEMENT_TYPE_CHAR:
+ case MONO_TYPE_CHAR:
return sizeof (m_char);
- case ELEMENT_TYPE_I1:
- case ELEMENT_TYPE_U1:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
return 1;
- case ELEMENT_TYPE_I2:
- case ELEMENT_TYPE_U2:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
return 2;
- case ELEMENT_TYPE_I4:
- case ELEMENT_TYPE_U4:
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
+ case MONO_TYPE_R4:
return 4;
- case ELEMENT_TYPE_I8:
- case ELEMENT_TYPE_U8:
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_I8:
+ case MONO_TYPE_U8:
+ case MONO_TYPE_R8:
return 8;
- case ELEMENT_TYPE_I:
+ case MONO_TYPE_I:
return sizeof (m_i);
- case ELEMENT_TYPE_U:
+ case MONO_TYPE_U:
return sizeof (m_u);
- case ELEMENT_TYPE_STRING:
+ case MONO_TYPE_STRING:
return sizeof (m_string);
- case ELEMENT_TYPE_OBJECT:
+ case MONO_TYPE_OBJECT:
return sizeof (m_object);
- case ELEMENT_TYPE_VALUETYPE:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_VALUETYPE");
+ case MONO_TYPE_VALUETYPE:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_VALUETYPE");
- case ELEMENT_TYPE_CLASS:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_CLASS");
+ case MONO_TYPE_CLASS:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_CLASS");
break;
- case ELEMENT_TYPE_SZARRAY:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_SZARRAY");
+ case MONO_TYPE_SZARRAY:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_SZARRAY");
break;
- case ELEMENT_TYPE_PTR:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_PTR");
+ case MONO_TYPE_PTR:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_PTR");
break;
- case ELEMENT_TYPE_FNPTR:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_FNPTR");
+ case MONO_TYPE_FNPTR:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_FNPTR");
break;
- case ELEMENT_TYPE_ARRAY:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_ARRAY");
+ case MONO_TYPE_ARRAY:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_ARRAY");
break;
default:
g_error ("type 0x%02x unknown", t->type);
* a good job at it. This is temporary to get the code for Paolo.
*/
static void
-class_compute_field_layout (metadata_t *m, MonoClass *class)
+class_compute_field_layout (MonoMetadata *m, MonoClass *class)
{
const int top = class->field.count;
guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
- metadata_tableinfo_t *t = &m->tables [META_TABLE_FIELD];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
int i;
/*
static MonoClass *
mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *tt = &m->tables [META_TABLE_TYPEDEF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *tt = &m->tables [MONO_TABLE_TYPEDEF];
MonoClass stack_class;
MonoClass *class = &stack_class;
guint32 cols [6], parent_token;
class->field.last = cols_next [4] - 1;
class->method.last = cols_next [5] - 1;
} else {
- class->field.last = m->tables [META_TABLE_FIELD].rows;
- class->method.last = m->tables [META_TABLE_METHOD].rows;
+ class->field.last = m->tables [MONO_TABLE_FIELD].rows;
+ class->method.last = m->tables [MONO_TABLE_METHOD].rows;
}
- if (cols [4] && cols [4] <= m->tables [META_TABLE_FIELD].rows)
+ if (cols [4] && cols [4] <= m->tables [MONO_TABLE_FIELD].rows)
class->field.count = class->field.last - class->field.first;
else
class->field.count = 0;
- if (cols [5] <= m->tables [META_TABLE_METHOD].rows)
+ if (cols [5] <= m->tables [MONO_TABLE_METHOD].rows)
class->method.count = class->method.last - class->method.first;
else
class->method.count = 0;
{
int idx = mono_metadata_token_index (field_token);
- if (mono_metadata_token_code (field_token) == TOKEN_TYPE_MEMBER_REF)
+ if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF)
g_error ("Unsupported Field Token is a MemberRef, implement me");
- g_assert (mono_metadata_token_code (field_token) == TOKEN_TYPE_FIELD_DEF);
+ g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
return mono_class_get_field_idx (class, idx - 1);
}
typedef_from_typeref (MonoImage *image, guint32 type_token, MonoImage **rimage, guint32 *index)
{
guint32 cols[6];
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *t = &m->tables[META_TABLE_TYPEREF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *t = &m->tables[MONO_TABLE_TYPEREF];
guint32 idx, i;
const char *name, *nspace;
/* load referenced assembly */
image = image->references [idx-1]->image;
m = &image->metadata;
- t = &m->tables [META_TABLE_TYPEDEF];
+ t = &m->tables [MONO_TABLE_TYPEDEF];
/* dumb search for now */
for (i=0; i < t->rows; ++i) {
mono_metadata_decode_row (t, i, cols, 6);
{
MonoClass *class;
- if ((type_token & 0xff000000) == TOKEN_TYPE_TYPE_DEF
+ if ((type_token & 0xff000000) == MONO_TOKEN_TYPE_DEF
&& (class = g_hash_table_lookup (image->class_cache, GUINT_TO_POINTER (type_token))))
return class;
switch (type_token & 0xff000000){
- case TOKEN_TYPE_TYPE_DEF:
+ case MONO_TOKEN_TYPE_DEF:
class = mono_class_create_from_typedef (image, type_token);
break;
- case TOKEN_TYPE_TYPE_REF: {
+ case MONO_TOKEN_TYPE_REF: {
typedef_from_typeref (image, type_token, &image, &type_token);
class = mono_class_create_from_typedef (image, type_token);
break;
}
- case TOKEN_TYPE_TYPE_SPEC:
+ case MONO_TOKEN_TYPE_SPEC:
g_error ("Can not handle class creation of TypeSpecs yet");
default:
typedef struct {
MonoMethod method;
- MonoMetaMethodHeader *header;
+ MonoMethodHeader *header;
} MonoMethodManaged;
typedef struct {
static guint32
typedef_from_name (MonoImage *image, const char *name, const char *nspace, guint32 *mlist)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *t = &m->tables [META_TABLE_TYPEDEF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
guint32 i;
- guint32 cols [META_TYPEDEF_SIZE];
+ guint32 cols [MONO_TYPEDEF_SIZE];
for (i=0; i < t->rows; ++i) {
- mono_metadata_decode_row (t, i, cols, META_TYPEDEF_SIZE);
- if (strcmp (name, mono_metadata_string_heap (m, cols [META_TYPEDEF_NAME])) == 0
- && strcmp (nspace, mono_metadata_string_heap (m, cols [META_TYPEDEF_NAMESPACE])) == 0) {
- *mlist = cols [META_TYPEDEF_METHOD_LIST];
+ mono_metadata_decode_row (t, i, cols, MONO_TYPEDEF_SIZE);
+ if (strcmp (name, mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME])) == 0
+ && strcmp (nspace, mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAMESPACE])) == 0) {
+ *mlist = cols [MONO_TYPEDEF_METHOD_LIST];
return i + 1;
}
}
static void
methoddef_from_memberref (MonoImage *image, guint32 index, MonoImage **rimage, guint32 *rindex)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *tables = m->tables;
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *tables = m->tables;
guint32 cols[6];
guint32 nindex, sig_len, msig_len, class, i;
const char *sig, *msig, *mname, *name, *nspace;
- mono_metadata_decode_row (&tables [META_TABLE_MEMBERREF], index-1, cols, 3);
- nindex = cols [META_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
- class = cols [META_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
+ mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], index-1, cols, 3);
+ nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
+ class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
/*g_print ("methodref: 0x%x 0x%x %s\n", class, nindex,
- mono_metadata_string_heap (m, cols [META_MEMBERREF_NAME]));*/
- sig = mono_metadata_blob_heap (m, cols [META_MEMBERREF_SIGNATURE]);
+ mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));*/
+ sig = mono_metadata_blob_heap (m, cols [MONO_MEMBERREF_SIGNATURE]);
sig_len = mono_metadata_decode_blob_size (sig, &sig);
- mname = mono_metadata_string_heap (m, cols [META_MEMBERREF_NAME]);
+ mname = mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]);
switch (class) {
case MEMBERREF_PARENT_TYPEREF: {
guint32 scopeindex, scopetable;
- mono_metadata_decode_row (&tables [META_TABLE_TYPEREF], nindex-1, cols, META_TYPEREF_SIZE);
- scopeindex = cols [META_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
- scopetable = cols [META_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
+ mono_metadata_decode_row (&tables [MONO_TABLE_TYPEREF], nindex-1, cols, MONO_TYPEREF_SIZE);
+ scopeindex = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
+ scopetable = cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
/*g_print ("typeref: 0x%x 0x%x %s.%s\n", scopetable, scopeindex,
- mono_metadata_string_heap (m, cols [META_TYPEREF_NAMESPACE]),
- mono_metadata_string_heap (m, cols [META_TYPEREF_NAME]));*/
+ mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]),
+ mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]));*/
switch (scopetable) {
case RESOLTION_SCOPE_ASSEMBLYREF:
/*
* *) name and namespace of the class from the TYPEREF table
* *) name and signature of the method from the MEMBERREF table
*/
- nspace = mono_metadata_string_heap (m, cols [META_TYPEREF_NAMESPACE]);
- name = mono_metadata_string_heap (m, cols [META_TYPEREF_NAME]);
+ nspace = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]);
+ name = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]);
image = image->references [scopeindex-1]->image;
m = &image->metadata;
- tables = &m->tables [META_TABLE_METHOD];
+ tables = &m->tables [MONO_TABLE_METHOD];
typedef_from_name (image, name, nspace, &i);
/* mostly dumb search for now */
for (;i < tables->rows; ++i) {
- mono_metadata_decode_row (tables, i, cols, META_METHOD_SIZE);
- msig = mono_metadata_blob_heap (m, cols [META_METHOD_SIGNATURE]);
+ mono_metadata_decode_row (tables, i, cols, MONO_METHOD_SIZE);
+ msig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
msig_len = mono_metadata_decode_blob_size (msig, &msig);
- if (strcmp (mname, mono_metadata_string_heap (m, cols [META_METHOD_NAME])) == 0
+ if (strcmp (mname, mono_metadata_string_heap (m, cols [MONO_METHOD_NAME])) == 0
&& sig_len == msig_len
&& strncmp (sig, msig, sig_len) == 0) {
*rimage = image;
return &ffi_type_void;
switch (type->type) {
- case ELEMENT_TYPE_I1:
+ case MONO_TYPE_I1:
rettype = &ffi_type_sint8;
break;
- case ELEMENT_TYPE_BOOLEAN:
- case ELEMENT_TYPE_U1:
+ case MONO_TYPE_BOOLEAN:
+ case MONO_TYPE_U1:
rettype = &ffi_type_uint8;
break;
- case ELEMENT_TYPE_I2:
+ case MONO_TYPE_I2:
rettype = &ffi_type_sint16;
break;
- case ELEMENT_TYPE_U2:
- case ELEMENT_TYPE_CHAR:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_CHAR:
rettype = &ffi_type_uint16;
break;
- case ELEMENT_TYPE_I4:
+ case MONO_TYPE_I4:
rettype = &ffi_type_sint32;
break;
- case ELEMENT_TYPE_U4:
+ case MONO_TYPE_U4:
rettype = &ffi_type_sint32;
break;
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_R4:
rettype = &ffi_type_float;
break;
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_R8:
rettype = &ffi_type_double;
break;
- case ELEMENT_TYPE_STRING:
+ case MONO_TYPE_STRING:
rettype = &ffi_type_pointer;
break;
default:
fill_pinvoke_info (MonoImage *image, MonoMethodPInvoke *piinfo, int index)
{
MonoMethod *mh = &piinfo->method;
- metadata_tableinfo_t *tables = image->metadata.tables;
- metadata_tableinfo_t *im = &tables [META_TABLE_IMPLMAP];
- metadata_tableinfo_t *mr = &tables [META_TABLE_MODULEREF];
+ MonoTableInfo *tables = image->metadata.tables;
+ MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
+ MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
guint32 im_cols [4];
guint32 mr_cols [1];
const char *import = NULL;
MonoMethod *result;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
- metadata_tableinfo_t *tables = image->metadata.tables;
+ MonoTableInfo *tables = image->metadata.tables;
const char *loc;
const char *sig = NULL;
int size;
guint32 cols[6];
- if (table == META_TABLE_METHOD && (result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
+ if (table == MONO_TABLE_METHOD && (result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
return result;
- if (table != META_TABLE_METHOD) {
- g_assert (table == META_TABLE_MEMBERREF);
+ if (table != MONO_TABLE_METHOD) {
+ g_assert (table == MONO_TABLE_MEMBERREF);
methoddef_from_memberref (image, index, &image, &token);
- return mono_get_method (image, TOKEN_TYPE_METHOD_DEF | token);
+ return mono_get_method (image, MONO_TOKEN_METHOD_DEF | token);
}
fill_pinvoke_info (image, (MonoMethodPInvoke *)result, index);
} else {
/* if this is a methodref from another module/assembly, this fails */
- loc = cli_rva_map ((cli_image_info_t *)image->image_info, cols [0]);
+ loc = mono_cli_rva_map ((MonoCLIImageInfo *)image->image_info, cols [0]);
g_assert (loc);
((MonoMethodManaged *)result)->header =
mono_metadata_parse_mh (&image->metadata, loc);
+Tue Jul 31 17:48:11 CEST 2001 Paolo Molaro <lupus@ximian.com>
+
+ * dis-cil.c, dis-cil.h, dump.c, dump.h, get.c, get.h, main.c, push-pop.h:
+ massive namespace cleanup.
+ * main.c: dis_locals() now just strigifies a MonoMethodHeader.
+
2001-07-31 Dietmar Maurer <dietmar@ximian.com>
* main.c (pinvoke_flags): impl.
indent[indent_level*2] = 0;
void
-dissasemble_cil (metadata_t *m, MonoMetaMethodHeader *mh)
+dissasemble_cil (MonoMetadata *m, MonoMethodHeader *mh)
{
const unsigned char *start = mh->code;
int size = mh->code_size;
-void dissasemble_cil (metadata_t *m, MonoMetaMethodHeader *mh);
+void dissasemble_cil (MonoMetadata *m, MonoMethodHeader *mh);
#include "get.h"
void
-dump_table_assembly (metadata_t *m)
+dump_table_assembly (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_ASSEMBLY];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLY];
guint32 cols [9];
const char *ptr;
int len;
}
void
-dump_table_typeref (metadata_t *m)
+dump_table_typeref (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_TYPEREF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEREF];
int i;
fprintf (output, "Typeref Table\n");
}
void
-dump_table_typedef (metadata_t *m)
+dump_table_typedef (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_TYPEDEF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
int i;
fprintf (output, "Typedef Table\n");
char *s = get_typedef (m, i);
guint32 cols [6];
- mono_metadata_decode_row (&m->tables [META_TABLE_TYPEDEF], i - 1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEDEF], i - 1, cols, CSIZE (cols));
fprintf (output, "%d: %s (flist=%d, mlist=%d)\n", i, s, cols [4], cols [5]);
g_free (s);
}
void
-dump_table_assemblyref (metadata_t *m)
+dump_table_assemblyref (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_ASSEMBLYREF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLYREF];
int i;
fprintf (output, "AssemblyRef Table\n");
}
void
-dump_table_param (metadata_t *m)
+dump_table_param (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_PARAM];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_PARAM];
int i;
fprintf (output, "Param Table\n");
}
void
-dump_table_field (metadata_t *m)
+dump_table_field (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_FIELD];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
int i;
fprintf (output, "Field Table (0..%d)\n", t->rows);
}
void
-dump_table_memberref (metadata_t *m)
+dump_table_memberref (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_MEMBERREF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_MEMBERREF];
int i, kind, idx;
char *ks, *x, *xx;
}
void
-dump_table_class_layout (metadata_t *m)
+dump_table_class_layout (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_CLASSLAYOUT];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_CLASSLAYOUT];
int i;
fprintf (output, "ClassLayout Table (0..%d)\n", t->rows);
}
void
-dump_table_constant (metadata_t *m)
+dump_table_constant (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_CONSTANT];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_CONSTANT];
int i;
fprintf (output, "Constant Table (0..%d)\n", t->rows);
mono_metadata_decode_row (t, i, cols, CSIZE (cols));
fprintf (output, "%d: Parent=0x%08x %s\n",
- i, cols [2], get_constant (m, (ElementTypeEnum) cols [0], cols [3]));
+ i, cols [2], get_constant (m, (MonoTypeEnum) cols [0], cols [3]));
}
}
void
-dump_table_property (metadata_t *m)
+dump_table_property (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_PROPERTY];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_PROPERTY];
int i, j, pcount;
const char *ptr;
char flags[128];
}
void
-dump_table_event (metadata_t *m)
+dump_table_event (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_EVENT];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_EVENT];
int i;
fprintf (output, "Event Table (0..%d)\n", t->rows);
}
void
-dump_table_file (metadata_t *m)
+dump_table_file (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_FILE];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_FILE];
int i;
fprintf (output, "File Table (0..%d)\n", t->rows);
}
void
-dump_table_moduleref (metadata_t *m)
+dump_table_moduleref (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_MODULEREF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_MODULEREF];
int i;
fprintf (output, "ModuleRef Table (0..%d)\n", t->rows);
}
void
-dump_table_method (metadata_t *m)
+dump_table_method (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_METHOD];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_METHOD];
int i;
fprintf (output, "Method Table (0..%d)\n", t->rows);
extern FILE *output;
-void dump_table_assembly (metadata_t *m);
-void dump_table_assemblyref (metadata_t *m);
-void dump_table_class_layout (metadata_t *m);
-void dump_table_constant (metadata_t *m);
-void dump_table_property (metadata_t *m);
-void dump_table_event (metadata_t *m);
-void dump_table_file (metadata_t *m);
-void dump_table_moduleref (metadata_t *m);
-void dump_table_method (metadata_t *m);
-void dump_table_field (metadata_t *m);
-void dump_table_memberref (metadata_t *m);
-void dump_table_param (metadata_t *m);
-void dump_table_typedef (metadata_t *m);
-void dump_table_typeref (metadata_t *m);
+void dump_table_assembly (MonoMetadata *m);
+void dump_table_assemblyref (MonoMetadata *m);
+void dump_table_class_layout (MonoMetadata *m);
+void dump_table_constant (MonoMetadata *m);
+void dump_table_property (MonoMetadata *m);
+void dump_table_event (MonoMetadata *m);
+void dump_table_file (MonoMetadata *m);
+void dump_table_moduleref (MonoMetadata *m);
+void dump_table_method (MonoMetadata *m);
+void dump_table_field (MonoMetadata *m);
+void dump_table_memberref (MonoMetadata *m);
+void dump_table_param (MonoMetadata *m);
+void dump_table_typedef (MonoMetadata *m);
+void dump_table_typeref (MonoMetadata *m);
#include "get.h"
char *
-get_typedef (metadata_t *m, int idx)
+get_typedef (MonoMetadata *m, int idx)
{
guint32 cols [6];
- mono_metadata_decode_row (&m->tables [META_TABLE_TYPEDEF], idx - 1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEDEF], idx - 1, cols, CSIZE (cols));
return g_strdup_printf (
"%s.%s",
}
char *
-get_module (metadata_t *m, int idx)
+get_module (MonoMetadata *m, int idx)
{
guint32 cols [5];
*/
g_assert (idx == 1);
- mono_metadata_decode_row (&m->tables [META_TABLE_MODULEREF], idx - 1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_MODULEREF], idx - 1, cols, CSIZE (cols));
return g_strdup (mono_metadata_string_heap (m, cols [6]));
}
char *
-get_assemblyref (metadata_t *m, int idx)
+get_assemblyref (MonoMetadata *m, int idx)
{
guint32 cols [9];
- mono_metadata_decode_row (&m->tables [META_TABLE_ASSEMBLYREF], idx - 1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_ASSEMBLYREF], idx - 1, cols, CSIZE (cols));
return g_strdup (mono_metadata_string_heap (m, cols [6]));
}
* Returns a string representing the ArrayShape (22.2.16).
*/
static const char *
-get_array_shape (metadata_t *m, const char *ptr, char **result)
+get_array_shape (MonoMetadata *m, const char *ptr, char **result)
{
GString *res = g_string_new ("[");
guint32 rank, num_sizes, num_lo_bounds;
* Returns the stringified representation of a TypeSpec signature (22.2.17)
*/
char *
-get_typespec (metadata_t *m, guint32 idx)
+get_typespec (MonoMetadata *m, guint32 idx)
{
guint32 cols [1];
const char *ptr;
GString *res = g_string_new ("");
int len;
- mono_metadata_decode_row (&m->tables [META_TABLE_TYPESPEC], idx-1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPESPEC], idx-1, cols, CSIZE (cols));
ptr = mono_metadata_blob_heap (m, cols [0]);
len = mono_metadata_decode_value (ptr, &ptr);
switch (*ptr++){
- case ELEMENT_TYPE_PTR:
+ case MONO_TYPE_PTR:
ptr = get_custom_mod (m, ptr, &s);
if (s){
g_string_append (res, s);
g_free (s);
}
- if (*ptr == ELEMENT_TYPE_VOID)
+ if (*ptr == MONO_TYPE_VOID)
g_string_append (res, "void");
else {
ptr = get_type (m, ptr, &s);
}
break;
- case ELEMENT_TYPE_FNPTR:
+ case MONO_TYPE_FNPTR:
g_string_append (res, "FNPTR ");
/*
* we assume MethodRefSig, as we do not know
hex_dump (ptr, 0, 40);
break;
- case ELEMENT_TYPE_ARRAY:
+ case MONO_TYPE_ARRAY:
ptr = get_type (m, ptr, &s);
g_string_append (res, s);
g_free (s);
g_free (s);
break;
- case ELEMENT_TYPE_SZARRAY:
+ case MONO_TYPE_SZARRAY:
ptr = get_custom_mod (m, ptr, &s);
if (s){
g_string_append (res, s);
}
char *
-get_typeref (metadata_t *m, int idx)
+get_typeref (MonoMetadata *m, int idx)
{
guint32 cols [3];
const char *s, *t;
char *x, *ret;
guint32 rs_idx, table;
- mono_metadata_decode_row (&m->tables [META_TABLE_TYPEREF], idx - 1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEREF], idx - 1, cols, CSIZE (cols));
t = mono_metadata_string_heap (m, cols [1]);
s = mono_metadata_string_heap (m, cols [2]);
* at (dor_token >> 2)
*/
char *
-get_typedef_or_ref (metadata_t *m, guint32 dor_token)
+get_typedef_or_ref (MonoMetadata *m, guint32 dor_token)
{
char *temp = NULL, *s;
int table, idx;
* Returns: the new ptr to continue decoding
*/
const char *
-get_encoded_typedef_or_ref (metadata_t *m, const char *ptr, char **result)
+get_encoded_typedef_or_ref (MonoMetadata *m, const char *ptr, char **result)
{
guint32 token;
* Returns: updated pointer location
*/
const char *
-get_custom_mod (metadata_t *m, const char *ptr, char **return_value)
+get_custom_mod (MonoMetadata *m, const char *ptr, char **return_value)
{
char *s;
- if ((*ptr == ELEMENT_TYPE_CMOD_OPT) ||
- (*ptr == ELEMENT_TYPE_CMOD_REQD)){
+ if ((*ptr == MONO_TYPE_CMOD_OPT) ||
+ (*ptr == MONO_TYPE_CMOD_REQD)){
ptr++;
ptr = get_encoded_typedef_or_ref (m, ptr, &s);
static map_t element_type_map [] = {
- { ELEMENT_TYPE_END , "end" },
- { ELEMENT_TYPE_VOID , "void" },
- { ELEMENT_TYPE_BOOLEAN , "bool" },
- { ELEMENT_TYPE_CHAR , "char" },
- { ELEMENT_TYPE_I1 , "sbyte" },
- { ELEMENT_TYPE_U1 , "byte" },
- { ELEMENT_TYPE_I2 , "int16" },
- { ELEMENT_TYPE_U2 , "uint16" },
- { ELEMENT_TYPE_I4 , "int32" },
- { ELEMENT_TYPE_U4 , "uint32" },
- { ELEMENT_TYPE_I8 , "int64" },
- { ELEMENT_TYPE_U8 , "uint64" },
- { ELEMENT_TYPE_R4 , "float32" },
- { ELEMENT_TYPE_R8 , "float64" },
- { ELEMENT_TYPE_STRING , "string" },
- { ELEMENT_TYPE_TYPEDBYREF , "TypedByRef" },
- { ELEMENT_TYPE_I , "native int" },
- { ELEMENT_TYPE_U , "native unsigned int" },
- { ELEMENT_TYPE_OBJECT , "object" },
+ { MONO_TYPE_END , "end" },
+ { MONO_TYPE_VOID , "void" },
+ { MONO_TYPE_BOOLEAN , "bool" },
+ { MONO_TYPE_CHAR , "char" },
+ { MONO_TYPE_I1 , "sbyte" },
+ { MONO_TYPE_U1 , "byte" },
+ { MONO_TYPE_I2 , "int16" },
+ { MONO_TYPE_U2 , "uint16" },
+ { MONO_TYPE_I4 , "int32" },
+ { MONO_TYPE_U4 , "uint32" },
+ { MONO_TYPE_I8 , "int64" },
+ { MONO_TYPE_U8 , "uint64" },
+ { MONO_TYPE_R4 , "float32" },
+ { MONO_TYPE_R8 , "float64" },
+ { MONO_TYPE_STRING , "string" },
+ { MONO_TYPE_TYPEDBYREF , "TypedByRef" },
+ { MONO_TYPE_I , "native int" },
+ { MONO_TYPE_U , "native unsigned int" },
+ { MONO_TYPE_OBJECT , "object" },
{ 0, NULL }
};
};
char*
-dis_stringify_token (metadata_t *m, guint32 token)
+dis_stringify_token (MonoMetadata *m, guint32 token)
{
guint idx = token & 0xffffff;
switch (token >> 24) {
- case META_TABLE_TYPEDEF: return get_typedef (m, idx);
- case META_TABLE_TYPEREF: return get_typeref (m, idx);
- case META_TABLE_TYPESPEC: return get_typespec (m, idx);
+ case MONO_TABLE_TYPEDEF: return get_typedef (m, idx);
+ case MONO_TABLE_TYPEREF: return get_typeref (m, idx);
+ case MONO_TABLE_TYPESPEC: return get_typespec (m, idx);
default:
break;
}
}
char*
-dis_stringify_array (metadata_t *m, MonoArray *array)
+dis_stringify_array (MonoMetadata *m, MonoArray *array)
{
char *type;
GString *s = g_string_new("");
}
char*
-dis_stringify_modifiers (metadata_t *m, int n, MonoCustomMod *mod)
+dis_stringify_modifiers (MonoMetadata *m, int n, MonoCustomMod *mod)
{
GString *s = g_string_new("");
char *result;
int i;
for (i = 0; i < n; ++i) {
char *tok = dis_stringify_token (m, mod[i].token);
- g_string_sprintfa (s, "%s %s", mod[i].mod == ELEMENT_TYPE_CMOD_OPT ? "opt": "reqd", tok);
+ g_string_sprintfa (s, "%s %s", mod[i].mod == MONO_TYPE_CMOD_OPT ? "opt": "reqd", tok);
g_free (tok);
}
g_string_append_c (s, ' ');
}
char*
-dis_stringify_param (metadata_t *m, MonoParam *param)
+dis_stringify_param (MonoMetadata *m, MonoParam *param)
{
char *mods = NULL;
char *t;
}
char*
-dis_stringify_method_signature (metadata_t *m, MonoMethodSignature *method)
+dis_stringify_method_signature (MonoMetadata *m, MonoMethodSignature *method)
{
return g_strdup ("method-signature");
}
char*
-dis_stringify_type (metadata_t *m, MonoType *type)
+dis_stringify_type (MonoMetadata *m, MonoType *type)
{
char *bare = NULL;
char *byref;
byref = type->byref ? "ref " : "";
switch (type->type){
- case ELEMENT_TYPE_BOOLEAN:
- case ELEMENT_TYPE_CHAR:
- case ELEMENT_TYPE_I1:
- case ELEMENT_TYPE_U1:
- case ELEMENT_TYPE_I2:
- case ELEMENT_TYPE_U2:
- case ELEMENT_TYPE_I4:
- case ELEMENT_TYPE_U4:
- case ELEMENT_TYPE_I8:
- case ELEMENT_TYPE_U8:
- case ELEMENT_TYPE_R4:
- case ELEMENT_TYPE_R8:
- case ELEMENT_TYPE_I:
- case ELEMENT_TYPE_U:
- case ELEMENT_TYPE_STRING:
- case ELEMENT_TYPE_OBJECT:
- case ELEMENT_TYPE_TYPEDBYREF:
+ case MONO_TYPE_BOOLEAN:
+ case MONO_TYPE_CHAR:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
+ case MONO_TYPE_I8:
+ case MONO_TYPE_U8:
+ case MONO_TYPE_R4:
+ case MONO_TYPE_R8:
+ case MONO_TYPE_I:
+ case MONO_TYPE_U:
+ case MONO_TYPE_STRING:
+ case MONO_TYPE_OBJECT:
+ case MONO_TYPE_TYPEDBYREF:
bare = g_strdup (map (type->type, element_type_map));
break;
- case ELEMENT_TYPE_VALUETYPE:
- case ELEMENT_TYPE_CLASS:
+ case MONO_TYPE_VALUETYPE:
+ case MONO_TYPE_CLASS:
bare = dis_stringify_token (m, type->data.token);
break;
- case ELEMENT_TYPE_FNPTR:
+ case MONO_TYPE_FNPTR:
bare = dis_stringify_method_signature (m, type->data.method);
break;
- case ELEMENT_TYPE_PTR:
- case ELEMENT_TYPE_SZARRAY: {
+ case MONO_TYPE_PTR:
+ case MONO_TYPE_SZARRAY: {
char *child_type;
char *mods;
if (type->custom_mod) {
child_type = dis_stringify_type (m, type->data.type);
}
- bare = g_strdup_printf (type->type == ELEMENT_TYPE_PTR ? "%s%s*" : "%s%s[]", mods, child_type);
+ bare = g_strdup_printf (type->type == MONO_TYPE_PTR ? "%s%s*" : "%s%s[]", mods, child_type);
g_free (child_type);
g_free (mods);
break;
}
- case ELEMENT_TYPE_ARRAY:
+ case MONO_TYPE_ARRAY:
bare = dis_stringify_array (m, type->data.array);
break;
default:
* Returns: the new ptr to continue decoding
*/
const char *
-get_type (metadata_t *m, const char *ptr, char **result)
+get_type (MonoMetadata *m, const char *ptr, char **result)
{
MonoType *type = mono_metadata_parse_type (m, ptr, &ptr);
*result = dis_stringify_type (m, type);
* Returns a stringified representation of a FieldSig (22.2.4)
*/
char *
-get_field_signature (metadata_t *m, guint32 blob_signature)
+get_field_signature (MonoMetadata *m, guint32 blob_signature)
{
char *allocated_modifier_string, *allocated_type_string;
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
return res;
}
-ElementTypeEnum
-get_field_literal_type (metadata_t *m, guint32 blob_signature)
+MonoTypeEnum
+get_field_literal_type (MonoMetadata *m, guint32 blob_signature)
{
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
int len;
if (allocated_modifier_string)
g_free (allocated_modifier_string);
- return (ElementTypeEnum) *ptr;
+ return (MonoTypeEnum) *ptr;
}
* decodes the literal indexed by @token.
*/
char *
-decode_literal (metadata_t *m, guint32 token)
+decode_literal (MonoMetadata *m, guint32 token)
{
return g_strdup ("LITERAL_VALUE");
}
* Returns: the new ptr to continue decoding.
*/
const char *
-get_ret_type (metadata_t *m, const char *ptr, char **ret_type)
+get_ret_type (MonoMetadata *m, const char *ptr, char **ret_type)
{
GString *str = g_string_new ("");
char *mod = NULL;
g_free (mod);
}
- if (*ptr == ELEMENT_TYPE_TYPEDBYREF){
+ if (*ptr == MONO_TYPE_TYPEDBYREF){
/* TODO: what does `typedbyref' mean? */
g_string_append (str, "/* FIXME: What does this mean? */ typedbyref ");
ptr++;
- } else if (*ptr == ELEMENT_TYPE_VOID){
+ } else if (*ptr == MONO_TYPE_VOID){
g_string_append (str, "void");
ptr++;
} else {
- if (*ptr == ELEMENT_TYPE_BYREF){
+ if (*ptr == MONO_TYPE_BYREF){
g_string_append (str, "[out] ");
ptr++;
}
* Returns: the new ptr to continue decoding.
*/
const char *
-get_param (metadata_t *m, const char *ptr, char **retval)
+get_param (MonoMetadata *m, const char *ptr, char **retval)
{
GString *str = g_string_new ("");
char *allocated_mod_string, *allocated_type_string;
g_free (allocated_mod_string);
}
- if (*ptr == ELEMENT_TYPE_TYPEDBYREF){
+ if (*ptr == MONO_TYPE_TYPEDBYREF){
g_string_append (str, "/*FIXME: what does typedbyref mean? */ typedbyref ");
ptr++;
} else {
- if (*ptr == ELEMENT_TYPE_BYREF){
+ if (*ptr == MONO_TYPE_BYREF){
g_string_append (str, "[out] ");
ptr++;
}
* Returns a stringifed representation of a MethodRefSig (22.2.2)
*/
char *
-get_methodref_signature (metadata_t *m, guint32 blob_signature, const char *fancy_name)
+get_methodref_signature (MonoMetadata *m, guint32 blob_signature, const char *fancy_name)
{
GString *res = g_string_new ("");
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
* the TypeDef table and locate the actual "owner" of the field
*/
char *
-get_field (metadata_t *m, guint32 token)
+get_field (MonoMetadata *m, guint32 token)
{
int idx = mono_metadata_token_index (token);
- metadata_tableinfo_t *tdef = &m->tables [META_TABLE_TYPEDEF];
+ MonoTableInfo *tdef = &m->tables [MONO_TABLE_TYPEDEF];
guint32 cols [3];
char *sig, *res, *type;
guint32 type_idx;
* We can get here also with a MenberRef token (for a field
* defined in another module/assembly, just like in get_method ()
*/
- if (mono_metadata_token_code (token) == TOKEN_TYPE_MEMBER_REF) {
+ if (mono_metadata_token_code (token) == MONO_TOKEN_MEMBER_REF) {
return g_strdup_printf ("fieldref-0x%08x", token);
}
- g_assert (mono_metadata_token_code (token) == TOKEN_TYPE_FIELD_DEF);
+ g_assert (mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF);
- mono_metadata_decode_row (&m->tables [META_TABLE_FIELD], idx - 1, cols, CSIZE (cols));
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_FIELD], idx - 1, cols, CSIZE (cols));
sig = get_field_signature (m, cols [2]);
/*
}
static char *
-get_memberref_parent (metadata_t *m, guint32 mrp_token)
+get_memberref_parent (MonoMetadata *m, guint32 mrp_token)
{
/*
* mrp_index is a MemberRefParent coded index
* the TypeDef table and locate the actual "owner" of the field
*/
char *
-get_method (metadata_t *m, guint32 token)
+get_method (MonoMetadata *m, guint32 token)
{
int idx = mono_metadata_token_index (token);
guint32 member_cols [3], method_cols [6];
char *res, *class, *fancy_name, *sig;
switch (mono_metadata_token_code (token)){
- case TOKEN_TYPE_METHOD_DEF:
+ case MONO_TOKEN_METHOD_DEF:
- mono_metadata_decode_row (&m->tables [META_TABLE_METHOD],
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
idx - 1, method_cols, 6);
fancy_name = mono_metadata_string_heap (m, method_cols [3]);
return sig;
- case TOKEN_TYPE_MEMBER_REF: {
+ case MONO_TOKEN_MEMBER_REF: {
- mono_metadata_decode_row (&m->tables [META_TABLE_MEMBERREF],
+ mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
idx - 1, member_cols,
CSIZE (member_cols));
class = get_memberref_parent (m, member_cols [0]);
* constant.
*/
char *
-get_constant (metadata_t *m, ElementTypeEnum t, guint32 blob_index)
+get_constant (MonoMetadata *m, MonoTypeEnum t, guint32 blob_index)
{
const char *ptr = mono_metadata_blob_heap (m, blob_index);
int len;
len = mono_metadata_decode_value (ptr, &ptr);
switch (t){
- case ELEMENT_TYPE_BOOLEAN:
+ case MONO_TYPE_BOOLEAN:
return g_strdup_printf ("%s", *ptr ? "true" : "false");
- case ELEMENT_TYPE_CHAR:
+ case MONO_TYPE_CHAR:
return g_strdup_printf ("%c", *ptr);
- case ELEMENT_TYPE_U1:
+ case MONO_TYPE_U1:
return g_strdup_printf ("0x%02x", (int) (*ptr));
break;
- case ELEMENT_TYPE_I2:
+ case MONO_TYPE_I2:
return g_strdup_printf ("%d", (int) (*(gint16 *) ptr));
- case ELEMENT_TYPE_I4:
+ case MONO_TYPE_I4:
return g_strdup_printf ("%d", *(gint32 *) ptr);
- case ELEMENT_TYPE_I8:
+ case MONO_TYPE_I8:
/*
* FIXME: This is not endian portable, does only
* matter for debugging, but still.
*/
return g_strdup_printf ("0x%08x%08x", *(guint32 *) ptr, *(guint32 *) (ptr + 4));
- case ELEMENT_TYPE_U8:
+ case MONO_TYPE_U8:
return g_strdup_printf ("0x%08x%08x", *(guint32 *) ptr, *(guint32 *) (ptr + 4));
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_R4:
return g_strdup_printf ("%g", (double) (* (float *) ptr));
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_R8:
return g_strdup_printf ("%g", * (double *) ptr);
- case ELEMENT_TYPE_STRING: {
+ case MONO_TYPE_STRING: {
int len, i, j, e;
char *res;
e = len = 0;
return res;
}
- case ELEMENT_TYPE_CLASS:
+ case MONO_TYPE_CLASS:
return g_strdup ("CLASS CONSTANT. MUST BE ZERO");
/*
* These are non CLS compliant:
*/
- case ELEMENT_TYPE_I1:
+ case MONO_TYPE_I1:
return g_strdup_printf ("%d", (int) *ptr);
- case ELEMENT_TYPE_U2:
+ case MONO_TYPE_U2:
return g_strdup_printf ("0x%04x", (unsigned int) (*(guint16 *) ptr));
- case ELEMENT_TYPE_U4:
+ case MONO_TYPE_U4:
return g_strdup_printf ("0x%04x", (unsigned int) (*(guint32 *) ptr));
default:
- g_error ("Unknown ELEMENT_TYPE (%d) on constant at Blob index (0x%08x)\n",
+ g_error ("Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n",
(int) *ptr, blob_index);
return g_strdup_printf ("Unknown");
}
* constant.
*/
char *
-get_token (metadata_t *m, guint32 token)
+get_token (MonoMetadata *m, guint32 token)
{
switch (mono_metadata_token_code (token)){
- case TOKEN_TYPE_FIELD_DEF:
+ case MONO_TOKEN_FIELD_DEF:
return (get_field (m, token));
default:
* get_token_type:
* @m: metadata context
* @token: the token can belong to any of the following tables:
- * TOKEN_TYPE_TYPE_REF, TOKEN_TYPE_TYPE_DEF, TOKEN_TYPE_TYPE_SPEC
+ * MONO_TOKEN_TYPE_REF, MONO_TOKEN_TYPE_DEF, MONO_TOKEN_TYPE_SPEC
*
* Returns: a stringified version of the MethodDef or MethodRef or TypeSpecn
* at (token & 0xffffff)
*/
char *
-get_token_type (metadata_t *m, guint32 token)
+get_token_type (MonoMetadata *m, guint32 token)
{
char *temp = NULL, *s;
int idx;
idx = mono_metadata_token_index (token);
switch (mono_metadata_token_code (token)){
- case TOKEN_TYPE_TYPE_DEF:
+ case MONO_TOKEN_TYPE_DEF:
temp = get_typedef (m, idx);
s = g_strdup_printf ("%s", temp);
break;
- case TOKEN_TYPE_TYPE_REF:
+ case MONO_TOKEN_TYPE_REF:
temp = get_typeref (m, idx);
s = g_strdup_printf ("%s", temp);
break;
- case TOKEN_TYPE_TYPE_SPEC:
+ case MONO_TOKEN_TYPE_SPEC:
s = get_typespec (m, idx);
break;
/*
* These return allocated strings
*/
-char *get_typedef (metadata_t *m, int idx);
-char *get_module (metadata_t *m, int idx);
-char *get_assemblyref (metadata_t *m, int idx);
-char *get_typeref (metadata_t *m, int idx);
-char *get_typedef_or_ref (metadata_t *m, guint32 dor_token);
-char *get_field_signature (metadata_t *m, guint32 blob_signature);
-char *decode_literal (metadata_t *m, guint32 token);
-char *get_field (metadata_t *m, guint32 token);
+char *get_typedef (MonoMetadata *m, int idx);
+char *get_module (MonoMetadata *m, int idx);
+char *get_assemblyref (MonoMetadata *m, int idx);
+char *get_typeref (MonoMetadata *m, int idx);
+char *get_typedef_or_ref (MonoMetadata *m, guint32 dor_token);
+char *get_field_signature (MonoMetadata *m, guint32 blob_signature);
+char *decode_literal (MonoMetadata *m, guint32 token);
+char *get_field (MonoMetadata *m, guint32 token);
char *param_flags (guint32 f);
char *field_flags (guint32 f);
-char *get_methodref_signature (metadata_t *m, guint32 blob_signature, const char *fancy);
-char *get_constant (metadata_t *m, ElementTypeEnum t, guint32 blob_index);
-char *get_token (metadata_t *m, guint32 token);
-char *get_token_type (metadata_t *m, guint32 token);
-char *get_typespec (metadata_t *m, guint32 blob_idx);
-char *get_method (metadata_t *m, guint32 token);
+char *get_methodref_signature (MonoMetadata *m, guint32 blob_signature, const char *fancy);
+char *get_constant (MonoMetadata *m, MonoTypeEnum t, guint32 blob_index);
+char *get_token (MonoMetadata *m, guint32 token);
+char *get_token_type (MonoMetadata *m, guint32 token);
+char *get_typespec (MonoMetadata *m, guint32 blob_idx);
+char *get_method (MonoMetadata *m, guint32 token);
-char *dis_stringify_type (metadata_t *m, MonoType *type);
-char *dis_stringify_token (metadata_t *m, guint32 token);
-char *dis_stringify_array (metadata_t *m, MonoArray *array);
-char *dis_stringify_modifiers (metadata_t *m, int n, MonoCustomMod *mod);
-char *dis_stringify_param (metadata_t *m, MonoParam *param);
-char *dis_stringify_method_signature (metadata_t *m, MonoMethodSignature *method);
+char *dis_stringify_type (MonoMetadata *m, MonoType *type);
+char *dis_stringify_token (MonoMetadata *m, guint32 token);
+char *dis_stringify_array (MonoMetadata *m, MonoArray *array);
+char *dis_stringify_modifiers (MonoMetadata *m, int n, MonoCustomMod *mod);
+char *dis_stringify_param (MonoMetadata *m, MonoParam *param);
+char *dis_stringify_method_signature (MonoMetadata *m, MonoMethodSignature *method);
/*
* These functions are used during the decoding of streams in the
*
* Results are returning in the pointer argument.
*/
-const char *get_encoded_typedef_or_ref (metadata_t *m, const char *ptr,
+const char *get_encoded_typedef_or_ref (MonoMetadata *m, const char *ptr,
char **result);
const char *get_encoded_value (const char *_ptr,
guint32 *len);
-const char *get_custom_mod (metadata_t *m, const char *ptr,
+const char *get_custom_mod (MonoMetadata *m, const char *ptr,
char **return_value);
-const char *get_type (metadata_t *m, const char *ptr,
+const char *get_type (MonoMetadata *m, const char *ptr,
char **result);
-const char *get_ret_type (metadata_t *m, const char *ptr,
+const char *get_ret_type (MonoMetadata *m, const char *ptr,
char **ret_type);
-const char *get_param (metadata_t *m, const char *ptr,
+const char *get_param (MonoMetadata *m, const char *ptr,
char **retval);
const char *get_blob_encoded_size (const char *ptr, int *size);
-ElementTypeEnum get_field_literal_type (metadata_t *m, guint32 blob_signature);
+MonoTypeEnum get_field_literal_type (MonoMetadata *m, guint32 blob_signature);
+
}
static void
-dis_directive_assembly (metadata_t *m)
+dis_directive_assembly (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_ASSEMBLY];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLY];
guint32 cols [9];
if (t->base == NULL)
}
static void
-dis_directive_assemblyref (metadata_t *m)
+dis_directive_assemblyref (MonoMetadata *m)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_ASSEMBLYREF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_ASSEMBLYREF];
guint32 cols [9];
int i;
* This routine displays all the decoded fields from @start to @end
*/
static void
-dis_field_list (metadata_t *m, guint32 start, guint32 end)
+dis_field_list (MonoMetadata *m, guint32 start, guint32 end)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_FIELD];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
guint32 cols [3];
int i;
flags = field_flags (cols [0]);
if (cols [0] & FIELD_ATTRIBUTE_LITERAL){
- ElementTypeEnum type;
+ MonoTypeEnum type;
char *lit;
type = get_field_literal_type (m, cols [2]);
}
static void
-dis_locals (metadata_t *m, guint32 token)
+dis_locals (MonoMetadata *m, MonoMethodHeader *mh)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_STANDALONESIG];
- const char *ptr;
- guint32 cols[1];
- int len=0, i, bsize;
-
- mono_metadata_decode_row (t, (token&0xffffff)-1, cols, CSIZE(cols));
- ptr = mono_metadata_blob_heap (m, cols[0]);
- bsize = mono_metadata_decode_blob_size (ptr, &ptr);
- if (*ptr != 0x07)
- g_warning("wrong signature for locals blob");
- ptr++;
- len = mono_metadata_decode_value (ptr, &ptr);
- fprintf(output, "\t.locals ( // %d\n", len);
- for (i=0; i < len; ++i) {
- int val;
- char * desc = NULL;
- const char *p = ptr;
- MonoType *type;
- val = mono_metadata_decode_value (ptr, &ptr);
- if (val == ELEMENT_TYPE_PINNED) {
- fprintf(output, "//pinned\n");
- p = ptr;
- val = mono_metadata_decode_value (ptr, &ptr);
- }
- if (val == ELEMENT_TYPE_BYREF) {
- fprintf(output, "// byref\n");
- p = ptr;
- }
- type = mono_metadata_parse_type (m, p, &ptr);
- desc = dis_stringify_type (m, type);
- mono_metadata_free_type (type);
+ int i;
+
+ fprintf(output, "\t.locals %s(\n", mh->init_locals ? "init " : "");
+ for (i=0; i < mh->num_locals; ++i) {
+ char * desc;
+ /* print also byref and pinned attributes */
+ desc = dis_stringify_type (m, mh->locals[i]);
fprintf(output, "\t\t%s\tV_%d\n", desc, i);
g_free(desc);
}
}
static void
-dis_code (metadata_t *m, cli_image_info_t *ii, guint32 rva)
+dis_code (MonoMetadata *m, MonoCLIImageInfo *ii, guint32 rva)
{
- MonoMetaMethodHeader *mh;
- const char *ptr = cli_rva_map (ii, rva);
+ MonoMethodHeader *mh;
+ const char *ptr = mono_cli_rva_map (ii, rva);
char *loc;
if (rva == 0)
fprintf (output, "\t.maxstack %d\n", mh->max_stack);
fprintf (output, "\t// Code size=%d (0x%x)\n", mh->code_size, mh->code_size);
- printf ("\t// Values Code Size=%d/0x%x\n\t// LocalTok=%x\n\n",
- mh->code_size, mh->code_size, mh->local_var_sig_tok);
- if (mh->local_var_sig_tok)
- dis_locals (m, mh->local_var_sig_tok);
+ printf ("\t// Values Code Size=%d/0x%x\n\n",
+ mh->code_size, mh->code_size);
+ if (mh->num_locals)
+ dis_locals (m, mh);
dissasemble_cil (m, mh);
/*
* needs to be deallocated with free_method_signature().
*/
static MethodSignature *
-parse_method_signature (metadata_t *m, guint32 blob_signature)
+parse_method_signature (MonoMetadata *m, guint32 blob_signature)
{
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
MethodSignature *ms = g_new0 (MethodSignature, 1);
static char *
-pinvoke_info (metadata_t *m, guint32 mindex)
+pinvoke_info (MonoMetadata *m, guint32 mindex)
{
- metadata_tableinfo_t *im = &m->tables [META_TABLE_IMPLMAP];
- metadata_tableinfo_t *mr = &m->tables [META_TABLE_MODULEREF];
+ MonoTableInfo *im = &m->tables [MONO_TABLE_IMPLMAP];
+ MonoTableInfo *mr = &m->tables [MONO_TABLE_MODULEREF];
guint32 im_cols [4];
guint32 mr_cols [1];
const char *import, *scope, *flags;
* This routine displays the methods in the Method Table from @start to @end
*/
static void
-dis_method_list (metadata_t *m, cli_image_info_t *ii, guint32 start, guint32 end)
+dis_method_list (MonoMetadata *m, MonoCLIImageInfo *ii, guint32 start, guint32 end)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_METHOD];
- metadata_tableinfo_t *p = &m->tables [META_TABLE_PARAM];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_METHOD];
+ MonoTableInfo *p = &m->tables [MONO_TABLE_PARAM];
guint32 cols [6];
guint32 cols_next [6];
guint32 param_cols [3];
* Disassembles the type whose index in the TypeDef table is @n.
*/
static void
-dis_type (metadata_t *m, cli_image_info_t *ii, int n)
+dis_type (MonoMetadata *m, MonoCLIImageInfo *ii, int n)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_TYPEDEF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
guint32 cols [6];
guint32 cols_next [6];
const char *name;
if (next_is_valid)
last = cols_next [4] - 1;
else
- last = m->tables [META_TABLE_FIELD].rows;
+ last = m->tables [MONO_TABLE_FIELD].rows;
- if (cols[4] && cols[4] <= m->tables [META_TABLE_FIELD].rows)
+ if (cols[4] && cols[4] <= m->tables [MONO_TABLE_FIELD].rows)
dis_field_list (m, cols [4] - 1, last);
fprintf (output, "\n");
if (next_is_valid)
last = cols_next [5] - 1;
else
- last = m->tables [META_TABLE_METHOD].rows;
+ last = m->tables [MONO_TABLE_METHOD].rows;
- if (cols [5] < m->tables [META_TABLE_METHOD].rows)
+ if (cols [5] < m->tables [MONO_TABLE_METHOD].rows)
dis_method_list (m, ii, cols [5]-1, last);
fprintf (output, " }\n}\n\n");
* disassembles all types in the @m context
*/
static void
-dis_types (metadata_t *m, cli_image_info_t *ii)
+dis_types (MonoMetadata *m, MonoCLIImageInfo *ii)
{
- metadata_tableinfo_t *t = &m->tables [META_TABLE_TYPEDEF];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
int i;
for (i = 1; i < t->rows; i++)
struct {
char *name;
int table;
- void (*dumper) (metadata_t *m);
+ void (*dumper) (MonoMetadata *m);
} table_list [] = {
- { "--assembly", META_TABLE_ASSEMBLY, dump_table_assembly },
- { "--assemblyref", META_TABLE_ASSEMBLYREF, dump_table_assemblyref },
- { "--fields", META_TABLE_FIELD, dump_table_field },
- { "--memberref", META_TABLE_MEMBERREF, dump_table_memberref },
- { "--param", META_TABLE_PARAM, dump_table_param },
- { "--typedef", META_TABLE_TYPEDEF, dump_table_typedef },
- { "--typeref", META_TABLE_TYPEREF, dump_table_typeref },
- { "--classlayout", META_TABLE_CLASSLAYOUT, dump_table_class_layout },
- { "--constant", META_TABLE_CONSTANT, dump_table_constant },
- { "--property", META_TABLE_PROPERTY, dump_table_property },
- { "--event", META_TABLE_EVENT, dump_table_event },
- { "--file", META_TABLE_FILE, dump_table_file },
- { "--moduleref", META_TABLE_MODULEREF, dump_table_moduleref },
- { "--method", META_TABLE_METHOD, dump_table_method },
+ { "--assembly", MONO_TABLE_ASSEMBLY, dump_table_assembly },
+ { "--assemblyref", MONO_TABLE_ASSEMBLYREF, dump_table_assemblyref },
+ { "--fields", MONO_TABLE_FIELD, dump_table_field },
+ { "--memberref", MONO_TABLE_MEMBERREF, dump_table_memberref },
+ { "--param", MONO_TABLE_PARAM, dump_table_param },
+ { "--typedef", MONO_TABLE_TYPEDEF, dump_table_typedef },
+ { "--typeref", MONO_TABLE_TYPEREF, dump_table_typeref },
+ { "--classlayout", MONO_TABLE_CLASSLAYOUT, dump_table_class_layout },
+ { "--constant", MONO_TABLE_CONSTANT, dump_table_constant },
+ { "--property", MONO_TABLE_PROPERTY, dump_table_property },
+ { "--event", MONO_TABLE_EVENT, dump_table_event },
+ { "--file", MONO_TABLE_FILE, dump_table_file },
+ { "--moduleref", MONO_TABLE_MODULEREF, dump_table_moduleref },
+ { "--method", MONO_TABLE_METHOD, dump_table_method },
{ NULL, -1 }
};
{
enum MonoImageOpenStatus status;
MonoImage *img;
- cli_image_info_t *ii;
- metadata_t *m;
+ MonoCLIImageInfo *ii;
+ MonoMetadata *m;
fprintf (output, "// Disassembling %s\n", file);
};
void
-dissasemble_cil (metadata_t *m, const unsigned char *start, int size)
+dissasemble_cil (MonoMetadata *m, const unsigned char *start, int size)
{
const unsigned char *end = start + size;
const unsigned char *ptr = start;
+Tue Jul 31 17:52:53 CEST 2001 Paolo Molaro <lupus@ximian.com>
+
+ * interp.c: massive namespace cleanup.
+
Mon Jul 30 20:09:58 CEST 2001 Paolo Molaro <lupus@ximian.com>
* interp.c: update to use mono_method->name.
static void
init_class (MonoClass *klass)
{
- guint32 cols [META_METHOD_SIZE];
- metadata_t *m;
- metadata_tableinfo_t *t;
+ guint32 cols [MONO_METHOD_SIZE];
+ MonoMetadata *m;
+ MonoTableInfo *t;
int i;
if (klass->inited)
init_class (klass->parent);
m = &klass->image->metadata;
- t = &m->tables [META_TABLE_METHOD];
+ t = &m->tables [MONO_TABLE_METHOD];
for (i = klass->method.first; i < klass->method.last; ++i) {
- mono_metadata_decode_row (t, i, cols, META_METHOD_SIZE);
+ mono_metadata_decode_row (t, i, cols, MONO_METHOD_SIZE);
- if (strcmp (".cctor", mono_metadata_string_heap (m, cols [META_METHOD_NAME])) == 0) {
- MonoMethod *cctor = mono_get_method (klass->image, TOKEN_TYPE_METHOD_DEF | (i + 1));
+ if (strcmp (".cctor", mono_metadata_string_heap (m, cols [MONO_METHOD_NAME])) == 0) {
+ MonoMethod *cctor = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (i + 1));
ves_exec_method (cctor, NULL);
mono_free_method (cctor);
klass->inited = 1;
static MonoObject *
newobj (MonoImage *image, guint32 token)
{
- metadata_t *m = &image->metadata;
+ MonoMetadata *m = &image->metadata;
MonoObject *result = NULL;
switch (mono_metadata_token_code (token)){
- case TOKEN_TYPE_METHOD_DEF: {
+ case MONO_TOKEN_METHOD_DEF: {
guint32 idx = mono_metadata_typedef_from_method (m, token);
- result = mono_object_new (image, TOKEN_TYPE_TYPE_DEF | idx);
+ result = mono_object_new (image, MONO_TOKEN_TYPE_DEF | idx);
break;
}
- case TOKEN_TYPE_MEMBER_REF: {
- guint32 member_cols [3];
+ case MONO_TOKEN_MEMBER_REF: {
+ guint32 member_cols [MONO_MEMBERREF_SIZE];
guint32 mpr_token, table, idx;
mono_metadata_decode_row (
- &m->tables [META_TABLE_MEMBERREF],
+ &m->tables [MONO_TABLE_MEMBERREF],
mono_metadata_token_index (token) - 1,
member_cols, CSIZE (member_cols));
- mpr_token = member_cols [0];
+ mpr_token = member_cols [MONO_MEMBERREF_CLASS];
table = mpr_token & 7;
idx = mpr_token >> 3;
switch (table){
case 0: /* TypeDef */
- result = mono_object_new (image, TOKEN_TYPE_TYPE_DEF | idx);
+ result = mono_object_new (image, MONO_TOKEN_TYPE_DEF | idx);
break;
case 1: /* TypeRef */
- result = mono_object_new (image, TOKEN_TYPE_TYPE_REF | idx);
+ result = mono_object_new (image, MONO_TOKEN_TYPE_REF | idx);
break;
case 2: /* ModuleRef */
g_error ("Unhandled: ModuleRef");
get_virtual_method (MonoImage *image, guint32 token, stackval *args)
{
switch (mono_metadata_token_table (token)) {
- case META_TABLE_METHOD:
+ case MONO_TABLE_METHOD:
return mono_get_method (image, token);
}
g_error ("got virtual method: 0x%x\n", token);
{
stackval result;
switch (type->type) {
- case ELEMENT_TYPE_I1:
+ case MONO_TYPE_I1:
result.type = VAL_I32;
result.data.i = *(gint8*)(data + offset);
break;
- case ELEMENT_TYPE_U1:
- case ELEMENT_TYPE_BOOLEAN:
+ case MONO_TYPE_U1:
+ case MONO_TYPE_BOOLEAN:
result.type = VAL_I32;
result.data.i = *(guint8*)(data + offset);
break;
- case ELEMENT_TYPE_I2:
+ case MONO_TYPE_I2:
result.type = VAL_I32;
result.data.i = *(gint16*)(data + offset);
break;
- case ELEMENT_TYPE_U2:
- case ELEMENT_TYPE_CHAR:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_CHAR:
result.type = VAL_I32;
result.data.i = *(guint16*)(data + offset);
break;
- case ELEMENT_TYPE_I4:
+ case MONO_TYPE_I4:
result.type = VAL_I32;
result.data.i = *(gint32*)(data + offset);
break;
- case ELEMENT_TYPE_U4:
+ case MONO_TYPE_U4:
result.type = VAL_I32;
result.data.i = *(guint32*)(data + offset);
break;
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_R4:
result.type = VAL_DOUBLE;
result.data.f = *(float*)(data + offset);
break;
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_R8:
result.type = VAL_DOUBLE;
result.data.f = *(double*)(data + offset);
break;
stackval_to_data (MonoType *type, stackval *val, char *data, guint offset)
{
switch (type->type) {
- case ELEMENT_TYPE_I1:
- case ELEMENT_TYPE_U1:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
*(guint8*)(data + offset) = val->data.i;
break;
- case ELEMENT_TYPE_BOOLEAN:
+ case MONO_TYPE_BOOLEAN:
*(guint8*)(data + offset) = (val->data.i != 0);
break;
- case ELEMENT_TYPE_I2:
- case ELEMENT_TYPE_U2:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
*(guint16*)(data + offset) = val->data.i;
break;
- case ELEMENT_TYPE_I4:
- case ELEMENT_TYPE_U4:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
*(gint32*)(data + offset) = val->data.i;
break;
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_R4:
*(float*)(data + offset) = val->data.f;
break;
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_R8:
*(double*)(data + offset) = val->data.f;
break;
default:
switch (mh->signature->params [i]->type->type) {
- case ELEMENT_TYPE_I1:
- case ELEMENT_TYPE_U1:
- case ELEMENT_TYPE_BOOLEAN:
- case ELEMENT_TYPE_I2:
- case ELEMENT_TYPE_U2:
- case ELEMENT_TYPE_CHAR:
- case ELEMENT_TYPE_I4:
- case ELEMENT_TYPE_U4:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
+ case MONO_TYPE_BOOLEAN:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_CHAR:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
values[i] = &sp [i].data.i;
break;
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_R4:
tmp_float [i] = sp [i].data.f;
values[i] = &tmp_float [i];
break;
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_R8:
values[i] = &sp [i].data.f;
break;
- case ELEMENT_TYPE_STRING: /* fixme: this is wrong ? */
+ case MONO_TYPE_STRING: /* fixme: this is wrong ? */
values[i] = &sp [i].data.p;
break;
default:
CASE (CEE_CPOBJ) ves_abort(); BREAK;
CASE (CEE_LDOBJ) ves_abort(); BREAK;
CASE (CEE_LDSTR) {
- metadata_t *m = &mh->image->metadata;
+ MonoMetadata *m = &mh->image->metadata;
const char *name;
guint32 index;
/* need to handle fieldrefs */
klass = mono_class_get (mh->image,
- TOKEN_TYPE_TYPE_DEF | mono_metadata_typedef_from_field (&mh->image->metadata, token & 0xffffff));
+ MONO_TOKEN_TYPE_DEF | mono_metadata_typedef_from_field (&mh->image->metadata, token & 0xffffff));
field = mono_class_get_field (klass, token);
g_assert (field);
*sp = stackval_from_data (field->type->type, (char*)klass, field->offset);
/* need to handle fieldrefs */
klass = mono_class_get (mh->image,
- TOKEN_TYPE_TYPE_DEF | mono_metadata_typedef_from_field (&mh->image->metadata, token & 0xffffff));
+ MONO_TOKEN_TYPE_DEF | mono_metadata_typedef_from_field (&mh->image->metadata, token & 0xffffff));
field = mono_class_get_field (klass, token);
g_assert (field);
stackval_to_data (field->type->type, sp, (char*)klass, field->offset);
ves_exec (MonoAssembly *assembly)
{
MonoImage *image = assembly->image;
- cli_image_info_t *iinfo;
+ MonoCLIImageInfo *iinfo;
stackval result;
MonoMethod *mh;
+Tue Jul 31 17:54:02 CEST 2001 Paolo Molaro <lupus@ximian.com>
+
+ * metadata.h, metadata.c, Makefile.am, private.h, assembly.c, blob.h,
+ cil-coff.h, image.c, image.h, pedump.c, rawbuffer.c, rawbuffer.h, row-indexes.h,
+ tokentype.h: massive namespace cleanup.
+
Mon Jul 30 20:11:01 CEST 2001 Paolo Molaro <lupus@ximian.com>
* metadata.h, metadata.c: decode exception clauses when parsing method header.
assembly.c \
image.c \
metadata.c \
+ private.h \
rawbuffer.c
libmetadataincludedir = $(includedir)/mono/metadata
{
MonoAssembly *ass;
MonoImage *image;
- metadata_tableinfo_t *t;
- metadata_t *m;
+ MonoTableInfo *t;
+ MonoMetadata *m;
int i, j;
const char *basename = strrchr (filename, '/');
static MonoAssembly *corlib;
resolver = default_assembly_name_resolver;
m = &image->metadata;
- t = &m->tables [META_TABLE_ASSEMBLYREF];
+ t = &m->tables [MONO_TABLE_ASSEMBLYREF];
image->references = g_new (MonoAssembly *, t->rows + 1);
for (i = j = 0; i < t->rows; i++){
char *assembly_ref;
const char *name;
- guint32 cols [9];
+ guint32 cols [MONO_ASSEMBLYREF_SIZE];
mono_metadata_decode_row (t, i, cols, CSIZE (cols));
- name = mono_metadata_string_heap (m, cols [6]);
+ name = mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_NAME]);
/*
* Special case until we have a passable corlib:
* Encoding for type signatures used in the Metadata
*/
typedef enum {
- ELEMENT_TYPE_END = 0x00, /* End of List */
- ELEMENT_TYPE_VOID = 0x01,
- ELEMENT_TYPE_BOOLEAN = 0x02,
- ELEMENT_TYPE_CHAR = 0x03,
- ELEMENT_TYPE_I1 = 0x04,
- ELEMENT_TYPE_U1 = 0x05,
- ELEMENT_TYPE_I2 = 0x06,
- ELEMENT_TYPE_U2 = 0x07,
- ELEMENT_TYPE_I4 = 0x08,
- ELEMENT_TYPE_U4 = 0x09,
- ELEMENT_TYPE_I8 = 0x0a,
- ELEMENT_TYPE_U8 = 0x0b,
- ELEMENT_TYPE_R4 = 0x0c,
- ELEMENT_TYPE_R8 = 0x0d,
- ELEMENT_TYPE_STRING = 0x0e,
- ELEMENT_TYPE_PTR = 0x0f, /* arg: <type> token */
- ELEMENT_TYPE_BYREF = 0x10, /* arg: <type> token */
- ELEMENT_TYPE_VALUETYPE = 0x11, /* arg: <type> token */
- ELEMENT_TYPE_CLASS = 0x12, /* arg: <type> token */
- ELEMENT_TYPE_ARRAY = 0x14, /* type, rank, boundsCount, bound1, loCount, lo1 */
- ELEMENT_TYPE_TYPEDBYREF = 0x15,
- ELEMENT_TYPE_I = 0x18,
- ELEMENT_TYPE_U = 0x19,
- ELEMENT_TYPE_FNPTR = 0x1b, /* arg: full method signature */
- ELEMENT_TYPE_OBJECT = 0x1c,
- ELEMENT_TYPE_SZARRAY = 0x1d, /* 0-based one-dim-array */
- ELEMENT_TYPE_CMOD_REQD = 0x1f, /* arg: typedef or typeref token */
- ELEMENT_TYPE_CMOD_OPT = 0x20, /* optional arg: typedef or typref token */
- ELEMENT_TYPE_INTERNAL = 0x21, /* CLR internal type */
+ MONO_TYPE_END = 0x00, /* End of List */
+ MONO_TYPE_VOID = 0x01,
+ MONO_TYPE_BOOLEAN = 0x02,
+ MONO_TYPE_CHAR = 0x03,
+ MONO_TYPE_I1 = 0x04,
+ MONO_TYPE_U1 = 0x05,
+ MONO_TYPE_I2 = 0x06,
+ MONO_TYPE_U2 = 0x07,
+ MONO_TYPE_I4 = 0x08,
+ MONO_TYPE_U4 = 0x09,
+ MONO_TYPE_I8 = 0x0a,
+ MONO_TYPE_U8 = 0x0b,
+ MONO_TYPE_R4 = 0x0c,
+ MONO_TYPE_R8 = 0x0d,
+ MONO_TYPE_STRING = 0x0e,
+ MONO_TYPE_PTR = 0x0f, /* arg: <type> token */
+ MONO_TYPE_BYREF = 0x10, /* arg: <type> token */
+ MONO_TYPE_VALUETYPE = 0x11, /* arg: <type> token */
+ MONO_TYPE_CLASS = 0x12, /* arg: <type> token */
+ MONO_TYPE_ARRAY = 0x14, /* type, rank, boundsCount, bound1, loCount, lo1 */
+ MONO_TYPE_TYPEDBYREF = 0x15,
+ MONO_TYPE_I = 0x18,
+ MONO_TYPE_U = 0x19,
+ MONO_TYPE_FNPTR = 0x1b, /* arg: full method signature */
+ MONO_TYPE_OBJECT = 0x1c,
+ MONO_TYPE_SZARRAY = 0x1d, /* 0-based one-dim-array */
+ MONO_TYPE_CMOD_REQD = 0x1f, /* arg: typedef or typeref token */
+ MONO_TYPE_CMOD_OPT = 0x20, /* optional arg: typedef or typref token */
+ MONO_TYPE_INTERNAL = 0x21, /* CLR internal type */
- ELEMENT_TYPE_MODIFIER = 0x40, /* Or with the following types */
- ELEMENT_TYPE_SENTINEL = 0x41, /* Sentinel for varargs method signature */
- ELEMENT_TYPE_PINNED = 0x45, /* Local var that points to pinned object */
-} ElementTypeEnum;
+ MONO_TYPE_MODIFIER = 0x40, /* Or with the following types */
+ MONO_TYPE_SENTINEL = 0x41, /* Sentinel for varargs method signature */
+ MONO_TYPE_PINNED = 0x45, /* Local var that points to pinned object */
+} MonoTypeEnum;
#endif
#define METHOD_HEADER_SECTION_FAT_FORMAT 0x40
#define METHOD_HEADER_SECTION_MORE_SECTS 0x80
-/* A metadata token */
-typedef guint32 mtoken_t;
-
typedef struct {
char msdos_header [128];
-} msdos_header_t;
+} MonoMSDOSHeader;
typedef struct {
guint16 coff_machine;
guint32 coff_symcount;
guint16 coff_opt_header_size;
guint16 coff_attributes;
-} coff_header_t;
+} MonoCOFFHeader;
#define COFF_ATTRIBUTE_EXECUTABLE_IMAGE 0x0002
#define COFF_ATTRIBUTE_LIBRARY_IMAGE 0x2000
guint32 pe_rva_entry_point;
guint32 pe_rva_code_base;
guint32 pe_rva_data_base;
-} pe_header_t;
+} MonoPEHeader;
typedef struct {
guint32 pe_image_base; /* must be 0x400000 */
guint32 pe_heap_commit;
guint32 pe_loader_flags;
guint32 pe_data_dir_count;
-} pe_header_nt_t;
+} MonoPEHeaderNT;
typedef struct {
guint32 rva;
guint32 size;
-} pe_dir_entry_t;
+} MonoPEDirEntry;
typedef struct {
- pe_dir_entry_t pe_export_table;
- pe_dir_entry_t pe_import_table;
- pe_dir_entry_t pe_resource_table;
- pe_dir_entry_t pe_exception_table;
- pe_dir_entry_t pe_certificate_table;
- pe_dir_entry_t pe_reloc_table;
- pe_dir_entry_t pe_debug;
- pe_dir_entry_t pe_copyright;
- pe_dir_entry_t pe_global_ptr;
- pe_dir_entry_t pe_tls_table;
- pe_dir_entry_t pe_load_config_table;
- pe_dir_entry_t pe_bound_import;
- pe_dir_entry_t pe_iat;
- pe_dir_entry_t pe_delay_import_desc;
- pe_dir_entry_t pe_cli_header;
- pe_dir_entry_t pe_reserved;
-} pe_datadir_t;
+ MonoPEDirEntry pe_export_table;
+ MonoPEDirEntry pe_import_table;
+ MonoPEDirEntry pe_resource_table;
+ MonoPEDirEntry pe_exception_table;
+ MonoPEDirEntry pe_certificate_table;
+ MonoPEDirEntry pe_reloc_table;
+ MonoPEDirEntry pe_debug;
+ MonoPEDirEntry pe_copyright;
+ MonoPEDirEntry pe_global_ptr;
+ MonoPEDirEntry pe_tls_table;
+ MonoPEDirEntry pe_load_config_table;
+ MonoPEDirEntry pe_bound_import;
+ MonoPEDirEntry pe_iat;
+ MonoPEDirEntry pe_delay_import_desc;
+ MonoPEDirEntry pe_cli_header;
+ MonoPEDirEntry pe_reserved;
+} MonoPEDatadir;
typedef struct {
char pesig [4];
- coff_header_t coff;
- pe_header_t pe;
- pe_header_nt_t nt;
- pe_datadir_t datadir;
-} dotnet_header_t;
+ MonoCOFFHeader coff;
+ MonoPEHeader pe;
+ MonoPEHeaderNT nt;
+ MonoPEDatadir datadir;
+} MonoDotNetHeader;
typedef struct {
char st_name [8];
#define SECT_FLAGS_MEM_WRITE 0x80000000
guint32 st_flags;
-} section_table_t;
+} MonoSectionTable;
typedef struct {
guint32 ch_size;
guint16 ch_runtime_major;
guint16 ch_runtime_minor;
- pe_dir_entry_t ch_metadata;
+ MonoPEDirEntry ch_metadata;
#define CLI_FLAGS_ILONLY 0x01
#define CLI_FLAGS_32BITREQUIRED 0x02
#define CLI_FLAGS_TRACKDEBUGDATA 0x00010000
guint32 ch_flags;
- mtoken_t ch_entry_point;
- pe_dir_entry_t ch_resources;
- pe_dir_entry_t ch_strong_name;
- pe_dir_entry_t ch_code_manager_table;
- pe_dir_entry_t ch_vtable_fixups;
- pe_dir_entry_t ch_export_address_table_jumps;
+ guint32 ch_entry_point;
+ MonoPEDirEntry ch_resources;
+ MonoPEDirEntry ch_strong_name;
+ MonoPEDirEntry ch_code_manager_table;
+ MonoPEDirEntry ch_vtable_fixups;
+ MonoPEDirEntry ch_export_address_table_jumps;
/* The following are zero in the current docs */
- pe_dir_entry_t ch_eeinfo_table;
- pe_dir_entry_t ch_helper_table;
- pe_dir_entry_t ch_dynamic_info;
- pe_dir_entry_t ch_delay_load_info;
- pe_dir_entry_t ch_module_image;
- pe_dir_entry_t ch_external_fixups;
- pe_dir_entry_t ch_ridmap;
- pe_dir_entry_t ch_debug_map;
- pe_dir_entry_t ch_ip_map;
-} cli_header_t;
+ MonoPEDirEntry ch_eeinfo_table;
+ MonoPEDirEntry ch_helper_table;
+ MonoPEDirEntry ch_dynamic_info;
+ MonoPEDirEntry ch_delay_load_info;
+ MonoPEDirEntry ch_module_image;
+ MonoPEDirEntry ch_external_fixups;
+ MonoPEDirEntry ch_ridmap;
+ MonoPEDirEntry ch_debug_map;
+ MonoPEDirEntry ch_ip_map;
+} MonoCLIHeader;
/* This is not an on-disk structure */
typedef struct {
- dotnet_header_t cli_header;
+ MonoDotNetHeader cli_header;
int cli_section_count;
- section_table_t *cli_section_tables;
+ MonoSectionTable *cli_section_tables;
void **cli_sections;
- cli_header_t cli_cli_header;
-} cli_image_info_t;
+ MonoCLIHeader cli_cli_header;
+} MonoCLIImageInfo;
-guint32 cli_rva_image_map (cli_image_info_t *iinfo, guint32 rva);
-char *cli_rva_map (cli_image_info_t *iinfo, guint32 rva);
+guint32 mono_cli_rva_image_map (MonoCLIImageInfo *iinfo, guint32 rva);
+char *mono_cli_rva_map (MonoCLIImageInfo *iinfo, guint32 rva);
#endif /* __MONO_CIL_COFF_H__ */
MonoType *t = ft->type;
switch (t->type){
- case ELEMENT_TYPE_BOOLEAN:
+ case MONO_TYPE_BOOLEAN:
return sizeof (m_boolean);
- case ELEMENT_TYPE_CHAR:
+ case MONO_TYPE_CHAR:
return sizeof (m_char);
- case ELEMENT_TYPE_I1:
- case ELEMENT_TYPE_U1:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
return 1;
- case ELEMENT_TYPE_I2:
- case ELEMENT_TYPE_U2:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
return 2;
- case ELEMENT_TYPE_I4:
- case ELEMENT_TYPE_U4:
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
+ case MONO_TYPE_R4:
return 4;
- case ELEMENT_TYPE_I8:
- case ELEMENT_TYPE_U8:
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_I8:
+ case MONO_TYPE_U8:
+ case MONO_TYPE_R8:
return 8;
- case ELEMENT_TYPE_I:
+ case MONO_TYPE_I:
return sizeof (m_i);
- case ELEMENT_TYPE_U:
+ case MONO_TYPE_U:
return sizeof (m_u);
- case ELEMENT_TYPE_STRING:
+ case MONO_TYPE_STRING:
return sizeof (m_string);
- case ELEMENT_TYPE_OBJECT:
+ case MONO_TYPE_OBJECT:
return sizeof (m_object);
- case ELEMENT_TYPE_VALUETYPE:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_VALUETYPE");
+ case MONO_TYPE_VALUETYPE:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_VALUETYPE");
- case ELEMENT_TYPE_CLASS:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_CLASS");
+ case MONO_TYPE_CLASS:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_CLASS");
break;
- case ELEMENT_TYPE_SZARRAY:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_SZARRAY");
+ case MONO_TYPE_SZARRAY:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_SZARRAY");
break;
- case ELEMENT_TYPE_PTR:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_PTR");
+ case MONO_TYPE_PTR:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_PTR");
break;
- case ELEMENT_TYPE_FNPTR:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_FNPTR");
+ case MONO_TYPE_FNPTR:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_FNPTR");
break;
- case ELEMENT_TYPE_ARRAY:
- g_error ("FIXME: Add computation of size for ELEMENT_TYPE_ARRAY");
+ case MONO_TYPE_ARRAY:
+ g_error ("FIXME: Add computation of size for MONO_TYPE_ARRAY");
break;
default:
g_error ("type 0x%02x unknown", t->type);
* a good job at it. This is temporary to get the code for Paolo.
*/
static void
-class_compute_field_layout (metadata_t *m, MonoClass *class)
+class_compute_field_layout (MonoMetadata *m, MonoClass *class)
{
const int top = class->field.count;
guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
- metadata_tableinfo_t *t = &m->tables [META_TABLE_FIELD];
+ MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
int i;
/*
static MonoClass *
mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *tt = &m->tables [META_TABLE_TYPEDEF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *tt = &m->tables [MONO_TABLE_TYPEDEF];
MonoClass stack_class;
MonoClass *class = &stack_class;
guint32 cols [6], parent_token;
class->field.last = cols_next [4] - 1;
class->method.last = cols_next [5] - 1;
} else {
- class->field.last = m->tables [META_TABLE_FIELD].rows;
- class->method.last = m->tables [META_TABLE_METHOD].rows;
+ class->field.last = m->tables [MONO_TABLE_FIELD].rows;
+ class->method.last = m->tables [MONO_TABLE_METHOD].rows;
}
- if (cols [4] && cols [4] <= m->tables [META_TABLE_FIELD].rows)
+ if (cols [4] && cols [4] <= m->tables [MONO_TABLE_FIELD].rows)
class->field.count = class->field.last - class->field.first;
else
class->field.count = 0;
- if (cols [5] <= m->tables [META_TABLE_METHOD].rows)
+ if (cols [5] <= m->tables [MONO_TABLE_METHOD].rows)
class->method.count = class->method.last - class->method.first;
else
class->method.count = 0;
{
int idx = mono_metadata_token_index (field_token);
- if (mono_metadata_token_code (field_token) == TOKEN_TYPE_MEMBER_REF)
+ if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF)
g_error ("Unsupported Field Token is a MemberRef, implement me");
- g_assert (mono_metadata_token_code (field_token) == TOKEN_TYPE_FIELD_DEF);
+ g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
return mono_class_get_field_idx (class, idx - 1);
}
typedef_from_typeref (MonoImage *image, guint32 type_token, MonoImage **rimage, guint32 *index)
{
guint32 cols[6];
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *t = &m->tables[META_TABLE_TYPEREF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *t = &m->tables[MONO_TABLE_TYPEREF];
guint32 idx, i;
const char *name, *nspace;
/* load referenced assembly */
image = image->references [idx-1]->image;
m = &image->metadata;
- t = &m->tables [META_TABLE_TYPEDEF];
+ t = &m->tables [MONO_TABLE_TYPEDEF];
/* dumb search for now */
for (i=0; i < t->rows; ++i) {
mono_metadata_decode_row (t, i, cols, 6);
{
MonoClass *class;
- if ((type_token & 0xff000000) == TOKEN_TYPE_TYPE_DEF
+ if ((type_token & 0xff000000) == MONO_TOKEN_TYPE_DEF
&& (class = g_hash_table_lookup (image->class_cache, GUINT_TO_POINTER (type_token))))
return class;
switch (type_token & 0xff000000){
- case TOKEN_TYPE_TYPE_DEF:
+ case MONO_TOKEN_TYPE_DEF:
class = mono_class_create_from_typedef (image, type_token);
break;
- case TOKEN_TYPE_TYPE_REF: {
+ case MONO_TOKEN_TYPE_REF: {
typedef_from_typeref (image, type_token, &image, &type_token);
class = mono_class_create_from_typedef (image, type_token);
break;
}
- case TOKEN_TYPE_TYPE_SPEC:
+ case MONO_TOKEN_TYPE_SPEC:
g_error ("Can not handle class creation of TypeSpecs yet");
default:
#include "cil-coff.h"
#include "rawbuffer.h"
#include "endian.h"
+#include "private.h"
#define INVALID_ADDRESS 0xffffffff
static GHashTable *loaded_images_hash;
guint32
-cli_rva_image_map (cli_image_info_t *iinfo, guint32 addr)
+mono_cli_rva_image_map (MonoCLIImageInfo *iinfo, guint32 addr)
{
const int top = iinfo->cli_section_count;
- section_table_t *tables = iinfo->cli_section_tables;
+ MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
for (i = 0; i < top; i++){
}
char *
-cli_rva_map (cli_image_info_t *iinfo, guint32 addr)
+mono_cli_rva_map (MonoCLIImageInfo *iinfo, guint32 addr)
{
const int top = iinfo->cli_section_count;
- section_table_t *tables = iinfo->cli_section_tables;
+ MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
for (i = 0; i < top; i++){
int
mono_image_ensure_section_idx (MonoImage *image, int section)
{
- cli_image_info_t *iinfo = image->image_info;
- section_table_t *sect;
+ MonoCLIImageInfo *iinfo = image->image_info;
+ MonoSectionTable *sect;
gboolean writable;
g_return_val_if_fail (section < iinfo->cli_section_count, FALSE);
writable = sect->st_flags & SECT_FLAGS_MEM_WRITE;
- iinfo->cli_sections [section] = raw_buffer_load (
+ iinfo->cli_sections [section] = mono_raw_buffer_load (
fileno (image->f), writable,
sect->st_raw_data_ptr, sect->st_raw_data_size);
int
mono_image_ensure_section (MonoImage *image, const char *section)
{
- cli_image_info_t *ii = image->image_info;
+ MonoCLIImageInfo *ii = image->image_info;
int i;
for (i = 0; i < ii->cli_section_count; i++){
}
static int
-load_section_tables (MonoImage *image, cli_image_info_t *iinfo)
+load_section_tables (MonoImage *image, MonoCLIImageInfo *iinfo)
{
const int top = iinfo->cli_header.coff.coff_sections;
int i;
iinfo->cli_section_count = top;
- iinfo->cli_section_tables = g_new0 (section_table_t, top);
+ iinfo->cli_section_tables = g_new0 (MonoSectionTable, top);
iinfo->cli_sections = g_new0 (void *, top);
for (i = 0; i < top; i++){
- section_table_t *t = &iinfo->cli_section_tables [i];
+ MonoSectionTable *t = &iinfo->cli_section_tables [i];
- if (fread (t, sizeof (section_table_t), 1, image->f) != 1)
+ if (fread (t, sizeof (MonoSectionTable), 1, image->f) != 1)
return FALSE;
t->st_virtual_size = le32_to_cpu (t->st_virtual_size);
}
static gboolean
-load_cli_header (MonoImage *image, cli_image_info_t *iinfo)
+load_cli_header (MonoImage *image, MonoCLIImageInfo *iinfo)
{
guint32 offset;
int n;
- offset = cli_rva_image_map (iinfo, iinfo->cli_header.datadir.pe_cli_header.rva);
+ offset = mono_cli_rva_image_map (iinfo, iinfo->cli_header.datadir.pe_cli_header.rva);
if (offset == INVALID_ADDRESS)
return FALSE;
if (fseek (image->f, offset, 0) != 0)
return FALSE;
- if ((n = fread (&iinfo->cli_cli_header, sizeof (cli_header_t), 1, image->f)) != 1)
+ if ((n = fread (&iinfo->cli_cli_header, sizeof (MonoCLIHeader), 1, image->f)) != 1)
return FALSE;
/* Catch new uses of the fields that are supposed to be zero */
}
static gboolean
-load_metadata_ptrs (MonoImage *image, cli_image_info_t *iinfo)
+load_metadata_ptrs (MonoImage *image, MonoCLIImageInfo *iinfo)
{
- metadata_t *metadata = &image->metadata;
+ MonoMetadata *metadata = &image->metadata;
guint32 offset, size;
guint16 streams;
int i;
char *ptr;
- offset = cli_rva_image_map (iinfo, iinfo->cli_cli_header.ch_metadata.rva);
+ offset = mono_cli_rva_image_map (iinfo, iinfo->cli_cli_header.ch_metadata.rva);
size = iinfo->cli_cli_header.ch_metadata.size;
- metadata->raw_metadata = raw_buffer_load (fileno (image->f), FALSE, offset, size);
+ metadata->raw_metadata = mono_raw_buffer_load (fileno (image->f), FALSE, offset, size);
if (metadata->raw_metadata == NULL)
return FALSE;
for (i = 0; i < streams; i++){
if (strncmp (ptr + 8, "#~", 3) == 0){
- metadata->heap_tables.sh_offset = read32 (ptr);
- metadata->heap_tables.sh_size = read32 (ptr + 4);
+ metadata->heap_tables.offset = read32 (ptr);
+ metadata->heap_tables.size = read32 (ptr + 4);
ptr += 8 + 3;
} else if (strncmp (ptr + 8, "#Strings", 9) == 0){
- metadata->heap_strings.sh_offset = read32 (ptr);
- metadata->heap_strings.sh_size = read32 (ptr + 4);
+ metadata->heap_strings.offset = read32 (ptr);
+ metadata->heap_strings.size = read32 (ptr + 4);
ptr += 8 + 9;
} else if (strncmp (ptr + 8, "#US", 4) == 0){
- metadata->heap_us.sh_offset = read32 (ptr);
- metadata->heap_us.sh_size = read32 (ptr + 4);
+ metadata->heap_us.offset = read32 (ptr);
+ metadata->heap_us.size = read32 (ptr + 4);
ptr += 8 + 4;
} else if (strncmp (ptr + 8, "#Blob", 6) == 0){
- metadata->heap_blob.sh_offset = read32 (ptr);
- metadata->heap_blob.sh_size = read32 (ptr + 4);
+ metadata->heap_blob.offset = read32 (ptr);
+ metadata->heap_blob.size = read32 (ptr + 4);
ptr += 8 + 6;
} else if (strncmp (ptr + 8, "#GUID", 6) == 0){
- metadata->heap_guid.sh_offset = read32 (ptr);
- metadata->heap_guid.sh_size = read32 (ptr + 4);
+ metadata->heap_guid.offset = read32 (ptr);
+ metadata->heap_guid.size = read32 (ptr + 4);
ptr += 8 + 6;
} else
g_message ("Unknown heap type: %s\n", ptr + 8);
* Load representation of logical metadata tables, from the "#~" stream
*/
static gboolean
-load_tables (MonoImage *image, metadata_t *meta)
+load_tables (MonoImage *image, MonoMetadata *meta)
{
- char *heap_tables = meta->raw_metadata + meta->heap_tables.sh_offset;
+ char *heap_tables = meta->raw_metadata + meta->heap_tables.offset;
guint32 *rows;
guint64 valid_mask;
int valid = 0, table;
}
static gboolean
-load_metadata (MonoImage *image, cli_image_info_t *iinfo)
+load_metadata (MonoImage *image, MonoCLIImageInfo *iinfo)
{
if (!load_metadata_ptrs (image, iinfo))
return FALSE;
static MonoImage *
do_mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
{
- cli_image_info_t *iinfo;
- dotnet_header_t *header;
- msdos_header_t msdos;
+ MonoCLIImageInfo *iinfo;
+ MonoDotNetHeader *header;
+ MonoMSDOSHeader msdos;
MonoImage *image;
int n;
image = g_new0 (MonoImage, 1);
image->f = fopen (fname, "r");
image->name = g_strdup (fname);
- iinfo = g_new0 (cli_image_info_t, 1);
+ iinfo = g_new0 (MonoCLIImageInfo, 1);
image->image_info = iinfo;
image->method_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
if (!(msdos.msdos_header [0] == 0x4d && msdos.msdos_header [1] == 0x5a))
goto invalid_image;
- if ((n = fread (header, sizeof (dotnet_header_t), 1, image->f)) != 1)
+ if ((n = fread (header, sizeof (MonoDotNetHeader), 1, image->f)) != 1)
goto invalid_image;
/*
g_free (image->name);
if (image->metadata.raw_metadata != NULL)
- raw_buffer_free (image->metadata.raw_metadata);
+ mono_raw_buffer_free (image->metadata.raw_metadata);
if (image->image_info){
- cli_image_info_t *ii = image->image_info;
+ MonoCLIImageInfo *ii = image->image_info;
int i;
for (i = 0; i < ii->cli_section_count; i++){
if (!ii->cli_sections [i])
continue;
- raw_buffer_free (ii->cli_sections [i]);
+ mono_raw_buffer_free (ii->cli_sections [i]);
}
if (ii->cli_section_tables)
g_free (ii->cli_section_tables);
char *name;
void *image_info;
- metadata_t metadata;
+ MonoMetadata metadata;
/*
* references is initialized only by using the mono_assembly_open
static guint32
typedef_from_name (MonoImage *image, const char *name, const char *nspace, guint32 *mlist)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *t = &m->tables [META_TABLE_TYPEDEF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *t = &m->tables [MONO_TABLE_TYPEDEF];
guint32 i;
- guint32 cols [META_TYPEDEF_SIZE];
+ guint32 cols [MONO_TYPEDEF_SIZE];
for (i=0; i < t->rows; ++i) {
- mono_metadata_decode_row (t, i, cols, META_TYPEDEF_SIZE);
- if (strcmp (name, mono_metadata_string_heap (m, cols [META_TYPEDEF_NAME])) == 0
- && strcmp (nspace, mono_metadata_string_heap (m, cols [META_TYPEDEF_NAMESPACE])) == 0) {
- *mlist = cols [META_TYPEDEF_METHOD_LIST];
+ mono_metadata_decode_row (t, i, cols, MONO_TYPEDEF_SIZE);
+ if (strcmp (name, mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME])) == 0
+ && strcmp (nspace, mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAMESPACE])) == 0) {
+ *mlist = cols [MONO_TYPEDEF_METHOD_LIST];
return i + 1;
}
}
static void
methoddef_from_memberref (MonoImage *image, guint32 index, MonoImage **rimage, guint32 *rindex)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *tables = m->tables;
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *tables = m->tables;
guint32 cols[6];
guint32 nindex, sig_len, msig_len, class, i;
const char *sig, *msig, *mname, *name, *nspace;
- mono_metadata_decode_row (&tables [META_TABLE_MEMBERREF], index-1, cols, 3);
- nindex = cols [META_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
- class = cols [META_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
+ mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], index-1, cols, 3);
+ nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
+ class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
/*g_print ("methodref: 0x%x 0x%x %s\n", class, nindex,
- mono_metadata_string_heap (m, cols [META_MEMBERREF_NAME]));*/
- sig = mono_metadata_blob_heap (m, cols [META_MEMBERREF_SIGNATURE]);
+ mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));*/
+ sig = mono_metadata_blob_heap (m, cols [MONO_MEMBERREF_SIGNATURE]);
sig_len = mono_metadata_decode_blob_size (sig, &sig);
- mname = mono_metadata_string_heap (m, cols [META_MEMBERREF_NAME]);
+ mname = mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]);
switch (class) {
case MEMBERREF_PARENT_TYPEREF: {
guint32 scopeindex, scopetable;
- mono_metadata_decode_row (&tables [META_TABLE_TYPEREF], nindex-1, cols, META_TYPEREF_SIZE);
- scopeindex = cols [META_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
- scopetable = cols [META_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
+ mono_metadata_decode_row (&tables [MONO_TABLE_TYPEREF], nindex-1, cols, MONO_TYPEREF_SIZE);
+ scopeindex = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
+ scopetable = cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
/*g_print ("typeref: 0x%x 0x%x %s.%s\n", scopetable, scopeindex,
- mono_metadata_string_heap (m, cols [META_TYPEREF_NAMESPACE]),
- mono_metadata_string_heap (m, cols [META_TYPEREF_NAME]));*/
+ mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]),
+ mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]));*/
switch (scopetable) {
case RESOLTION_SCOPE_ASSEMBLYREF:
/*
* *) name and namespace of the class from the TYPEREF table
* *) name and signature of the method from the MEMBERREF table
*/
- nspace = mono_metadata_string_heap (m, cols [META_TYPEREF_NAMESPACE]);
- name = mono_metadata_string_heap (m, cols [META_TYPEREF_NAME]);
+ nspace = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]);
+ name = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]);
image = image->references [scopeindex-1]->image;
m = &image->metadata;
- tables = &m->tables [META_TABLE_METHOD];
+ tables = &m->tables [MONO_TABLE_METHOD];
typedef_from_name (image, name, nspace, &i);
/* mostly dumb search for now */
for (;i < tables->rows; ++i) {
- mono_metadata_decode_row (tables, i, cols, META_METHOD_SIZE);
- msig = mono_metadata_blob_heap (m, cols [META_METHOD_SIGNATURE]);
+ mono_metadata_decode_row (tables, i, cols, MONO_METHOD_SIZE);
+ msig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
msig_len = mono_metadata_decode_blob_size (msig, &msig);
- if (strcmp (mname, mono_metadata_string_heap (m, cols [META_METHOD_NAME])) == 0
+ if (strcmp (mname, mono_metadata_string_heap (m, cols [MONO_METHOD_NAME])) == 0
&& sig_len == msig_len
&& strncmp (sig, msig, sig_len) == 0) {
*rimage = image;
return &ffi_type_void;
switch (type->type) {
- case ELEMENT_TYPE_I1:
+ case MONO_TYPE_I1:
rettype = &ffi_type_sint8;
break;
- case ELEMENT_TYPE_BOOLEAN:
- case ELEMENT_TYPE_U1:
+ case MONO_TYPE_BOOLEAN:
+ case MONO_TYPE_U1:
rettype = &ffi_type_uint8;
break;
- case ELEMENT_TYPE_I2:
+ case MONO_TYPE_I2:
rettype = &ffi_type_sint16;
break;
- case ELEMENT_TYPE_U2:
- case ELEMENT_TYPE_CHAR:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_CHAR:
rettype = &ffi_type_uint16;
break;
- case ELEMENT_TYPE_I4:
+ case MONO_TYPE_I4:
rettype = &ffi_type_sint32;
break;
- case ELEMENT_TYPE_U4:
+ case MONO_TYPE_U4:
rettype = &ffi_type_sint32;
break;
- case ELEMENT_TYPE_R4:
+ case MONO_TYPE_R4:
rettype = &ffi_type_float;
break;
- case ELEMENT_TYPE_R8:
+ case MONO_TYPE_R8:
rettype = &ffi_type_double;
break;
- case ELEMENT_TYPE_STRING:
+ case MONO_TYPE_STRING:
rettype = &ffi_type_pointer;
break;
default:
fill_pinvoke_info (MonoImage *image, MonoMethodPInvoke *piinfo, int index)
{
MonoMethod *mh = &piinfo->method;
- metadata_tableinfo_t *tables = image->metadata.tables;
- metadata_tableinfo_t *im = &tables [META_TABLE_IMPLMAP];
- metadata_tableinfo_t *mr = &tables [META_TABLE_MODULEREF];
+ MonoTableInfo *tables = image->metadata.tables;
+ MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
+ MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
guint32 im_cols [4];
guint32 mr_cols [1];
const char *import = NULL;
MonoMethod *result;
int table = mono_metadata_token_table (token);
int index = mono_metadata_token_index (token);
- metadata_tableinfo_t *tables = image->metadata.tables;
+ MonoTableInfo *tables = image->metadata.tables;
const char *loc;
const char *sig = NULL;
int size;
guint32 cols[6];
- if (table == META_TABLE_METHOD && (result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
+ if (table == MONO_TABLE_METHOD && (result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token))))
return result;
- if (table != META_TABLE_METHOD) {
- g_assert (table == META_TABLE_MEMBERREF);
+ if (table != MONO_TABLE_METHOD) {
+ g_assert (table == MONO_TABLE_MEMBERREF);
methoddef_from_memberref (image, index, &image, &token);
- return mono_get_method (image, TOKEN_TYPE_METHOD_DEF | token);
+ return mono_get_method (image, MONO_TOKEN_METHOD_DEF | token);
}
fill_pinvoke_info (image, (MonoMethodPInvoke *)result, index);
} else {
/* if this is a methodref from another module/assembly, this fails */
- loc = cli_rva_map ((cli_image_info_t *)image->image_info, cols [0]);
+ loc = mono_cli_rva_map ((MonoCLIImageInfo *)image->image_info, cols [0]);
g_assert (loc);
((MonoMethodManaged *)result)->header =
mono_metadata_parse_mh (&image->metadata, loc);
#include "endian.h"
#include "cil-coff.h"
#include "tokentype.h"
+#include "private.h"
/*
* Encoding of the "description" argument:
/* Reference: Partition II - 23.2.6 */
static int
-compute_size (metadata_t *meta, MonoMetaTable *table, int tableindex, guint32 *result_bitfield)
+compute_size (MonoMetadata *meta, MonoMetaTable *table, int tableindex, guint32 *result_bitfield)
{
guint32 bitfield = 0;
int size = 0, field_size;
* get the size for this column - lupus
*/
switch (tableindex) {
- case META_TABLE_ASSEMBLYREFOS:
+ case MONO_TABLE_ASSEMBLYREFOS:
g_assert (i == 3);
- field_size = idx_size (META_TABLE_ASSEMBLYREF); break;
- case META_TABLE_ASSEMBLYPROCESSOR:
+ field_size = idx_size (MONO_TABLE_ASSEMBLYREF); break;
+ case MONO_TABLE_ASSEMBLYPROCESSOR:
g_assert (i == 1);
- field_size = idx_size (META_TABLE_ASSEMBLYREF); break;
- case META_TABLE_CLASSLAYOUT:
+ field_size = idx_size (MONO_TABLE_ASSEMBLYREF); break;
+ case MONO_TABLE_CLASSLAYOUT:
g_assert (i == 2);
- field_size = idx_size (META_TABLE_TYPEDEF); break;
- case META_TABLE_EVENTMAP:
+ field_size = idx_size (MONO_TABLE_TYPEDEF); break;
+ case MONO_TABLE_EVENTMAP:
g_assert (i == 0 || i == 1);
- field_size = i ? idx_size (META_TABLE_EVENT):
- idx_size(META_TABLE_TYPEDEF);
+ field_size = i ? idx_size (MONO_TABLE_EVENT):
+ idx_size(MONO_TABLE_TYPEDEF);
break;
- case META_TABLE_EVENT:
+ case MONO_TABLE_EVENT:
g_assert (i == 2);
- field_size = MAX (idx_size (META_TABLE_TYPEDEF), idx_size(META_TABLE_TYPEREF));
- field_size = MAX (field_size, idx_size(META_TABLE_TYPESPEC));
+ field_size = MAX (idx_size (MONO_TABLE_TYPEDEF), idx_size(MONO_TABLE_TYPEREF));
+ field_size = MAX (field_size, idx_size(MONO_TABLE_TYPESPEC));
break;
- case META_TABLE_EXPORTEDTYPE:
+ case MONO_TABLE_EXPORTEDTYPE:
g_assert (i == 1);
- field_size = idx_size (META_TABLE_TYPEDEF); break;
- case META_TABLE_FIELDLAYOUT:
+ field_size = idx_size (MONO_TABLE_TYPEDEF); break;
+ case MONO_TABLE_FIELDLAYOUT:
g_assert (i == 1);
- field_size = idx_size (META_TABLE_FIELD); break;
- case META_TABLE_FIELDRVA:
+ field_size = idx_size (MONO_TABLE_FIELD); break;
+ case MONO_TABLE_FIELDRVA:
g_assert (i == 1);
- field_size = idx_size (META_TABLE_FIELD); break;
- case META_TABLE_IMPLMAP:
+ field_size = idx_size (MONO_TABLE_FIELD); break;
+ case MONO_TABLE_IMPLMAP:
g_assert (i == 3);
- field_size = idx_size (META_TABLE_MODULEREF); break;
- case META_TABLE_INTERFACEIMPL:
+ field_size = idx_size (MONO_TABLE_MODULEREF); break;
+ case MONO_TABLE_INTERFACEIMPL:
g_assert (i == 0);
- field_size = idx_size (META_TABLE_TYPEDEF); break;
- case META_TABLE_METHOD:
+ field_size = idx_size (MONO_TABLE_TYPEDEF); break;
+ case MONO_TABLE_METHOD:
g_assert (i == 5);
- field_size = idx_size (META_TABLE_PARAM); break;
- case META_TABLE_METHODIMPL:
+ field_size = idx_size (MONO_TABLE_PARAM); break;
+ case MONO_TABLE_METHODIMPL:
g_assert (i == 0);
- field_size = idx_size (META_TABLE_TYPEDEF); break;
- case META_TABLE_METHODSEMANTICS:
+ field_size = idx_size (MONO_TABLE_TYPEDEF); break;
+ case MONO_TABLE_METHODSEMANTICS:
g_assert (i == 1);
- field_size = idx_size (META_TABLE_METHOD); break;
- case META_TABLE_NESTEDCLASS:
+ field_size = idx_size (MONO_TABLE_METHOD); break;
+ case MONO_TABLE_NESTEDCLASS:
g_assert (i == 0 || i == 1);
- field_size = idx_size (META_TABLE_TYPEDEF); break;
- case META_TABLE_PROPERTYMAP:
+ field_size = idx_size (MONO_TABLE_TYPEDEF); break;
+ case MONO_TABLE_PROPERTYMAP:
g_assert (i == 0 || i == 1);
- field_size = i ? idx_size (META_TABLE_PROPERTY):
- idx_size(META_TABLE_TYPEDEF);
+ field_size = i ? idx_size (MONO_TABLE_PROPERTY):
+ idx_size(MONO_TABLE_TYPEDEF);
break;
- case META_TABLE_TYPEDEF:
+ case MONO_TABLE_TYPEDEF:
g_assert (i == 4 || i == 5);
- field_size = i == 4 ? idx_size (META_TABLE_FIELD):
- idx_size(META_TABLE_METHOD);
+ field_size = i == 4 ? idx_size (MONO_TABLE_FIELD):
+ idx_size(MONO_TABLE_METHOD);
break;
default:
g_assert_not_reached ();
* HasConstant: ParamDef, FieldDef, Property
*/
case MONO_MT_CONST_IDX:
- n = MAX (meta->tables [META_TABLE_PARAM].rows,
- meta->tables [META_TABLE_FIELD].rows);
- n = MAX (n, meta->tables [META_TABLE_PROPERTY].rows);
+ n = MAX (meta->tables [MONO_TABLE_PARAM].rows,
+ meta->tables [MONO_TABLE_FIELD].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_PROPERTY].rows);
/* 2 bits to encode tag */
field_size = rtsize (n, 16-2);
break;
}*/
- n = MAX (meta->tables [META_TABLE_METHOD].rows,
- meta->tables [META_TABLE_FIELD].rows);
- n = MAX (n, meta->tables [META_TABLE_TYPEREF].rows);
- n = MAX (n, meta->tables [META_TABLE_TYPEDEF].rows);
- n = MAX (n, meta->tables [META_TABLE_PARAM].rows);
- n = MAX (n, meta->tables [META_TABLE_INTERFACEIMPL].rows);
- n = MAX (n, meta->tables [META_TABLE_MEMBERREF].rows);
- n = MAX (n, meta->tables [META_TABLE_MODULE].rows);
+ n = MAX (meta->tables [MONO_TABLE_METHOD].rows,
+ meta->tables [MONO_TABLE_FIELD].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_TYPEREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_TYPEDEF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_PARAM].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_INTERFACEIMPL].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MEMBERREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MODULE].rows);
/* Permission seems to be a blob heap pointer */
- n = MAX (n, meta->tables [META_TABLE_PROPERTY].rows);
- n = MAX (n, meta->tables [META_TABLE_EVENT].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_PROPERTY].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_EVENT].rows);
/* Signature seems to be a blob heap pointer */
- n = MAX (n, meta->tables [META_TABLE_MODULEREF].rows);
- n = MAX (n, meta->tables [META_TABLE_TYPESPEC].rows);
- n = MAX (n, meta->tables [META_TABLE_ASSEMBLY].rows);
- n = MAX (n, meta->tables [META_TABLE_ASSEMBLYREF].rows);
- n = MAX (n, meta->tables [META_TABLE_FILE].rows);
- n = MAX (n, meta->tables [META_TABLE_EXPORTEDTYPE].rows);
- n = MAX (n, meta->tables [META_TABLE_MANIFESTRESOURCE].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MODULEREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLY].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLYREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_FILE].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_EXPORTEDTYPE].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MANIFESTRESOURCE].rows);
/* 5 bits to encode */
field_size = rtsize (n, 16-5);
break;
}*/
- n = MAX (meta->tables [META_TABLE_TYPEREF].rows,
- meta->tables [META_TABLE_TYPEDEF].rows);
- n = MAX (n, meta->tables [META_TABLE_METHOD].rows);
- n = MAX (n, meta->tables [META_TABLE_MEMBERREF].rows);
+ n = MAX (meta->tables [MONO_TABLE_TYPEREF].rows,
+ meta->tables [MONO_TABLE_TYPEDEF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_METHOD].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MEMBERREF].rows);
/* 3 bits to encode */
field_size = rtsize (n, 16-3);
* HasDeclSecurity: Typedef, MethodDef, Assembly
*/
case MONO_MT_HASDEC_IDX:
- n = MAX (meta->tables [META_TABLE_TYPEDEF].rows,
- meta->tables [META_TABLE_METHOD].rows);
- n = MAX (n, meta->tables [META_TABLE_ASSEMBLY].rows);
+ n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows,
+ meta->tables [MONO_TABLE_METHOD].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLY].rows);
/* 2 bits to encode */
field_size = rtsize (n, 16-2);
* Implementation: File, AssemblyRef, ExportedType
*/
case MONO_MT_IMPL_IDX:
- n = MAX (meta->tables [META_TABLE_FILE].rows,
- meta->tables [META_TABLE_ASSEMBLYREF].rows);
- n = MAX (n, meta->tables [META_TABLE_EXPORTEDTYPE].rows);
+ n = MAX (meta->tables [MONO_TABLE_FILE].rows,
+ meta->tables [MONO_TABLE_ASSEMBLYREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_EXPORTEDTYPE].rows);
/* 2 bits to encode tag */
field_size = rtsize (n, 16-2);
* HasFieldMarshall: FieldDef, ParamDef
*/
case MONO_MT_HFM_IDX:
- n = MAX (meta->tables [META_TABLE_FIELD].rows,
- meta->tables [META_TABLE_PARAM].rows);
+ n = MAX (meta->tables [MONO_TABLE_FIELD].rows,
+ meta->tables [MONO_TABLE_PARAM].rows);
/* 1 bit used to encode tag */
field_size = rtsize (n, 16-1);
* MemberForwarded: FieldDef, MethodDef
*/
case MONO_MT_MF_IDX:
- n = MAX (meta->tables [META_TABLE_FIELD].rows,
- meta->tables [META_TABLE_METHOD].rows);
+ n = MAX (meta->tables [MONO_TABLE_FIELD].rows,
+ meta->tables [MONO_TABLE_METHOD].rows);
/* 1 bit used to encode tag */
field_size = rtsize (n, 16-1);
* TypeDefOrRef: TypeDef, ParamDef, TypeSpec
*/
case MONO_MT_TDOR_IDX:
- n = MAX (meta->tables [META_TABLE_TYPEDEF].rows,
- meta->tables [META_TABLE_PARAM].rows);
- n = MAX (n, meta->tables [META_TABLE_TYPESPEC].rows);
+ n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows,
+ meta->tables [MONO_TABLE_PARAM].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows);
/* 2 bits to encode */
field_size = rtsize (n, 16-2);
* MemberRefParent: TypeDef, TypeRef, ModuleDef, ModuleRef, TypeSpec
*/
case MONO_MT_MRP_IDX:
- n = MAX (meta->tables [META_TABLE_TYPEDEF].rows,
- meta->tables [META_TABLE_TYPEREF].rows);
- n = MAX (n, meta->tables [META_TABLE_MODULE].rows);
- n = MAX (n, meta->tables [META_TABLE_MODULEREF].rows);
- n = MAX (n, meta->tables [META_TABLE_TYPESPEC].rows);
+ n = MAX (meta->tables [MONO_TABLE_TYPEDEF].rows,
+ meta->tables [MONO_TABLE_TYPEREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MODULE].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_MODULEREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_TYPESPEC].rows);
/* 3 bits to encode */
field_size = rtsize (n, 16 - 3);
* MethodDefOrRef: MethodDef, MemberRef
*/
case MONO_MT_HS_IDX:
- n = MAX (meta->tables [META_TABLE_METHOD].rows,
- meta->tables [META_TABLE_MEMBERREF].rows);
+ n = MAX (meta->tables [MONO_TABLE_METHOD].rows,
+ meta->tables [MONO_TABLE_MEMBERREF].rows);
/* 1 bit used to encode tag */
field_size = rtsize (n, 16-1);
* ResolutionScope: Module, ModuleRef, AssemblyRef, TypeRef
*/
case MONO_MT_RS_IDX:
- n = MAX (meta->tables [META_TABLE_MODULE].rows,
- meta->tables [META_TABLE_MODULEREF].rows);
- n = MAX (n, meta->tables [META_TABLE_ASSEMBLYREF].rows);
- n = MAX (n, meta->tables [META_TABLE_TYPEREF].rows);
+ n = MAX (meta->tables [MONO_TABLE_MODULE].rows,
+ meta->tables [MONO_TABLE_MODULEREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_ASSEMBLYREF].rows);
+ n = MAX (n, meta->tables [MONO_TABLE_TYPEREF].rows);
/* 2 bits used to encode tag (ECMA spec claims 3) */
field_size = rtsize (n, 16 - 2);
* This is an internal function used by the image loader code.
*/
void
-mono_metadata_compute_table_bases (metadata_t *meta)
+mono_metadata_compute_table_bases (MonoMetadata *meta)
{
int i;
char *base = meta->tables_base;
* whose code is @table.
*/
char *
-mono_metadata_locate (metadata_t *meta, int table, int idx)
+mono_metadata_locate (MonoMetadata *meta, int table, int idx)
{
/* idx == 0 refers always to NULL */
g_return_val_if_fail (idx > 0 && idx <= meta->tables [table].rows, "");
}
char *
-mono_metadata_locate_token (metadata_t *meta, guint32 token)
+mono_metadata_locate_token (MonoMetadata *meta, guint32 token)
{
return mono_metadata_locate (meta, token >> 24, token & 0xffffff);
}
* Returns the MonoMetaTable structure for table @table
*/
MonoMetaTable *
-mono_metadata_get_table (MetaTableEnum table)
+mono_metadata_get_table (MonoMetaTableEnum table)
{
int x = (int) table;
- g_return_val_if_fail ((x > 0) && (x <= META_TABLE_LAST), NULL);
+ g_return_val_if_fail ((x > 0) && (x <= MONO_TABLE_LAST), NULL);
return tables [table].table;
}
* Returns: an in-memory pointer to the @index in the string heap.
*/
const char *
-mono_metadata_string_heap (metadata_t *meta, guint32 index)
+mono_metadata_string_heap (MonoMetadata *meta, guint32 index)
{
- g_return_val_if_fail (index < meta->heap_strings.sh_size, "");
- return meta->raw_metadata + meta->heap_strings.sh_offset + index;
+ g_return_val_if_fail (index < meta->heap_strings.size, "");
+ return meta->raw_metadata + meta->heap_strings.offset + index;
}
const char *
-mono_metadata_user_string (metadata_t *meta, guint32 index)
+mono_metadata_user_string (MonoMetadata *meta, guint32 index)
{
- g_return_val_if_fail (index < meta->heap_us.sh_size, "");
- return meta->raw_metadata + meta->heap_us.sh_offset + index;
+ g_return_val_if_fail (index < meta->heap_us.size, "");
+ return meta->raw_metadata + meta->heap_us.offset + index;
}
/**
* Returns: an in-memory pointer to the @index in the Blob heap.
*/
const char *
-mono_metadata_blob_heap (metadata_t *meta, guint32 index)
+mono_metadata_blob_heap (MonoMetadata *meta, guint32 index)
{
- g_return_val_if_fail (index < meta->heap_blob.sh_size, "");
- return meta->raw_metadata + meta->heap_blob.sh_offset + index;
+ g_return_val_if_fail (index < meta->heap_blob.size, "");
+ return meta->raw_metadata + meta->heap_blob.offset + index;
}
static const char *
* into the guint32 @res array that has res_size elements
*/
void
-mono_metadata_decode_row (metadata_tableinfo_t *t, int idx, guint32 *res, int res_size)
+mono_metadata_decode_row (MonoTableInfo *t, int idx, guint32 *res, int res_size)
{
guint32 bitfield = t->size_bitfield;
- int i, count = meta_table_count (bitfield);
+ int i, count = mono_metadata_table_count (bitfield);
char *data = t->base + idx * t->row_size;
g_assert (res_size == count);
for (i = 0; i < count; i++){
- int n = meta_table_size (bitfield, i);
+ int n = mono_metadata_table_size (bitfield, i);
switch (n){
case 1:
}
guint32
-mono_metadata_parse_typedef_or_ref (metadata_t *m, const char *ptr, const char **rptr)
+mono_metadata_parse_typedef_or_ref (MonoMetadata *m, const char *ptr, const char **rptr)
{
guint32 token;
guint table;
token = mono_metadata_decode_value (ptr, &ptr);
switch (table & 0x03) {
- case 0: table = META_TABLE_TYPEDEF; break;
- case 1: table = META_TABLE_TYPEREF; break;
- case 2: table = META_TABLE_TYPESPEC; break;
+ case 0: table = MONO_TABLE_TYPEDEF; break;
+ case 1: table = MONO_TABLE_TYPEREF; break;
+ case 2: table = MONO_TABLE_TYPESPEC; break;
default: g_error ("Unhandled encoding for typedef-or-ref coded index");
}
if (rptr)
}
int
-mono_metadata_parse_custom_mod (metadata_t *m, MonoCustomMod *dest, const char *ptr, const char **rptr)
+mono_metadata_parse_custom_mod (MonoMetadata *m, MonoCustomMod *dest, const char *ptr, const char **rptr)
{
MonoCustomMod local;
- if ((*ptr == ELEMENT_TYPE_CMOD_OPT) ||
- (*ptr == ELEMENT_TYPE_CMOD_REQD)) {
+ if ((*ptr == MONO_TYPE_CMOD_OPT) ||
+ (*ptr == MONO_TYPE_CMOD_REQD)) {
if (!dest)
dest = &local;
dest->mod = *ptr++;
}
MonoArray *
-mono_metadata_parse_array (metadata_t *m, const char *ptr, const char **rptr)
+mono_metadata_parse_array (MonoMetadata *m, const char *ptr, const char **rptr)
{
int i;
MonoArray *array = g_new0 (MonoArray, 1);
}
MonoParam *
-mono_metadata_parse_param (metadata_t *m, int rettype, const char *ptr, const char **rptr)
+mono_metadata_parse_param (MonoMetadata *m, int rettype, const char *ptr, const char **rptr)
{
const char *tmp_ptr = ptr;
MonoParam *param;
while (mono_metadata_parse_custom_mod (m, &(param->modifiers[count]), ptr, &ptr))
count++;
switch (*ptr) {
- case ELEMENT_TYPE_TYPEDBYREF:
+ case MONO_TYPE_TYPEDBYREF:
param->typedbyref = 1;
ptr++;
break;
- case ELEMENT_TYPE_VOID:
+ case MONO_TYPE_VOID:
if (!rettype)
g_error ("void not allowed in param");
ptr++;
break;
- case ELEMENT_TYPE_BYREF:
+ case MONO_TYPE_BYREF:
byref = 1;
ptr++;
/* follow through */
}
MonoMethodSignature *
-mono_metadata_parse_method_signature (metadata_t *m, int def, const char *ptr, const char **rptr)
+mono_metadata_parse_method_signature (MonoMetadata *m, int def, const char *ptr, const char **rptr)
{
MonoMethodSignature *method = g_new0(MonoMethodSignature, 1);
int i;
method->params = g_new0(MonoParam*, method->param_count);
method->sentinelpos = -1;
for (i = 0; i < method->param_count; ++i) {
- if (*ptr == ELEMENT_TYPE_SENTINEL) {
+ if (*ptr == MONO_TYPE_SENTINEL) {
if (method->call_convention != MONO_CALL_VARARG || def)
g_error ("found sentinel for methoddef or no vararg method");
method->sentinelpos = i;
* This extracts a Type as specified in Partition II (22.2.12)
*/
static void
-do_mono_metadata_parse_type (MonoType *type, metadata_t *m, const char *ptr, const char **rptr)
+do_mono_metadata_parse_type (MonoType *type, MonoMetadata *m, const char *ptr, const char **rptr)
{
type->type = mono_metadata_decode_value (ptr, &ptr);
switch (type->type){
- case ELEMENT_TYPE_BOOLEAN:
- case ELEMENT_TYPE_CHAR:
- case ELEMENT_TYPE_I1:
- case ELEMENT_TYPE_U1:
- case ELEMENT_TYPE_I2:
- case ELEMENT_TYPE_U2:
- case ELEMENT_TYPE_I4:
- case ELEMENT_TYPE_U4:
- case ELEMENT_TYPE_I8:
- case ELEMENT_TYPE_U8:
- case ELEMENT_TYPE_R4:
- case ELEMENT_TYPE_R8:
- case ELEMENT_TYPE_I:
- case ELEMENT_TYPE_U:
- case ELEMENT_TYPE_STRING:
- case ELEMENT_TYPE_OBJECT:
+ case MONO_TYPE_BOOLEAN:
+ case MONO_TYPE_CHAR:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
+ case MONO_TYPE_I8:
+ case MONO_TYPE_U8:
+ case MONO_TYPE_R4:
+ case MONO_TYPE_R8:
+ case MONO_TYPE_I:
+ case MONO_TYPE_U:
+ case MONO_TYPE_STRING:
+ case MONO_TYPE_OBJECT:
break;
- case ELEMENT_TYPE_VALUETYPE:
- case ELEMENT_TYPE_CLASS:
+ case MONO_TYPE_VALUETYPE:
+ case MONO_TYPE_CLASS:
type->data.token = mono_metadata_parse_typedef_or_ref (m, ptr, &ptr);
break;
- case ELEMENT_TYPE_SZARRAY:
- case ELEMENT_TYPE_PTR:
+ case MONO_TYPE_SZARRAY:
+ case MONO_TYPE_PTR:
if (mono_metadata_parse_custom_mod (m, NULL, ptr, NULL)) {
const char *tmp_ptr = ptr;
MonoModifiedType *mtype;
while (mono_metadata_parse_custom_mod (m, &(mtype->modifiers[count]), ptr, &ptr))
count++;
/* FIXME: mono_metadata_decode_value ... */
- if (*ptr == ELEMENT_TYPE_VOID) {
+ if (*ptr == MONO_TYPE_VOID) {
mtype->type = NULL;
ptr++;
} else {
}
} else {
/* FIXME: mono_metadata_decode_value ... */
- if (*ptr == ELEMENT_TYPE_VOID) {
+ if (*ptr == MONO_TYPE_VOID) {
type->data.type = NULL;
ptr++;
} else {
}
}
break;
- case ELEMENT_TYPE_FNPTR:
+ case MONO_TYPE_FNPTR:
type->data.method = mono_metadata_parse_method_signature (m, 0, ptr, &ptr);
break;
- case ELEMENT_TYPE_ARRAY:
+ case MONO_TYPE_ARRAY:
type->data.array = mono_metadata_parse_array (m, ptr, &ptr);
break;
default:
* from the type stored at @ptr in the metadata table @m.
*/
MonoType *
-mono_metadata_parse_type (metadata_t *m, const char *ptr, const char **rptr)
+mono_metadata_parse_type (MonoMetadata *m, const char *ptr, const char **rptr)
{
/* should probably be allocated in a memchunk */
MonoType *type = g_new0(MonoType, 1);
mono_metadata_free_type (MonoType *type)
{
switch (type->type){
- case ELEMENT_TYPE_SZARRAY:
- case ELEMENT_TYPE_PTR:
+ case MONO_TYPE_SZARRAY:
+ case MONO_TYPE_PTR:
if (!type->custom_mod) {
if (type->data.type)
mono_metadata_free_type (type->data.type);
g_free (type->data.mtype);
}
break;
- case ELEMENT_TYPE_FNPTR:
+ case MONO_TYPE_FNPTR:
mono_metadata_free_method_signature (type->data.method);
break;
- case ELEMENT_TYPE_ARRAY:
+ case MONO_TYPE_ARRAY:
mono_metadata_free_array (type->data.array);
break;
}
* @ptr: Points to the beginning of the Section Data (25.3)
*/
static void
-parse_section_data (MonoMetaMethodHeader *mh, const unsigned char *ptr)
+parse_section_data (MonoMethodHeader *mh, const unsigned char *ptr)
{
unsigned char sect_data_flags;
const unsigned char *sptr;
is_fat = sect_data_flags & METHOD_HEADER_SECTION_FAT_FORMAT;
if (is_fat) {
- sect_data_len = (ptr [0] << 16) | (ptr [1] << 8) | ptr [0];
+ sect_data_len = (ptr [0] << 16) | (ptr [1] << 8) | ptr [2];
ptr += 3;
} else {
sect_data_len = ptr [0];
}
}
-MonoMetaMethodHeader *
-mono_metadata_parse_mh (metadata_t *m, const char *ptr)
+MonoMethodHeader *
+mono_metadata_parse_mh (MonoMetadata *m, const char *ptr)
{
- MonoMetaMethodHeader *mh;
+ MonoMethodHeader *mh;
unsigned char flags = *(unsigned char *) ptr;
unsigned char format = flags & METHOD_HEADER_FORMAT_MASK;
guint16 fat_flags;
+ guint32 local_var_sig_tok;
int hsize;
g_return_val_if_fail (ptr != NULL, NULL);
- mh = g_new0 (MonoMetaMethodHeader, 1);
+ mh = g_new0 (MonoMethodHeader, 1);
switch (format){
case METHOD_HEADER_TINY_FORMAT:
ptr++;
mh->max_stack = 8;
- mh->local_var_sig_tok = 0;
+ local_var_sig_tok = 0;
mh->code_size = flags >> 2;
mh->code = ptr;
break;
case METHOD_HEADER_TINY_FORMAT1:
ptr++;
mh->max_stack = 8;
- mh->local_var_sig_tok = 0;
+ local_var_sig_tok = 0;
//
// The spec claims 3 bits, but the Beta2 is
ptr += 2;
mh->code_size = *(guint32 *) ptr;
ptr += 4;
- mh->local_var_sig_tok = *(guint32 *) ptr;
+ local_var_sig_tok = *(guint32 *) ptr;
ptr += 4;
if (fat_flags & METHOD_HEADER_INIT_LOCALS)
return NULL;
}
- if (mh->local_var_sig_tok) {
- metadata_tableinfo_t *t = &m->tables [META_TABLE_STANDALONESIG];
+ if (local_var_sig_tok) {
+ MonoTableInfo *t = &m->tables [MONO_TABLE_STANDALONESIG];
const char *ptr;
- guint32 cols[1];
+ guint32 cols [MONO_STAND_ALONG_SIGNATURE_SIZE];
int len=0, i, bsize;
- mono_metadata_decode_row (t, (mh->local_var_sig_tok & 0xffffff)-1, cols, 1);
- ptr = mono_metadata_blob_heap (m, cols [0]);
+ mono_metadata_decode_row (t, (local_var_sig_tok & 0xffffff)-1, cols, 1);
+ ptr = mono_metadata_blob_heap (m, cols [MONO_STAND_ALONG_SIGNATURE]);
bsize = mono_metadata_decode_blob_size (ptr, &ptr);
if (*ptr != 0x07)
g_warning ("wrong signature for locals blob");
const char *p = ptr;
val = mono_metadata_decode_blob_size (ptr, &ptr);
/* FIXME: store pinned/byref values */
- if (val == ELEMENT_TYPE_PINNED) {
+ if (val == MONO_TYPE_PINNED) {
p = ptr;
val = mono_metadata_decode_blob_size (ptr, &ptr);
}
- if (val == ELEMENT_TYPE_BYREF) {
+ if (val == MONO_TYPE_BYREF) {
p = ptr;
}
mh->locals [i] = mono_metadata_parse_type (m, p, &ptr);
}
void
-mono_metadata_free_mh (MonoMetaMethodHeader *mh)
+mono_metadata_free_mh (MonoMethodHeader *mh)
{
int i;
for (i = 0; i < mh->num_locals; ++i)
* Returns: The MonoFieldType that was extracted from @ptr.
*/
MonoFieldType *
-mono_metadata_parse_field_type (metadata_t *m, const char *ptr, const char **rptr)
+mono_metadata_parse_field_type (MonoMetadata *m, const char *ptr, const char **rptr)
{
return mono_metadata_parse_param (m, 0, ptr, rptr);
}
switch (table){
case 0: /* TypeDef */
- return TOKEN_TYPE_TYPE_DEF | idx;
+ return MONO_TOKEN_TYPE_DEF | idx;
case 1: /* TypeRef */
- return TOKEN_TYPE_TYPE_REF | idx;
+ return MONO_TOKEN_TYPE_REF | idx;
case 2: /* TypeSpec */
- return TOKEN_TYPE_TYPE_SPEC | idx;
+ return MONO_TOKEN_TYPE_SPEC | idx;
default:
g_assert_not_reached ();
typedef struct {
int idx; /* The index that we are trying to locate */
int col_idx; /* The index in the row where idx is stored */
- metadata_t *m; /* the metadata context */
- metadata_tableinfo_t *t; /* pointer to the typedef table */
+ MonoMetadata *m; /* the metadata context */
+ MonoTableInfo *t; /* pointer to the typedef table */
guint32 result;
} locator_t;
return 0;
}
-#define FIELD_INDEX 4
-#define METHOD_INDEX 5
-
guint32
-mono_metadata_typedef_from_field (metadata_t *meta, guint32 index)
+mono_metadata_typedef_from_field (MonoMetadata *meta, guint32 index)
{
- metadata_tableinfo_t *tdef = &meta->tables [META_TABLE_TYPEDEF];
+ MonoTableInfo *tdef = &meta->tables [MONO_TABLE_TYPEDEF];
locator_t loc;
loc.idx = mono_metadata_token_index (index);
- loc.col_idx = FIELD_INDEX;
+ loc.col_idx = MONO_TYPEDEF_FIELD_LIST;
loc.t = tdef;
if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, typedef_locator))
}
guint32
-mono_metadata_typedef_from_method (metadata_t *meta, guint32 index)
+mono_metadata_typedef_from_method (MonoMetadata *meta, guint32 index)
{
- metadata_tableinfo_t *tdef = &meta->tables [META_TABLE_TYPEDEF];
+ MonoTableInfo *tdef = &meta->tables [MONO_TABLE_TYPEDEF];
locator_t loc;
loc.idx = mono_metadata_token_index (index);
- loc.col_idx = METHOD_INDEX;
+ loc.col_idx = MONO_TYPEDEF_METHOD_LIST;
loc.t = tdef;
if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, typedef_locator))
#define MONO_ZERO_LEN_ARRAY 1
#endif
-typedef struct {
- guint32 sh_offset;
- guint32 sh_size;
-} stream_header_t;
+typedef enum {
+ MONO_TABLE_MODULE,
+ MONO_TABLE_TYPEREF,
+ MONO_TABLE_TYPEDEF,
+ MONO_TABLE_UNUSED1,
+ MONO_TABLE_FIELD,
+ MONO_TABLE_UNUSED2,
+ MONO_TABLE_METHOD,
+ MONO_TABLE_UNUSED3,
+ MONO_TABLE_PARAM,
+ MONO_TABLE_INTERFACEIMPL,
+ MONO_TABLE_MEMBERREF,
+ MONO_TABLE_CONSTANT,
+ MONO_TABLE_CUSTOMATTRIBUTE,
+ MONO_TABLE_FIELDMARSHAL,
+ MONO_TABLE_DECLSECURITY,
+ MONO_TABLE_CLASSLAYOUT,
+ MONO_TABLE_FIELDLAYOUT,
+ MONO_TABLE_STANDALONESIG,
+ MONO_TABLE_EVENTMAP,
+ MONO_TABLE_UNUSED4,
+ MONO_TABLE_EVENT,
+ MONO_TABLE_PROPERTYMAP,
+ MONO_TABLE_UNUSED5,
+ MONO_TABLE_PROPERTY,
+ MONO_TABLE_METHODSEMANTICS,
+ MONO_TABLE_METHODIMPL,
+ MONO_TABLE_MODULEREF,
+ MONO_TABLE_TYPESPEC,
+ MONO_TABLE_IMPLMAP,
+ MONO_TABLE_FIELDRVA,
+ MONO_TABLE_UNUSED6,
+ MONO_TABLE_UNUSED7,
+ MONO_TABLE_ASSEMBLY,
+ MONO_TABLE_ASSEMBLYPROCESSOR,
+ MONO_TABLE_ASSEMBLYOS,
+ MONO_TABLE_ASSEMBLYREF,
+ MONO_TABLE_ASSEMBLYREFPROCESSOR,
+ MONO_TABLE_ASSEMBLYREFOS,
+ MONO_TABLE_FILE,
+ MONO_TABLE_EXPORTEDTYPE,
+ MONO_TABLE_MANIFESTRESOURCE,
+ MONO_TABLE_NESTEDCLASS,
+
+#define MONO_TABLE_LAST MONO_TABLE_NESTEDCLASS
+} MonoMetaTableEnum;
+
+typedef enum {
+ MONO_EXCEPTION_CLAUSE_NONE,
+ MONO_EXCEPTION_CLAUSE_FILTER,
+ MONO_EXCEPTION_CLAUSE_FINALLY,
+ MONO_EXCEPTION_CLAUSE_FAULT = 4
+} MonoExceptionEnum;
typedef enum {
- META_TABLE_MODULE,
- META_TABLE_TYPEREF,
- META_TABLE_TYPEDEF,
- META_TABLE_UNUSED1,
- META_TABLE_FIELD,
- META_TABLE_UNUSED2,
- META_TABLE_METHOD,
- META_TABLE_UNUSED3,
- META_TABLE_PARAM,
- META_TABLE_INTERFACEIMPL,
- META_TABLE_MEMBERREF,
- META_TABLE_CONSTANT,
- META_TABLE_CUSTOMATTRIBUTE,
- META_TABLE_FIELDMARSHAL,
- META_TABLE_DECLSECURITY,
- META_TABLE_CLASSLAYOUT,
- META_TABLE_FIELDLAYOUT,
- META_TABLE_STANDALONESIG,
- META_TABLE_EVENTMAP,
- META_TABLE_UNUSED4,
- META_TABLE_EVENT,
- META_TABLE_PROPERTYMAP,
- META_TABLE_UNUSED5,
- META_TABLE_PROPERTY,
- META_TABLE_METHODSEMANTICS,
- META_TABLE_METHODIMPL,
- META_TABLE_MODULEREF,
- META_TABLE_TYPESPEC,
- META_TABLE_IMPLMAP,
- META_TABLE_FIELDRVA,
- META_TABLE_UNUSED6,
- META_TABLE_UNUSED7,
- META_TABLE_ASSEMBLY,
- META_TABLE_ASSEMBLYPROCESSOR,
- META_TABLE_ASSEMBLYOS,
- META_TABLE_ASSEMBLYREF,
- META_TABLE_ASSEMBLYREFPROCESSOR,
- META_TABLE_ASSEMBLYREFOS,
- META_TABLE_FILE,
- META_TABLE_EXPORTEDTYPE,
- META_TABLE_MANIFESTRESOURCE,
- META_TABLE_NESTEDCLASS,
-
-#define META_TABLE_LAST META_TABLE_NESTEDCLASS
-} MetaTableEnum;
+ MONO_CALL_DEFAULT,
+ MONO_CALL_C,
+ MONO_CALL_STDCALL,
+ MONO_CALL_THISCALL,
+ MONO_CALL_FASTCALL,
+ MONO_CALL_VARARG
+} MonoCallConvention;
+
+typedef struct {
+ guint32 offset;
+ guint32 size;
+} MonoStreamHeader;
typedef struct {
guint32 rows, row_size;
* we only need 4, but 8 is aligned no shift required.
*/
guint32 size_bitfield;
-} metadata_tableinfo_t;
+} MonoTableInfo;
-void mono_metadata_decode_row (metadata_tableinfo_t *t,
+void mono_metadata_decode_row (MonoTableInfo *t,
int idx,
guint32 *res,
int res_size);
/*
* This macro is used to extract the size of the table encoded in
- * the size_bitfield of metadata_tableinfo_t.
+ * the size_bitfield of MonoTableInfo.
*/
-#define meta_table_size(bitfield,table) ((((bitfield) >> ((table)*2)) & 0x3) + 1)
-#define meta_table_count(bitfield) ((bitfield) >> 24)
+#define mono_metadata_table_size(bitfield,table) ((((bitfield) >> ((table)*2)) & 0x3) + 1)
+#define mono_metadata_table_count(bitfield) ((bitfield) >> 24)
typedef struct {
char *raw_metadata;
gboolean idx_string_wide, idx_guid_wide, idx_blob_wide;
- stream_header_t heap_strings;
- stream_header_t heap_us;
- stream_header_t heap_blob;
- stream_header_t heap_guid;
- stream_header_t heap_tables;
+ MonoStreamHeader heap_strings;
+ MonoStreamHeader heap_us;
+ MonoStreamHeader heap_blob;
+ MonoStreamHeader heap_guid;
+ MonoStreamHeader heap_tables;
char *tables_base;
- metadata_tableinfo_t tables [64];
-} metadata_t;
-
-/*
- * This enumeration is used to describe the data types in the metadata
- * tables
- */
-enum {
- MONO_MT_END,
-
- /* Sized elements */
- MONO_MT_UINT32,
- MONO_MT_UINT16,
- MONO_MT_UINT8,
-
- /* Index into Blob heap */
- MONO_MT_BLOB_IDX,
-
- /* Index into String heap */
- MONO_MT_STRING_IDX,
-
- /* GUID index */
- MONO_MT_GUID_IDX,
-
- /* Pointer into a table */
- MONO_MT_TABLE_IDX,
-
- /* HasConstant:Parent pointer (Param, Field or Property) */
- MONO_MT_CONST_IDX,
-
- /* HasCustomAttribute index. Indexes any table except CustomAttribute */
- MONO_MT_HASCAT_IDX,
-
- /* CustomAttributeType encoded index */
- MONO_MT_CAT_IDX,
-
- /* HasDeclSecurity index: TypeDef Method or Assembly */
- MONO_MT_HASDEC_IDX,
-
- /* Implementation coded index: File, Export AssemblyRef */
- MONO_MT_IMPL_IDX,
-
- /* HasFieldMarshal coded index: Field or Param table */
- MONO_MT_HFM_IDX,
-
- /* MemberForwardedIndex: Field or Method */
- MONO_MT_MF_IDX,
-
- /* TypeDefOrRef coded index: typedef, typeref, typespec */
- MONO_MT_TDOR_IDX,
-
- /* MemberRefParent coded index: typeref, moduleref, method, memberref, typesepc, typedef */
- MONO_MT_MRP_IDX,
-
- /* MethodDefOrRef coded index: Method or Member Ref table */
- MONO_MT_MDOR_IDX,
-
- /* HasSemantic coded index: Event or Property */
- MONO_MT_HS_IDX,
-
- /* ResolutionScope coded index: Module, ModuleRef, AssemblytRef, TypeRef */
- MONO_MT_RS_IDX
-};
-
-typedef struct {
- int code;
- char *def;
-} MonoMetaTable;
-
-const char *mono_meta_table_name (int table);
-
-/* Internal functions */
-void mono_metadata_compute_table_bases (metadata_t *meta);
-
-MonoMetaTable *mono_metadata_get_table (MetaTableEnum table);
+ MonoTableInfo tables [64];
+} MonoMetadata;
/*
*
*/
-char *mono_metadata_locate (metadata_t *meta, int table, int idx);
-char *mono_metadata_locate_token (metadata_t *meta, guint32 token);
+char *mono_metadata_locate (MonoMetadata *meta, int table, int idx);
+char *mono_metadata_locate_token (MonoMetadata *meta, guint32 token);
-const char *mono_metadata_string_heap (metadata_t *meta, guint32 index);
-const char *mono_metadata_blob_heap (metadata_t *meta, guint32 index);
-const char *mono_metadata_user_string (metadata_t *meta, guint32 index);
+const char *mono_metadata_string_heap (MonoMetadata *meta, guint32 index);
+const char *mono_metadata_blob_heap (MonoMetadata *meta, guint32 index);
+const char *mono_metadata_user_string (MonoMetadata *meta, guint32 index);
-guint32 mono_metadata_typedef_from_field (metadata_t *meta, guint32 index);
-guint32 mono_metadata_typedef_from_method (metadata_t *meta, guint32 index);
+guint32 mono_metadata_typedef_from_field (MonoMetadata *meta, guint32 index);
+guint32 mono_metadata_typedef_from_method (MonoMetadata *meta, guint32 index);
/*
* Functions to extract information from the Blobs
guint32 mono_metadata_decode_blob_size (const char *ptr,
const char **rptr);
-typedef enum {
- MONO_META_EXCEPTION_CLAUSE_NONE,
- MONO_META_EXCEPTION_CLAUSE_FILTER,
- MONO_META_EXCEPTION_CLAUSE_FINALLY,
- MONO_META_EXCEPTION_CLAUSE_FAULT
-} MonoMetaExceptionEnum;
-
-typedef enum {
- MONO_CALL_DEFAULT,
- MONO_CALL_C,
- MONO_CALL_STDCALL,
- MONO_CALL_THISCALL,
- MONO_CALL_FASTCALL,
- MONO_CALL_VARARG
-} MonoCallConvention;
-
typedef struct {
guint32 flags;
guint32 try_offset;
};
typedef struct {
- guint32 code_size;
- const char *code;
- short max_stack;
- guint32 local_var_sig_tok;
-
- unsigned int num_clauses : 16;
- /* if local_var_sig_tok != 0, then the following apply: */
+ guint32 code_size;
+ const char *code;
+ short max_stack;
+ unsigned int num_clauses : 15;
+ /* if num_locals != 0, then the following apply: */
unsigned int init_locals : 1;
- int num_locals;
- MonoType **locals;
+ int num_locals;
+ MonoType **locals;
MonoExceptionClause *clauses;
-} MonoMetaMethodHeader;
+} MonoMethodHeader;
-guint32 mono_metadata_parse_typedef_or_ref (metadata_t *m,
+guint32 mono_metadata_parse_typedef_or_ref (MonoMetadata *m,
const char *ptr,
const char **rptr);
-int mono_metadata_parse_custom_mod (metadata_t *m,
+int mono_metadata_parse_custom_mod (MonoMetadata *m,
MonoCustomMod *dest,
const char *ptr,
const char **rptr);
-MonoArray *mono_metadata_parse_array (metadata_t *m,
+MonoArray *mono_metadata_parse_array (MonoMetadata *m,
const char *ptr,
const char **rptr);
void mono_metadata_free_array (MonoArray *array);
-MonoParam *mono_metadata_parse_param (metadata_t *m,
+MonoParam *mono_metadata_parse_param (MonoMetadata *m,
int rettype,
const char *ptr,
const char **rptr);
void mono_metadata_free_param (MonoParam *param);
-MonoType *mono_metadata_parse_type (metadata_t *m,
+MonoType *mono_metadata_parse_type (MonoMetadata *m,
const char *ptr,
const char **rptr);
void mono_metadata_free_type (MonoType *type);
-MonoFieldType *mono_metadata_parse_field_type (metadata_t *m,
+MonoFieldType *mono_metadata_parse_field_type (MonoMetadata *m,
const char *ptr,
const char **rptr);
-MonoMethodSignature *mono_metadata_parse_method_signature (metadata_t *m,
+MonoMethodSignature *mono_metadata_parse_method_signature (MonoMetadata *m,
int def,
const char *ptr,
const char **rptr);
void mono_metadata_free_method_signature (MonoMethodSignature *method);
-MonoMetaMethodHeader *mono_metadata_parse_mh (metadata_t *m, const char *ptr);
-void mono_metadata_free_mh (MonoMetaMethodHeader *mh);
+MonoMethodHeader *mono_metadata_parse_mh (MonoMetadata *m, const char *ptr);
+void mono_metadata_free_mh (MonoMethodHeader *mh);
/*
* Makes a token based on a table and an index
#include "image.h"
#include <glib.h>
#include "cil-coff.h"
+#include "private.h"
gboolean dump_data = TRUE;
gboolean dump_tables = FALSE;
}
static void
-dump_coff_header (coff_header_t *coff)
+dump_coff_header (MonoCOFFHeader *coff)
{
printf ("\nCOFF Header:\n");
hex16 (" Machine", coff->coff_machine);
}
static void
-dump_pe_header (pe_header_t *pe)
+dump_pe_header (MonoPEHeader *pe)
{
printf ("\nPE Header:\n");
hex16 (" Magic (0x010b)", pe->pe_magic);
}
static void
-dump_nt_header (pe_header_nt_t *nt)
+dump_nt_header (MonoPEHeaderNT *nt)
{
printf ("\nNT Header:\n");
}
static void
-dent (const char *label, pe_dir_entry_t de)
+dent (const char *label, MonoPEDirEntry de)
{
printf ("\t%s: 0x%08x [0x%08x]\n", label, de.rva, de.size);
}
static void
-dump_datadir (pe_datadir_t *dd)
+dump_datadir (MonoPEDatadir *dd)
{
printf ("\nData directories:\n");
dent (" Export Table", dd->pe_export_table);
}
static void
-dump_dotnet_header (dotnet_header_t *header)
+dump_dotnet_header (MonoDotNetHeader *header)
{
dump_coff_header (&header->coff);
dump_pe_header (&header->pe);
}
static void
-dump_section_table (section_table_t *st)
+dump_section_table (MonoSectionTable *st)
{
guint32 flags = st->st_flags;
}
static void
-dump_sections (cli_image_info_t *iinfo)
+dump_sections (MonoCLIImageInfo *iinfo)
{
const int top = iinfo->cli_header.coff.coff_sections;
int i;
}
static void
-dump_cli_header (cli_header_t *ch)
+dump_cli_header (MonoCLIHeader *ch)
{
printf ("\n");
printf (" CLI header size: %d\n", ch->ch_size);
}
static void
-dsh (char *label, stream_header_t *sh)
+dsh (char *label, MonoStreamHeader *sh)
{
printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n",
label,
- sh->sh_offset, sh->sh_offset + sh->sh_size,
- sh->sh_size, sh->sh_size);
+ sh->offset, sh->offset + sh->size,
+ sh->size, sh->size);
}
static void
-dump_metadata_ptrs (metadata_t *meta)
+dump_metadata_ptrs (MonoMetadata *meta)
{
printf ("\nMetadata pointers:\n");
dsh ("\tTables (#~)", &meta->heap_tables);
}
static void
-dump_table (metadata_t *meta, int table)
+dump_table (MonoMetadata *meta, int table)
{
}
static void
-dump_metadata (metadata_t *meta)
+dump_metadata (MonoMetadata *meta)
{
int table;
}
static void
-dump_methoddef (metadata_t *metadata, guint32 token)
+dump_methoddef (MonoMetadata *metadata, guint32 token)
{
char *loc;
static void
dump_dotnet_iinfo (MonoImage *image)
{
- cli_image_info_t *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = image->image_info;
dump_dotnet_header (&iinfo->cli_header);
dump_sections (iinfo);
--- /dev/null
+#ifndef __MONO_METADATA_PRIVATE_H__
+#define __MONO_METADATA_PRIVATE_H__
+
+/*
+ * This enumeration is used to describe the data types in the metadata
+ * tables
+ */
+enum {
+ MONO_MT_END,
+
+ /* Sized elements */
+ MONO_MT_UINT32,
+ MONO_MT_UINT16,
+ MONO_MT_UINT8,
+
+ /* Index into Blob heap */
+ MONO_MT_BLOB_IDX,
+
+ /* Index into String heap */
+ MONO_MT_STRING_IDX,
+
+ /* GUID index */
+ MONO_MT_GUID_IDX,
+
+ /* Pointer into a table */
+ MONO_MT_TABLE_IDX,
+
+ /* HasConstant:Parent pointer (Param, Field or Property) */
+ MONO_MT_CONST_IDX,
+
+ /* HasCustomAttribute index. Indexes any table except CustomAttribute */
+ MONO_MT_HASCAT_IDX,
+
+ /* CustomAttributeType encoded index */
+ MONO_MT_CAT_IDX,
+
+ /* HasDeclSecurity index: TypeDef Method or Assembly */
+ MONO_MT_HASDEC_IDX,
+
+ /* Implementation coded index: File, Export AssemblyRef */
+ MONO_MT_IMPL_IDX,
+
+ /* HasFieldMarshal coded index: Field or Param table */
+ MONO_MT_HFM_IDX,
+
+ /* MemberForwardedIndex: Field or Method */
+ MONO_MT_MF_IDX,
+
+ /* TypeDefOrRef coded index: typedef, typeref, typespec */
+ MONO_MT_TDOR_IDX,
+
+ /* MemberRefParent coded index: typeref, moduleref, method, memberref, typesepc, typedef */
+ MONO_MT_MRP_IDX,
+
+ /* MethodDefOrRef coded index: Method or Member Ref table */
+ MONO_MT_MDOR_IDX,
+
+ /* HasSemantic coded index: Event or Property */
+ MONO_MT_HS_IDX,
+
+ /* ResolutionScope coded index: Module, ModuleRef, AssemblytRef, TypeRef */
+ MONO_MT_RS_IDX
+};
+
+typedef struct {
+ int code;
+ char *def;
+} MonoMetaTable;
+
+const char *mono_meta_table_name (int table);
+
+/* Internal functions */
+void mono_metadata_compute_table_bases (MonoMetadata *meta);
+
+MonoMetaTable *mono_metadata_get_table (MonoMetaTableEnum table);
+
+#endif /* __MONO_METADATA_PRIVATE_H__ */
+
GHashTable *malloc_map;
void *
-raw_buffer_load (int fd, int is_writable, guint32 base, size_t size)
+mono_raw_buffer_load (int fd, int is_writable, guint32 base, size_t size)
{
size_t start, end;
int prot = PROT_READ;
}
void
-raw_buffer_free (void *buffer)
+mono_raw_buffer_free (void *buffer)
{
int size, diff;
char *base;
-void *raw_buffer_load (int fd, int writable, guint32 base, size_t size);
-void raw_buffer_free (void *buffer);
+void *mono_raw_buffer_load (int fd, int writable, guint32 base, size_t size);
+void mono_raw_buffer_free (void *buffer);
*/
enum {
- META_ASSEMBLY_HASH_ALG,
- META_ASSEMBLY_MAJOR_VERSION,
- META_ASSEMBLY_MINOR_VERSION,
- META_ASSEMBLY_BUILD_NUMBER,
- META_ASSEMBLY_REV_NUMBER,
- META_ASSEMBLY_FLAGS,
- META_ASSEMBLY_PUBLIC_KEY,
- META_ASSEMBLY_NAME,
- META_ASSEMBLY_CULTURE,
- META_ASSEMBLY_SIZE
+ MONO_ASSEMBLY_HASH_ALG,
+ MONO_ASSEMBLY_MAJOR_VERSION,
+ MONO_ASSEMBLY_MINOR_VERSION,
+ MONO_ASSEMBLY_BUILD_NUMBER,
+ MONO_ASSEMBLY_REV_NUMBER,
+ MONO_ASSEMBLY_FLAGS,
+ MONO_ASSEMBLY_PUBLIC_KEY,
+ MONO_ASSEMBLY_NAME,
+ MONO_ASSEMBLY_CULTURE,
+ MONO_ASSEMBLY_SIZE
};
enum {
- META_ASSEMBLYOS_PLATFORM,
- META_ASSEMBLYOS_MAJOR_VERSION,
- META_ASSEMBLYOS_MINOR_VERSION,
- META_ASSEMBLYOS_SIZE
+ MONO_ASSEMBLYOS_PLATFORM,
+ MONO_ASSEMBLYOS_MAJOR_VERSION,
+ MONO_ASSEMBLYOS_MINOR_VERSION,
+ MONO_ASSEMBLYOS_SIZE
};
enum {
- META_ASSEMBLY_PROCESSOR,
- META_ASSEMBLY_PROCESSOR_SIZE
+ MONO_ASSEMBLY_PROCESSOR,
+ MONO_ASSEMBLY_PROCESSOR_SIZE
};
enum {
- META_ASSEMBLYREF_MAJOR_VERSION,
- META_ASSEMBLYREF_MINOR_VERSION,
- META_ASSEMBLYREF_BUILD_NUMBER,
- META_ASSEMBLYREF_REV_NUMBER,
- META_ASSEMBLYREF_FLAGS,
- META_ASSEMBLYREF_PUBLIC_KEY,
- META_ASSEMBLYREF_NAME,
- META_ASSEMBLYREF_CULTURE,
- META_ASSEMBLYREF_HASH_VALUE,
- META_ASSEMBLYREF_SIZE
+ MONO_ASSEMBLYREF_MAJOR_VERSION,
+ MONO_ASSEMBLYREF_MINOR_VERSION,
+ MONO_ASSEMBLYREF_BUILD_NUMBER,
+ MONO_ASSEMBLYREF_REV_NUMBER,
+ MONO_ASSEMBLYREF_FLAGS,
+ MONO_ASSEMBLYREF_PUBLIC_KEY,
+ MONO_ASSEMBLYREF_NAME,
+ MONO_ASSEMBLYREF_CULTURE,
+ MONO_ASSEMBLYREF_HASH_VALUE,
+ MONO_ASSEMBLYREF_SIZE
};
enum {
- META_ASSEMBLYREFOS_PLATFORM,
- META_ASSEMBLYREFOS_MAJOR_VERSION,
- META_ASSEMBLYREFOS_MINOR_VERSION,
- META_ASSEMBLYREFOS_ASSEMBLYREF,
- META_ASSEMBLYREFOS_SIZE
+ MONO_ASSEMBLYREFOS_PLATFORM,
+ MONO_ASSEMBLYREFOS_MAJOR_VERSION,
+ MONO_ASSEMBLYREFOS_MINOR_VERSION,
+ MONO_ASSEMBLYREFOS_ASSEMBLYREF,
+ MONO_ASSEMBLYREFOS_SIZE
};
enum {
- META_ASSEMBLYREFPROC_PROCESSOR,
- META_ASSEMBLYREFPROC_ASSEMBLYREF,
- META_ASSEMBLYREFPROC_SIZE
+ MONO_ASSEMBLYREFPROC_PROCESSOR,
+ MONO_ASSEMBLYREFPROC_ASSEMBLYREF,
+ MONO_ASSEMBLYREFPROC_SIZE
};
enum {
- META_CLASS_LAYOUT_PACKING_SIZE,
- META_CLASS_LAYOUT_CLASS_SIZE,
- META_CLASS_LAYOUT_PARENT,
- META_CLASS_LAYOUT_SIZE
+ MONO_CLASS_LAYOUT_PACKING_SIZE,
+ MONO_CLASS_LAYOUT_CLASS_SIZE,
+ MONO_CLASS_LAYOUT_PARENT,
+ MONO_CLASS_LAYOUT_SIZE
};
enum {
- META_CONSTANT_TYPE,
- META_CONSTANT_PADDING,
- META_CONSTANT_PARENT,
- META_CONSTANT_VALUE,
- META_CONSTANT_SIZE
+ MONO_CONSTANT_TYPE,
+ MONO_CONSTANT_PADDING,
+ MONO_CONSTANT_PARENT,
+ MONO_CONSTANT_VALUE,
+ MONO_CONSTANT_SIZE
};
enum {
- META_CUSTOM_ATTR_PARENT,
- META_CUSTOM_ATTR_TYPE,
- META_CUSTOM_ATTR_VALUE,
- META_CUSTOM_ATTR_SIZE
+ MONO_CUSTOM_ATTR_PARENT,
+ MONO_CUSTOM_ATTR_TYPE,
+ MONO_CUSTOM_ATTR_VALUE,
+ MONO_CUSTOM_ATTR_SIZE
};
enum {
- META_DECL_SECURITY_ACTION,
- META_DECL_SECURITY_PARENT,
- META_DECL_SECURITY_PERMISSIONSET,
- META_DECL_SECURITY_SIZE
+ MONO_DECL_SECURITY_ACTION,
+ MONO_DECL_SECURITY_PARENT,
+ MONO_DECL_SECURITY_PERMISSIONSET,
+ MONO_DECL_SECURITY_SIZE
};
enum {
- META_EVENT_MAP_PARENT,
- META_EVENT_MAP_EVENTLIST,
- META_EVENT_MAP_SIZE
+ MONO_EVENT_MAP_PARENT,
+ MONO_EVENT_MAP_EVENTLIST,
+ MONO_EVENT_MAP_SIZE
};
enum {
- META_EVENT_FLAGS,
- META_EVENT_NAME,
- META_EVENT_TYPE,
- META_EVENT_SIZE
+ MONO_EVENT_FLAGS,
+ MONO_EVENT_NAME,
+ MONO_EVENT_TYPE,
+ MONO_EVENT_SIZE
};
enum {
- META_EXP_TYPE_FLAGS,
- META_EXP_TYPE_TYPEDEF,
- META_EXP_TYPE_NAME,
- META_EXP_TYPE_NAMESPACE,
- META_EXP_TYPE_IMPLEMENTATION,
- META_EXP_TYPE_SIZE
+ MONO_EXP_TYPE_FLAGS,
+ MONO_EXP_TYPE_TYPEDEF,
+ MONO_EXP_TYPE_NAME,
+ MONO_EXP_TYPE_NAMESPACE,
+ MONO_EXP_TYPE_IMPLEMENTATION,
+ MONO_EXP_TYPE_SIZE
};
enum {
- META_FIELD_FLAGS,
- META_FIELD_NAME,
- META_FIELD_SIGNATURE,
- META_FIELD_SIZE
+ MONO_FIELD_FLAGS,
+ MONO_FIELD_NAME,
+ MONO_FIELD_SIGNATURE,
+ MONO_FIELD_SIZE
};
enum {
- META_FIELD_LAYOUT_OFFSET,
- META_FIELD_LAYOUT_FIELD,
- META_FIELD_LAYOUT_SIZE
+ MONO_FIELD_LAYOUT_OFFSET,
+ MONO_FIELD_LAYOUT_FIELD,
+ MONO_FIELD_LAYOUT_SIZE
};
enum {
- META_FIELD_MARSHAL_PARENT,
- META_FIELD_MARSHAL_NATIVE_TYPE,
- META_FIELD_MARSHAL_SIZE
+ MONO_FIELD_MARSHAL_PARENT,
+ MONO_FIELD_MARSHAL_NATIVE_TYPE,
+ MONO_FIELD_MARSHAL_SIZE
};
enum {
- META_FIELD_RVA_RVA,
- META_FIELD_RVA_FIELD,
- META_FIELD_RVA_SIZE
+ MONO_FIELD_RVA_RVA,
+ MONO_FIELD_RVA_FIELD,
+ MONO_FIELD_RVA_SIZE
};
enum {
- META_FILE_FLAGS,
- META_FILE_NAME,
- META_FILE_HASH_VALUE,
- META_FILE_SIZE
+ MONO_FILE_FLAGS,
+ MONO_FILE_NAME,
+ MONO_FILE_HASH_VALUE,
+ MONO_FILE_SIZE
};
enum {
- META_IMPLMAP_FLAGS,
- META_IMPLMAP_MEMBER,
- META_IMPLMAP_NAME,
- META_IMPLMAP_SCOPE,
- META_IMPLMAP_SIZE
+ MONO_IMPLMAP_FLAGS,
+ MONO_IMPLMAP_MEMBER,
+ MONO_IMPLMAP_NAME,
+ MONO_IMPLMAP_SCOPE,
+ MONO_IMPLMAP_SIZE
};
enum {
- META_INTERFACEIMPL_CLASS,
- META_INTERFACEIMPL_INTERFACE,
- META_INTERFACEIMPL_SIZE
+ MONO_INTERFACEIMPL_CLASS,
+ MONO_INTERFACEIMPL_INTERFACE,
+ MONO_INTERFACEIMPL_SIZE
};
enum {
- META_MANIFEST_OFFSET,
- META_MANIFEST_FLAGS,
- META_MANIFEST_NAME,
- META_MANIFEST_IMPLEMENTATION,
- META_MANIFEST_SIZE
+ MONO_MANIFEST_OFFSET,
+ MONO_MANIFEST_FLAGS,
+ MONO_MANIFEST_NAME,
+ MONO_MANIFEST_IMPLEMENTATION,
+ MONO_MANIFEST_SIZE
};
enum {
- META_MEMBERREF_CLASS,
- META_MEMBERREF_NAME,
- META_MEMBERREF_SIGNATURE,
- META_MEMBERREF_SIZE
+ MONO_MEMBERREF_CLASS,
+ MONO_MEMBERREF_NAME,
+ MONO_MEMBERREF_SIGNATURE,
+ MONO_MEMBERREF_SIZE
};
enum {
- META_METHOD_RVA,
- META_METHOD_IMPLFALGS,
- META_METHOD_FLAGS,
- META_METHOD_NAME,
- META_METHOD_SIGNATURE,
- META_METHOD_PARAMLIST,
- META_METHOD_SIZE
+ MONO_METHOD_RVA,
+ MONO_METHOD_IMPLFALGS,
+ MONO_METHOD_FLAGS,
+ MONO_METHOD_NAME,
+ MONO_METHOD_SIGNATURE,
+ MONO_METHOD_PARAMLIST,
+ MONO_METHOD_SIZE
};
enum {
- META_MTHODIMPL_CLASS,
- META_MTHODIMPL_BODY,
- META_MTHODIMPL_DECLARATION,
- META_MTHODIMPL_SIZE
+ MONO_MTHODIMPL_CLASS,
+ MONO_MTHODIMPL_BODY,
+ MONO_MTHODIMPL_DECLARATION,
+ MONO_MTHODIMPL_SIZE
};
enum {
- META_METHOD_SEMA_SEMANTICS,
- META_METHOD_SEMA_METHOD,
- META_METHOD_SEMA_ASSOCIATION,
- META_METHOD_SEMA_SIZE
+ MONO_METHOD_SEMA_SEMANTICS,
+ MONO_METHOD_SEMA_METHOD,
+ MONO_METHOD_SEMA_ASSOCIATION,
+ MONO_METHOD_SEMA_SIZE
};
enum {
- META_MODULE_GENERATION,
- META_MODULE_NAME,
- META_MODULE_MVID,
- META_MODULE_ENC,
- META_MODULE_ENCBASE,
- META_MODULE_SIZE
+ MONO_MODULE_GENERATION,
+ MONO_MODULE_NAME,
+ MONO_MODULE_MVID,
+ MONO_MODULE_ENC,
+ MONO_MODULE_ENCBASE,
+ MONO_MODULE_SIZE
};
enum {
- META_MODULEREF_NAME,
- META_MODULEREF_SIZE
+ MONO_MODULEREF_NAME,
+ MONO_MODULEREF_SIZE
};
enum {
- META_NESTED_CLASS_NESTED,
- META_NESTED_CLASS_ENCLOSING,
- META_NESTED_CLASS_SIZE
+ MONO_NESTED_CLASS_NESTED,
+ MONO_NESTED_CLASS_ENCLOSING,
+ MONO_NESTED_CLASS_SIZE
};
enum {
- META_PARAM_FLAGS,
- META_PARAM_SEQUENCE,
- META_PARAM_NAME,
- META_PARAM_SIZE
+ MONO_PARAM_FLAGS,
+ MONO_PARAM_SEQUENCE,
+ MONO_PARAM_NAME,
+ MONO_PARAM_SIZE
};
enum {
- META_PROPERTY_FLAGS,
- META_PROPERTY_NAME,
- META_PROPERTY_TYPE,
- META_PROPERTY_SIZE
+ MONO_PROPERTY_FLAGS,
+ MONO_PROPERTY_NAME,
+ MONO_PROPERTY_TYPE,
+ MONO_PROPERTY_SIZE
};
enum {
- META_PROPERTY_MAP_PARENT,
- META_PROPERTY_MAP_PROPERTY_LIST,
- META_PROPERTY_MAP_SIZE
+ MONO_PROPERTY_MAP_PARENT,
+ MONO_PROPERTY_MAP_PROPERTY_LIST,
+ MONO_PROPERTY_MAP_SIZE
};
enum {
- META_STAND_ALONG_SIGNATURE,
- META_STAND_ALONG_SIGNATURE_SIZE
+ MONO_STAND_ALONG_SIGNATURE,
+ MONO_STAND_ALONG_SIGNATURE_SIZE
};
enum {
- META_TYPEDEF_FLAGS,
- META_TYPEDEF_NAME,
- META_TYPEDEF_NAMESPACE,
- META_TYPEDEF_EXTENDS,
- META_TYPEDEF_FIELD_LIST,
- META_TYPEDEF_METHOD_LIST,
- META_TYPEDEF_SIZE
+ MONO_TYPEDEF_FLAGS,
+ MONO_TYPEDEF_NAME,
+ MONO_TYPEDEF_NAMESPACE,
+ MONO_TYPEDEF_EXTENDS,
+ MONO_TYPEDEF_FIELD_LIST,
+ MONO_TYPEDEF_METHOD_LIST,
+ MONO_TYPEDEF_SIZE
};
enum {
- META_TYPEREF_SCOPE,
- META_TYPEREF_NAME,
- META_TYPEREF_NAMESPACE,
- META_TYPEREF_SIZE
+ MONO_TYPEREF_SCOPE,
+ MONO_TYPEREF_NAME,
+ MONO_TYPEREF_NAMESPACE,
+ MONO_TYPEREF_SIZE
};
enum {
- META_TYPESPEC_SIGNATURE,
- META_TYPESPEC_SIZE
+ MONO_TYPESPEC_SIGNATURE,
+ MONO_TYPESPEC_SIZE
};
/*
*/
typedef enum {
- TOKEN_TYPE_MODULE = 0x00000000,
- TOKEN_TYPE_TYPE_REF = 0x01000000,
- TOKEN_TYPE_TYPE_DEF = 0x02000000,
- TOKEN_TYPE_FIELD_DEF = 0x04000000,
- TOKEN_TYPE_METHOD_DEF = 0x06000000,
- TOKEN_TYPE_PARAM_DEF = 0x08000000,
- TOKEN_TYPE_INTERFACE_IMPL = 0x09000000,
- TOKEN_TYPE_MEMBER_REF = 0x0a000000,
- TOKEN_TYPE_CUSTOM_ATTRIBUTE = 0x0c000000,
- TOKEN_TYPE_PERMISSION = 0x0e000000,
- TOKEN_TYPE_SIGNATURE = 0x11000000,
- TOKEN_TYPE_EVENT = 0x14000000,
- TOKEN_TYPE_PROPERTY = 0x17000000,
- TOKEN_TYPE_MODULE_REF = 0x1a000000,
- TOKEN_TYPE_TYPE_SPEC = 0x1b000000,
- TOKEN_TYPE_ASSEMBLY = 0x20000000,
- TOKEN_TYPE_ASSEMBLY_REF = 0x23000000,
- TOKEN_TYPE_FILE = 0x26000000,
- TOKEN_TYPE_EXPORTED_TYPE = 0x27000000,
- TOKEN_TYPE_MANIFEST_RESOURCE = 0x28000000,
+ MONO_TOKEN_MODULE = 0x00000000,
+ MONO_TOKEN_TYPE_REF = 0x01000000,
+ MONO_TOKEN_TYPE_DEF = 0x02000000,
+ MONO_TOKEN_FIELD_DEF = 0x04000000,
+ MONO_TOKEN_METHOD_DEF = 0x06000000,
+ MONO_TOKEN_PARAM_DEF = 0x08000000,
+ MONO_TOKEN_INTERFACE_IMPL = 0x09000000,
+ MONO_TOKEN_MEMBER_REF = 0x0a000000,
+ MONO_TOKEN_CUSTOM_ATTRIBUTE = 0x0c000000,
+ MONO_TOKEN_PERMISSION = 0x0e000000,
+ MONO_TOKEN_SIGNATURE = 0x11000000,
+ MONO_TOKEN_EVENT = 0x14000000,
+ MONO_TOKEN_PROPERTY = 0x17000000,
+ MONO_TOKEN_MODULE_REF = 0x1a000000,
+ MONO_TOKEN_TYPE_SPEC = 0x1b000000,
+ MONO_TOKEN_ASSEMBLY = 0x20000000,
+ MONO_TOKEN_ASSEMBLY_REF = 0x23000000,
+ MONO_TOKEN_FILE = 0x26000000,
+ MONO_TOKEN_EXPORTED_TYPE = 0x27000000,
+ MONO_TOKEN_MANIFEST_RESOURCE = 0x28000000,
/*
* These do not match metadata tables directly
*/
- TOKEN_TYPE_STRING = 0x70000000,
- TOKEN_TYPE_NAME = 0x71000000,
- TOKEN_TYPE_BASE_TYPE = 0x72000000
-} TokenType;
+ MONO_TOKEN_STRING = 0x70000000,
+ MONO_TOKEN_NAME = 0x71000000,
+ MONO_TOKEN_BASE_TYPE = 0x72000000
+} MonoTokenType;
#endif /* _MONO_METADATA_TOKENTYPE_H_ */
void
mono_typedef_decode (MonoImage *image, guint32 tidx, MonoTypedef *ret)
{
- metadata_t *m = &image->metadata;
- metadata_tableinfo_t *tt = m->tables [META_TABLE_TYPEDEF];
+ MonoMetadata *m = &image->metadata;
+ MonoTableInfo *tt = m->tables [MONO_TABLE_TYPEDEF];
int next_is_valid;
- guint32 cols_next [6];
+ guint32 cols_next [MONO_TYPEDEF_SIZE];
guint last;
g_assert (typedef_token < tt->rows);
/*
* Get the field and method range
*/
- ret->field.first = ret->cols [4] - 1;
- ret->method.first = ret->cols [5] - 1;
+ ret->field.first = ret->cols [MONO_TYPEREF_FIELD_LIST] - 1;
+ ret->method.first = ret->cols [MONO_TYPEDEF_METHOD_LIST] - 1;
if (tt->rows > typedef_idx + 1){
mono_metadata_decode_row (tt, typedef_idx + 1, cols_next, CSIZE (cols_next));
- ret->field.last = cols_next [4] - 1;
- ret->method.last = cols_next [5] - 1;
+ ret->field.last = cols_next [MONO_TYPEREF_FIELD_LIST] - 1;
+ ret->method.last = cols_next [MONO_TYPEREF_FIELD_LIST] - 1;
} else {
- ret->field.last = m->tables [META_TABLE_FIELD].rows;
- ret->field.method = m->tables [META_TABLE_METHOD].rows;
+ ret->field.last = m->tables [MONO_TABLE_FIELD].rows;
+ ret->field.method = m->tables [MONO_TABLE_METHOD].rows;
}
/*
projects / mono.git / commitdiff