* *.c, *.h: avoid namespace pollution in public headers.
svn path=/trunk/mono/; revision=30116
for (i = 0; i < t->rows; i++){
guint32 cols [MONO_CONSTANT_SIZE];
- const char *parent = desc [cols [MONO_CONSTANT_PARENT] & HASCONSTANT_MASK];
+ const char *parent = desc [cols [MONO_CONSTANT_PARENT] & MONO_HASCONSTANT_MASK];
mono_metadata_decode_row (t, i, cols, MONO_CONSTANT_SIZE);
fprintf (output, "%d: Parent= %s: %d %s\n",
- i + 1, parent, cols [MONO_CONSTANT_PARENT] >> HASCONSTANT_BITS,
+ i + 1, parent, cols [MONO_CONSTANT_PARENT] >> MONO_HASCONSTANT_BITS,
get_constant (m, (MonoTypeEnum) cols [MONO_CONSTANT_TYPE], cols [MONO_CONSTANT_VALUE]));
}
const char* table = "";
if (!idx)
return g_strdup ("current module");
- row = idx >> IMPLEMENTATION_BITS;
- switch (idx & IMPLEMENTATION_MASK) {
- case IMPLEMENTATION_FILE:
+ row = idx >> MONO_IMPLEMENTATION_BITS;
+ switch (idx & MONO_IMPLEMENTATION_MASK) {
+ case MONO_IMPLEMENTATION_FILE:
table = "file";
break;
- case IMPLEMENTATION_ASSEMBLYREF:
+ case MONO_IMPLEMENTATION_ASSEMBLYREF:
table = "assemblyref";
break;
- case IMPLEMENTATION_EXP_TYPE:
+ case MONO_IMPLEMENTATION_EXP_TYPE:
table = "exportedtype";
break;
default:
mono_metadata_decode_row (t, i - 1, cols, MONO_IMPLMAP_SIZE);
- method = get_method (m, MONO_TOKEN_METHOD_DEF | (cols [MONO_IMPLMAP_MEMBER] >> MEMBERFORWD_BITS));
+ method = get_method (m, MONO_TOKEN_METHOD_DEF | (cols [MONO_IMPLMAP_MEMBER] >> MONO_MEMBERFORWD_BITS));
fprintf (output, "%d: %s %d (%s %s)\n", i,
method,
static guint32
method_dor_to_token (guint32 idx) {
- switch (idx & METHODDEFORREF_MASK) {
- case METHODDEFORREF_METHODDEF:
- return MONO_TOKEN_METHOD_DEF | (idx >> METHODDEFORREF_BITS);
- case METHODDEFORREF_METHODREF:
- return MONO_TOKEN_MEMBER_REF | (idx >> METHODDEFORREF_BITS);
+ switch (idx & MONO_METHODDEFORREF_MASK) {
+ case MONO_METHODDEFORREF_METHODDEF:
+ return MONO_TOKEN_METHOD_DEF | (idx >> MONO_METHODDEFORREF_BITS);
+ case MONO_METHODDEFORREF_METHODREF:
+ return MONO_TOKEN_MEMBER_REF | (idx >> MONO_METHODDEFORREF_BITS);
}
return -1;
}
mono_metadata_decode_row (t, i - 1, cols, MONO_METHOD_SEMA_SIZE);
semantics = flags (cols [MONO_METHOD_SEMA_SEMANTICS], semantics_map);
- is_property = cols [MONO_METHOD_SEMA_ASSOCIATION] & HAS_SEMANTICS_MASK;
- index = cols [MONO_METHOD_SEMA_ASSOCIATION] >> HAS_SEMANTICS_BITS;
+ is_property = cols [MONO_METHOD_SEMA_ASSOCIATION] & MONO_HAS_SEMANTICS_MASK;
+ index = cols [MONO_METHOD_SEMA_ASSOCIATION] >> MONO_HAS_SEMANTICS_BITS;
fprintf (output, "%d: [%d] %s method: %d %s %d\n", i, cols [MONO_METHOD_SEMA_ASSOCIATION], semantics,
cols [MONO_METHOD_SEMA_METHOD] - 1,
is_property? "property" : "event",
static char*
has_cattr_get_table (MonoImage *m, guint32 val)
{
- guint32 t = val & CUSTOM_ATTR_MASK;
- guint32 index = val >> CUSTOM_ATTR_BITS;
+ guint32 t = val & MONO_CUSTOM_ATTR_MASK;
+ guint32 index = val >> MONO_CUSTOM_ATTR_BITS;
const char *table;
switch (t) {
- case CUSTOM_ATTR_METHODDEF:
+ case MONO_CUSTOM_ATTR_METHODDEF:
table = "MethodDef";
break;
- case CUSTOM_ATTR_FIELDDEF:
+ case MONO_CUSTOM_ATTR_FIELDDEF:
table = "FieldDef";
break;
- case CUSTOM_ATTR_TYPEREF:
+ case MONO_CUSTOM_ATTR_TYPEREF:
table = "TypeRef";
break;
- case CUSTOM_ATTR_TYPEDEF:
+ case MONO_CUSTOM_ATTR_TYPEDEF:
table = "TypeDef";
break;
- case CUSTOM_ATTR_PARAMDEF:
+ case MONO_CUSTOM_ATTR_PARAMDEF:
table = "Param";
break;
- case CUSTOM_ATTR_INTERFACE:
+ case MONO_CUSTOM_ATTR_INTERFACE:
table = "InterfaceImpl";
break;
- case CUSTOM_ATTR_MEMBERREF:
+ case MONO_CUSTOM_ATTR_MEMBERREF:
table = "MemberRef";
break;
- case CUSTOM_ATTR_MODULE:
+ case MONO_CUSTOM_ATTR_MODULE:
table = "Module";
break;
- case CUSTOM_ATTR_PERMISSION:
+ case MONO_CUSTOM_ATTR_PERMISSION:
table = "DeclSecurity?";
break;
- case CUSTOM_ATTR_PROPERTY:
+ case MONO_CUSTOM_ATTR_PROPERTY:
table = "Property";
break;
- case CUSTOM_ATTR_EVENT:
+ case MONO_CUSTOM_ATTR_EVENT:
table = "Event";
break;
- case CUSTOM_ATTR_SIGNATURE:
+ case MONO_CUSTOM_ATTR_SIGNATURE:
table = "StandAloneSignature";
break;
- case CUSTOM_ATTR_MODULEREF:
+ case MONO_CUSTOM_ATTR_MODULEREF:
table = "ModuleRef";
break;
- case CUSTOM_ATTR_TYPESPEC:
+ case MONO_CUSTOM_ATTR_TYPESPEC:
table = "TypeSpec";
break;
- case CUSTOM_ATTR_ASSEMBLY:
+ case MONO_CUSTOM_ATTR_ASSEMBLY:
table = "Assembly";
break;
- case CUSTOM_ATTR_ASSEMBLYREF:
+ case MONO_CUSTOM_ATTR_ASSEMBLYREF:
table = "AssemblyRef";
break;
- case CUSTOM_ATTR_FILE:
+ case MONO_CUSTOM_ATTR_FILE:
table = "File";
break;
- case CUSTOM_ATTR_EXP_TYPE:
+ case MONO_CUSTOM_ATTR_EXP_TYPE:
table = "ExportedType";
break;
- case CUSTOM_ATTR_MANIFEST:
+ case MONO_CUSTOM_ATTR_MANIFEST:
table = "Manifest";
break;
default:
mono_metadata_decode_row (t, i - 1, cols, MONO_CUSTOM_ATTR_SIZE);
desc = has_cattr_get_table (m, cols [MONO_CUSTOM_ATTR_PARENT]);
- mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> CUSTOM_ATTR_TYPE_BITS;
- switch (cols [MONO_CUSTOM_ATTR_TYPE] & CUSTOM_ATTR_TYPE_MASK) {
- case CUSTOM_ATTR_TYPE_METHODDEF:
+ mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
+ switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
+ case MONO_CUSTOM_ATTR_TYPE_METHODDEF:
mtoken |= MONO_TOKEN_METHOD_DEF;
break;
- case CUSTOM_ATTR_TYPE_MEMBERREF:
+ case MONO_CUSTOM_ATTR_TYPE_MEMBERREF:
mtoken |= MONO_TOKEN_MEMBER_REF;
break;
default:
mono_metadata_decode_row (t, i - 1, cols, MONO_FIELD_MARSHAL_SIZE);
blob = mono_metadata_blob_heap (m, cols [MONO_FIELD_MARSHAL_NATIVE_TYPE]);
native = get_marshal_info (m, blob);
- is_field = (cols [MONO_FIELD_MARSHAL_PARENT] & HAS_FIELD_MARSHAL_MASK) == HAS_FIELD_MARSHAL_FIELDSREF;
- idx = cols [MONO_FIELD_MARSHAL_PARENT] >> HAS_FIELD_MARSHAL_BITS;
+ is_field = (cols [MONO_FIELD_MARSHAL_PARENT] & MONO_HAS_FIELD_MARSHAL_MASK) == MONO_HAS_FIELD_MARSHAL_FIELDSREF;
+ idx = cols [MONO_FIELD_MARSHAL_PARENT] >> MONO_HAS_FIELD_MARSHAL_BITS;
fprintf (output, "%d: (0x%04x) %s %d: %s\n", i, cols [MONO_FIELD_MARSHAL_PARENT], is_field? "Field" : "Param", idx, native);
g_free (native);
}
len = mono_metadata_decode_blob_size (blob, &blob);
action = get_security_action (cols [MONO_DECL_SECURITY_ACTION]);
idx = cols [MONO_DECL_SECURITY_PARENT];
- fprintf (output, "%d: %s on %s %d%s", i, action, parent [idx & HAS_DECL_SECURITY_MASK], idx >> HAS_DECL_SECURITY_BITS, len? ":\n\t":"\n");
+ fprintf (output, "%d: %s on %s %d%s", i, action, parent [idx & MONO_HAS_DECL_SECURITY_MASK], idx >> MONO_HAS_DECL_SECURITY_BITS, len? ":\n\t":"\n");
if (!len)
continue;
for (idx = 0; idx < len; ++idx)
t = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]);
s = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]);
- rs_idx = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
- table = cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
+ rs_idx = cols [MONO_TYPEREF_SCOPE] >> MONO_RESOLTION_SCOPE_BITS;
+ table = cols [MONO_TYPEREF_SCOPE] & MONO_RESOLTION_SCOPE_MASK;
switch (table){
- case RESOLTION_SCOPE_MODULE: /* Module */
+ case MONO_RESOLTION_SCOPE_MODULE: /* Module */
x = get_module (m, rs_idx);
ret = g_strdup_printf ("[%s] %s%s%s", x, s, *s?".":"", t);
g_free (x);
break;
- case RESOLTION_SCOPE_MODULEREF: /* ModuleRef */
+ case MONO_RESOLTION_SCOPE_MODULEREF: /* ModuleRef */
x = get_moduleref (m, rs_idx);
ret = g_strdup_printf ("[.module %s]%s%s%s", x, s, *s ? "." : "", t);
break;
- case RESOLTION_SCOPE_ASSEMBLYREF: /*
+ case MONO_RESOLTION_SCOPE_ASSEMBLYREF: /*
* AssemblyRef (ECMA docs claim it is 3, but it looks to
* me like it is 2 (tokens are prefixed with 0x23)
*/
g_free (x);
break;
- case RESOLTION_SCOPE_TYPEREF: /* TypeRef */
+ case MONO_RESOLTION_SCOPE_TYPEREF: /* TypeRef */
x = get_typeref (m, rs_idx);
ret = g_strdup_printf ("%s/%s", x, t);
g_free (x);
/*
* low 2 bits contain encoding
*/
- table = dor_token & TYPEDEFORREF_MASK;
- idx = dor_token >> TYPEDEFORREF_BITS;
+ table = dor_token & MONO_TYPEDEFORREF_MASK;
+ idx = dor_token >> MONO_TYPEDEFORREF_BITS;
switch (table){
case 0: /* TypeDef */
guint32 sig;
int param_count, cconv, i, gen_count = 0;
- switch (token & METHODDEFORREF_MASK) {
- case METHODDEFORREF_METHODDEF:
+ switch (token & MONO_METHODDEFORREF_MASK) {
+ case MONO_METHODDEFORREF_METHODDEF:
mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
- (token >> METHODDEFORREF_BITS) - 1,
+ (token >> MONO_METHODDEFORREF_BITS) - 1,
method_cols, MONO_METHOD_SIZE);
sig = method_cols [MONO_METHOD_SIGNATURE];
break;
- case METHODDEFORREF_METHODREF:
+ case MONO_METHODDEFORREF_METHODREF:
mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
- (token >> METHODDEFORREF_BITS) - 1,
+ (token >> MONO_METHODDEFORREF_BITS) - 1,
member_cols, MONO_MEMBERREF_SIZE);
sig = member_cols [MONO_MEMBERREF_SIGNATURE];
break;
const char *val;
idx = mono_metadata_token_index (token);
- idx <<= CUSTOM_ATTR_BITS;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
switch (mono_metadata_token_table (token)) {
case MONO_TABLE_TYPEDEF:
- idx |= CUSTOM_ATTR_TYPEDEF;
+ idx |= MONO_CUSTOM_ATTR_TYPEDEF;
break;
case MONO_TABLE_ASSEMBLY:
- idx |= CUSTOM_ATTR_ASSEMBLY;
+ idx |= MONO_CUSTOM_ATTR_ASSEMBLY;
break;
case MONO_TABLE_MODULE:
- idx |= CUSTOM_ATTR_MODULE;
+ idx |= MONO_CUSTOM_ATTR_MODULE;
break;
case MONO_TABLE_PROPERTY:
- idx |= CUSTOM_ATTR_PROPERTY;
+ idx |= MONO_CUSTOM_ATTR_PROPERTY;
break;
case MONO_TABLE_EVENT:
- idx |= CUSTOM_ATTR_EVENT;
+ idx |= MONO_CUSTOM_ATTR_EVENT;
break;
case MONO_TABLE_FIELD:
- idx |= CUSTOM_ATTR_FIELDDEF;
+ idx |= MONO_CUSTOM_ATTR_FIELDDEF;
break;
case MONO_TABLE_METHOD:
- idx |= CUSTOM_ATTR_METHODDEF;
+ idx |= MONO_CUSTOM_ATTR_METHODDEF;
break;
case MONO_TABLE_PARAM:
- idx |= CUSTOM_ATTR_PARAMDEF;
+ idx |= MONO_CUSTOM_ATTR_PARAMDEF;
break;
default:
g_print ("Missing custom attr get support for token 0x%08x\n", token);
mono_metadata_decode_row (ca, i, cols, MONO_CUSTOM_ATTR_SIZE);
if (cols [MONO_CUSTOM_ATTR_PARENT] != idx)
continue;
- mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> CUSTOM_ATTR_TYPE_BITS;
- switch (cols [MONO_CUSTOM_ATTR_TYPE] & CUSTOM_ATTR_TYPE_MASK) {
- case CUSTOM_ATTR_TYPE_METHODDEF:
+ mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
+ switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
+ case MONO_CUSTOM_ATTR_TYPE_METHODDEF:
mtoken |= MONO_TOKEN_METHOD_DEF;
break;
- case CUSTOM_ATTR_TYPE_MEMBERREF:
+ case MONO_CUSTOM_ATTR_TYPE_MEMBERREF:
mtoken |= MONO_TOKEN_MEMBER_REF;
break;
default:
+
+Tue Jun 22 16:32:03 CEST 2004 Paolo Molaro <lupus@ximian.com>
+
+ * *.c, *.h: avoid namespace pollution in public headers.
+
2004-06-21 Martin Baulig <martin@ximian.com>
* exception.c (mono_get_exception_security): It's in
name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
- idx = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
- switch (cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK) {
- case RESOLTION_SCOPE_MODULE:
+ idx = cols [MONO_TYPEREF_SCOPE] >> MONO_RESOLTION_SCOPE_BITS;
+ switch (cols [MONO_TYPEREF_SCOPE] & MONO_RESOLTION_SCOPE_MASK) {
+ case MONO_RESOLTION_SCOPE_MODULE:
if (!idx)
g_error ("null ResolutionScope not yet handled");
/* a typedef in disguise */
return mono_class_from_name (image, nspace, name);
- case RESOLTION_SCOPE_MODULEREF:
+ case MONO_RESOLTION_SCOPE_MODULEREF:
return mono_class_from_name (image->modules [idx - 1], nspace, name);
- case RESOLTION_SCOPE_TYPEREF: {
+ case MONO_RESOLTION_SCOPE_TYPEREF: {
MonoClass *enclosing = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | idx);
GList *tmp;
mono_class_init (enclosing);
g_warning ("TypeRef ResolutionScope not yet handled (%d)", idx);
return NULL;
}
- case RESOLTION_SCOPE_ASSEMBLYREF:
+ case MONO_RESOLTION_SCOPE_ASSEMBLYREF:
break;
}
mono_metadata_decode_row (t, idx - 1, cols, MONO_EXP_TYPE_SIZE);
impl = cols [MONO_EXP_TYPE_IMPLEMENTATION];
- if ((impl & IMPLEMENTATION_MASK) == IMPLEMENTATION_FILE) {
- loaded_image = mono_assembly_load_module (image->assembly, impl >> IMPLEMENTATION_BITS);
+ if ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE) {
+ loaded_image = mono_assembly_load_module (image->assembly, impl >> MONO_IMPLEMENTATION_BITS);
if (!loaded_image)
return NULL;
class = mono_class_from_name (loaded_image, name_space, name);
* this code should only be called after obtaining the
* ResourceInfo and handling the other cases.
*/
- g_assert ((impl & IMPLEMENTATION_MASK) == IMPLEMENTATION_FILE);
- file_idx = impl >> IMPLEMENTATION_BITS;
+ g_assert ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE);
+ file_idx = impl >> MONO_IMPLEMENTATION_BITS;
module = mono_image_load_file_for_image (assembly->assembly->image, file_idx);
if (!module)
info->location = RESOURCE_LOCATION_EMBEDDED | RESOURCE_LOCATION_IN_MANIFEST;
}
else {
- switch (cols [MONO_MANIFEST_IMPLEMENTATION] & IMPLEMENTATION_MASK) {
- case IMPLEMENTATION_FILE:
- i = cols [MONO_MANIFEST_IMPLEMENTATION] >> IMPLEMENTATION_BITS;
+ switch (cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) {
+ case MONO_IMPLEMENTATION_FILE:
+ i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE);
val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]);
info->location = RESOURCE_LOCATION_EMBEDDED;
break;
- case IMPLEMENTATION_ASSEMBLYREF:
- i = cols [MONO_MANIFEST_IMPLEMENTATION] >> IMPLEMENTATION_BITS;
+ case MONO_IMPLEMENTATION_ASSEMBLYREF:
+ i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
info->assembly = mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]);
/* Obtain info recursively */
info->location |= RESOURCE_LOCATION_ANOTHER_ASSEMBLY;
break;
- case IMPLEMENTATION_EXP_TYPE:
+ case MONO_IMPLEMENTATION_EXP_TYPE:
g_assert_not_reached ();
break;
}
}
mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
- nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
- class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
+ nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS;
+ class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
/* we may want to check the signature here... */
switch (class) {
- case MEMBERREF_PARENT_TYPEREF:
+ case MONO_MEMBERREF_PARENT_TYPEREF:
klass = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | nindex);
if (!klass) {
g_warning ("Missing field %s in typeref index %d", fname, nindex);
if (retklass)
*retklass = klass;
return mono_class_get_field_from_name (klass, fname);
- case MEMBERREF_PARENT_TYPESPEC: {
+ case MONO_MEMBERREF_PARENT_TYPESPEC: {
/*guint32 bcols [MONO_TYPESPEC_SIZE];
guint32 len;
MonoType *type;
const char *ptr;
mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, 3);
- nindex = cols [MONO_MEMBERREF_CLASS] >> MEMBERREF_PARENT_BITS;
- class = cols [MONO_MEMBERREF_CLASS] & MEMBERREF_PARENT_MASK;
+ nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS;
+ class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
/*g_print ("methodref: 0x%x 0x%x %s\n", class, nindex,
mono_metadata_string_heap (m, cols [MONO_MEMBERREF_NAME]));*/
sig = mono_metadata_parse_method_signature (image, 0, ptr, NULL);
switch (class) {
- case MEMBERREF_PARENT_TYPEREF:
+ case MONO_MEMBERREF_PARENT_TYPEREF:
klass = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | nindex);
if (!klass) {
g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
mono_metadata_free_method_signature (sig);
return method;
- case MEMBERREF_PARENT_TYPESPEC: {
+ case MONO_MEMBERREF_PARENT_TYPESPEC: {
guint32 bcols [MONO_TYPESPEC_SIZE];
guint32 len;
MonoType *type;
g_assert_not_reached ();
break;
}
- case MEMBERREF_PARENT_TYPEDEF:
+ case MONO_MEMBERREF_PARENT_TYPEDEF:
klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | nindex);
if (!klass) {
g_warning ("Missing method %s in assembly %s typedef index %d", mname, image->name, nindex);
g_warning ("Missing method %s in assembly %s typeref index %d", mname, image->name, nindex);
mono_metadata_free_method_signature (sig);
return method;
- case MEMBERREF_PARENT_METHODDEF:
+ case MONO_MEMBERREF_PARENT_METHODDEF:
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | nindex, NULL);
return method;
default:
mono_metadata_decode_row (&tables [MONO_TABLE_METHODSPEC], idx - 1, cols, MONO_METHODSPEC_SIZE);
token = cols [MONO_METHODSPEC_METHOD];
- if ((token & METHODDEFORREF_MASK) == METHODDEFORREF_METHODDEF)
- token = MONO_TOKEN_METHOD_DEF | (token >> METHODDEFORREF_BITS);
+ if ((token & MONO_METHODDEFORREF_MASK) == MONO_METHODDEFORREF_METHODDEF)
+ token = MONO_TOKEN_METHOD_DEF | (token >> MONO_METHODDEFORREF_BITS);
else
- token = MONO_TOKEN_MEMBER_REF | (token >> METHODDEFORREF_BITS);
+ token = MONO_TOKEN_MEMBER_REF | (token >> MONO_METHODDEFORREF_BITS);
method = mono_get_method (image, token, NULL);
guint32 index = mono_metadata_token_index (token);
tdef = &meta->tables [MONO_TABLE_CONSTANT];
- index <<= HASCONSTANT_BITS;
+ index <<= MONO_HASCONSTANT_BITS;
switch (mono_metadata_token_table (token)) {
case MONO_TABLE_FIELD:
- index |= HASCONSTANT_FIEDDEF;
+ index |= MONO_HASCONSTANT_FIEDDEF;
break;
case MONO_TABLE_PARAM:
- index |= HASCONSTANT_PARAM;
+ index |= MONO_HASCONSTANT_PARAM;
break;
case MONO_TABLE_PROPERTY:
- index |= HASCONSTANT_PROPERTY;
+ index |= MONO_HASCONSTANT_PROPERTY;
break;
default:
g_warning ("Not a valid token for the constant table: 0x%08x", token);
loc.t = msemt;
loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION;
- loc.idx = ((index + 1) << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_EVENT; /* Method association coded index */
+ loc.idx = ((index + 1) << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT; /* Method association coded index */
if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator))
return 0;
loc.t = msemt;
loc.col_idx = MONO_METHOD_SEMA_ASSOCIATION;
- loc.idx = ((index + 1) << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_PROPERTY; /* Method association coded index */
+ loc.idx = ((index + 1) << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY; /* Method association coded index */
if (!bsearch (&loc, msemt->base, msemt->rows, msemt->row_size, table_locator))
return 0;
loc.t = tdef;
loc.col_idx = MONO_IMPLMAP_MEMBER;
- loc.idx = ((method_idx + 1) << MEMBERFORWD_BITS) | MEMBERFORWD_METHODDEF;
+ loc.idx = ((method_idx + 1) << MONO_MEMBERFORWD_BITS) | MONO_MEMBERFORWD_METHODDEF;
if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator))
return 0;
loc.t = tdef;
loc.col_idx = MONO_FIELD_MARSHAL_PARENT;
- loc.idx = ((idx + 1) << HAS_FIELD_MARSHAL_BITS) | (is_field? HAS_FIELD_MARSHAL_FIELDSREF: HAS_FIELD_MARSHAL_PARAMDEF);
+ loc.idx = ((idx + 1) << MONO_HAS_FIELD_MARSHAL_BITS) | (is_field? MONO_HAS_FIELD_MARSHAL_FIELDSREF: MONO_HAS_FIELD_MARSHAL_PARAMDEF);
if (!bsearch (&loc, tdef->base, tdef->rows, tdef->row_size, table_locator))
return NULL;
static MonoMethod*
method_from_method_def_or_ref (MonoImage *m, guint32 tok)
{
- guint32 idx = tok >> METHODDEFORREF_BITS;
- switch (tok & METHODDEFORREF_MASK) {
- case METHODDEFORREF_METHODDEF:
+ guint32 idx = tok >> MONO_METHODDEFORREF_BITS;
+ switch (tok & MONO_METHODDEFORREF_MASK) {
+ case MONO_METHODDEFORREF_METHODDEF:
return mono_get_method (m, MONO_TOKEN_METHOD_DEF | idx, NULL);
- case METHODDEFORREF_METHODREF:
+ case MONO_METHODDEFORREF_METHODREF:
return mono_get_method (m, MONO_TOKEN_MEMBER_REF | idx, NULL);
}
g_assert_not_reached ();
/*
* idx is the table index of the object
- * type is one of CUSTOM_ATTR_*
+ * type is one of MONO_CUSTOM_ATTR_*
*/
static void
mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, MonoArray *cattrs)
table->rows += count;
alloc_table (table, table->rows);
values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
- idx <<= CUSTOM_ATTR_BITS;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
idx |= type;
for (i = 0; i < count; ++i) {
cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
values [MONO_CUSTOM_ATTR_PARENT] = idx;
token = mono_image_create_token (assembly, (MonoObject*)cattr->ctor);
type = mono_metadata_token_index (token);
- type <<= CUSTOM_ATTR_TYPE_BITS;
+ type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
switch (mono_metadata_token_table (token)) {
case MONO_TABLE_METHOD:
- type |= CUSTOM_ATTR_TYPE_METHODDEF;
+ type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
break;
case MONO_TABLE_MEMBERREF:
- type |= CUSTOM_ATTR_TYPE_MEMBERREF;
+ type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
break;
default:
g_warning ("got wrong token in custom attr");
values = table->values + table->next_idx * MONO_DECL_SECURITY_SIZE;
idx = mono_metadata_token_index (parent_token);
- idx <<= HAS_DECL_SECURITY_BITS;
+ idx <<= MONO_HAS_DECL_SECURITY_BITS;
switch (mono_metadata_token_table (parent_token)) {
case MONO_TABLE_TYPEDEF:
- idx |= HAS_DECL_SECURITY_TYPEDEF;
+ idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
break;
case MONO_TABLE_METHOD:
- idx |= HAS_DECL_SECURITY_METHODDEF;
+ idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
break;
case MONO_TABLE_ASSEMBLY:
- idx |= HAS_DECL_SECURITY_ASSEMBLY;
+ idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
break;
default:
g_assert_not_reached ();
mtable->rows++;
alloc_table (mtable, mtable->rows);
mvalues = mtable->values + mtable->rows * MONO_FIELD_MARSHAL_SIZE;
- mvalues [MONO_FIELD_MARSHAL_PARENT] = (table->next_idx << HAS_FIELD_MARSHAL_BITS) | HAS_FIELD_MARSHAL_PARAMDEF;
+ mvalues [MONO_FIELD_MARSHAL_PARENT] = (table->next_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_PARAMDEF;
mvalues [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, pb->marshal_info);
}
pb->table_idx = table->next_idx++;
alloc_table (table, table->rows);
values = table->values + table->rows * MONO_METHODIMPL_SIZE;
values [MONO_METHODIMPL_CLASS] = tb->table_idx;
- values [MONO_METHODIMPL_BODY] = METHODDEFORREF_METHODDEF | (mb->table_idx << METHODDEFORREF_BITS);
+ values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
tok = mono_image_create_token (assembly, (MonoObject*)mb->override_method);
switch (mono_metadata_token_table (tok)) {
case MONO_TABLE_MEMBERREF:
- tok = (mono_metadata_token_index (tok) << METHODDEFORREF_BITS ) | METHODDEFORREF_METHODREF;
+ tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
break;
case MONO_TABLE_METHOD:
- tok = (mono_metadata_token_index (tok) << METHODDEFORREF_BITS ) | METHODDEFORREF_METHODDEF;
+ tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
break;
default:
g_assert_not_reached ();
table->rows ++;
alloc_table (table, table->rows);
values = table->values + table->rows * MONO_CONSTANT_SIZE;
- values [MONO_CONSTANT_PARENT] = HASCONSTANT_FIEDDEF | (fb->table_idx << HASCONSTANT_BITS);
+ values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_FIEDDEF | (fb->table_idx << MONO_HASCONSTANT_BITS);
values [MONO_CONSTANT_VALUE] = encode_constant (assembly, fb->def_value, &field_type);
values [MONO_CONSTANT_TYPE] = field_type;
values [MONO_CONSTANT_PADDING] = 0;
table->rows ++;
alloc_table (table, table->rows);
values = table->values + table->rows * MONO_FIELD_MARSHAL_SIZE;
- values [MONO_FIELD_MARSHAL_PARENT] = (fb->table_idx << HAS_FIELD_MARSHAL_BITS) | HAS_FIELD_MARSHAL_FIELDSREF;
+ values [MONO_FIELD_MARSHAL_PARENT] = (fb->table_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_FIELDSREF;
values [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, fb->marshal_info);
}
}
values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_GETTER;
values [MONO_METHOD_SEMA_METHOD] = pb->get_method->table_idx;
- values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_PROPERTY;
+ values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
}
if (pb->set_method) {
semaidx = table->next_idx ++;
values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_SETTER;
values [MONO_METHOD_SEMA_METHOD] = pb->set_method->table_idx;
- values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_PROPERTY;
+ values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
}
}
values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_ADD_ON;
values [MONO_METHOD_SEMA_METHOD] = eb->add_method->table_idx;
- values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_EVENT;
+ values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
}
if (eb->remove_method) {
semaidx = table->next_idx ++;
values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_REMOVE_ON;
values [MONO_METHOD_SEMA_METHOD] = eb->remove_method->table_idx;
- values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_EVENT;
+ values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
}
if (eb->raise_method) {
semaidx = table->next_idx ++;
values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_FIRE;
values [MONO_METHOD_SEMA_METHOD] = eb->raise_method->table_idx;
- values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << HAS_SEMANTICS_BITS) | HAS_SEMANTICS_EVENT;
+ values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
}
}
alloc_table (table, table->rows);
values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
- owner <<= CUSTOM_ATTR_BITS;
- owner |= CUSTOM_ATTR_GENERICPAR;
+ owner <<= MONO_CUSTOM_ATTR_BITS;
+ owner |= MONO_CUSTOM_ATTR_GENERICPAR;
values [MONO_CUSTOM_ATTR_PARENT] = owner;
token = mono_image_get_methodref_token (assembly, NewConstraintAttr_ctor);
type = mono_metadata_token_index (token);
- type <<= CUSTOM_ATTR_TYPE_BITS;
+ type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
switch (mono_metadata_token_table (token)) {
case MONO_TABLE_METHOD:
- type |= CUSTOM_ATTR_TYPE_METHODDEF;
+ type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
break;
case MONO_TABLE_MEMBERREF:
- type |= CUSTOM_ATTR_TYPE_MEMBERREF;
+ type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
break;
default:
g_warning ("got wrong token in custom attr");
values = table->values + token * MONO_MODULEREF_SIZE;
values [MONO_MODULEREF_NAME] = string_heap_insert (&assembly->sheap, image->module_name);
- token <<= RESOLTION_SCOPE_BITS;
- token |= RESOLTION_SCOPE_MODULEREF;
+ token <<= MONO_RESOLTION_SCOPE_BITS;
+ token |= MONO_RESOLTION_SCOPE_MODULEREF;
g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
return token;
} else {
values [MONO_ASSEMBLYREF_PUBLIC_KEY] = 0;
}
- token <<= RESOLTION_SCOPE_BITS;
- token |= RESOLTION_SCOPE_ASSEMBLYREF;
+ token <<= MONO_RESOLTION_SCOPE_BITS;
+ token |= MONO_RESOLTION_SCOPE_ASSEMBLYREF;
g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
return token;
}
values [MONO_TYPESPEC_SIGNATURE] = token;
}
- token = TYPEDEFORREF_TYPESPEC | (table->next_idx << TYPEDEFORREF_BITS);
+ token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
table->next_idx ++;
return token;
if ((klass->image == &assembly->image) &&
(type->type != MONO_TYPE_VAR) && (type->type != MONO_TYPE_MVAR)) {
MonoReflectionTypeBuilder *tb = klass->reflection_info;
- token = TYPEDEFORREF_TYPEDEF | (tb->table_idx << TYPEDEFORREF_BITS);
+ token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), klass->reflection_info);
return token;
}
if (klass->nested_in) {
enclosing = mono_image_typedef_or_ref (assembly, &klass->nested_in->byval_arg);
/* get the typeref idx of the enclosing type */
- enclosing >>= TYPEDEFORREF_BITS;
- scope = (enclosing << RESOLTION_SCOPE_BITS) | RESOLTION_SCOPE_TYPEREF;
+ enclosing >>= MONO_TYPEDEFORREF_BITS;
+ scope = (enclosing << MONO_RESOLTION_SCOPE_BITS) | MONO_RESOLTION_SCOPE_TYPEREF;
} else {
scope = resolution_scope_from_image (assembly, klass->image);
}
values [MONO_TYPEREF_NAME] = string_heap_insert (&assembly->sheap, klass->name);
values [MONO_TYPEREF_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
}
- token = TYPEDEFORREF_TYPEREF | (table->next_idx << TYPEDEFORREF_BITS); /* typeref */
+ token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
table->next_idx ++;
mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), klass->reflection_info);
guint32 parent;
parent = mono_image_typedef_or_ref (assembly, type);
- switch (parent & TYPEDEFORREF_MASK) {
- case TYPEDEFORREF_TYPEREF:
- pclass = MEMBERREF_PARENT_TYPEREF;
+ switch (parent & MONO_TYPEDEFORREF_MASK) {
+ case MONO_TYPEDEFORREF_TYPEREF:
+ pclass = MONO_MEMBERREF_PARENT_TYPEREF;
break;
- case TYPEDEFORREF_TYPESPEC:
- pclass = MEMBERREF_PARENT_TYPESPEC;
+ case MONO_TYPEDEFORREF_TYPESPEC:
+ pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
break;
- case TYPEDEFORREF_TYPEDEF:
- pclass = MEMBERREF_PARENT_TYPEDEF;
+ case MONO_TYPEDEFORREF_TYPEDEF:
+ pclass = MONO_MEMBERREF_PARENT_TYPEDEF;
break;
default:
g_warning ("unknown typeref or def token 0x%08x for %s", parent, name);
return 0;
}
/* extract the index */
- parent >>= TYPEDEFORREF_BITS;
+ parent >>= MONO_TYPEDEFORREF_BITS;
table = &assembly->tables [MONO_TABLE_MEMBERREF];
if (assembly->save) {
alloc_table (table, table->rows + 1);
values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
- values [MONO_MEMBERREF_CLASS] = pclass | (parent << MEMBERREF_PARENT_BITS);
+ values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
values [MONO_MEMBERREF_SIGNATURE] = sig;
}
switch (mono_metadata_token_table (mtoken)) {
case MONO_TABLE_MEMBERREF:
- mtoken = (mono_metadata_token_index (mtoken) << METHODDEFORREF_BITS) | METHODDEFORREF_METHODREF;
+ mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
break;
case MONO_TABLE_METHOD:
- mtoken = (mono_metadata_token_index (mtoken) << METHODDEFORREF_BITS) | METHODDEFORREF_METHODDEF;
+ mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
break;
default:
g_assert_not_reached ();
values [MONO_TYPESPEC_SIGNATURE] = token;
}
- token = TYPEDEFORREF_TYPESPEC | (table->next_idx << TYPEDEFORREF_BITS);
+ token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
g_hash_table_insert (assembly->typespec, tb->type.type, GUINT_TO_POINTER(token));
table->next_idx ++;
return token;
sig = fieldref_encode_signature (assembly, fb->type->type);
parent = create_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb);
- g_assert ((parent & TYPEDEFORREF_MASK) == TYPEDEFORREF_TYPESPEC);
+ g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC);
- pclass = MEMBERREF_PARENT_TYPESPEC;
- parent >>= TYPEDEFORREF_BITS;
+ pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
+ parent >>= MONO_TYPEDEFORREF_BITS;
table = &assembly->tables [MONO_TABLE_MEMBERREF];
if (assembly->save) {
alloc_table (table, table->rows + 1);
values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
- values [MONO_MEMBERREF_CLASS] = pclass | (parent << MEMBERREF_PARENT_BITS);
+ values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
values [MONO_MEMBERREF_SIGNATURE] = sig;
}
pb = mono_array_get (pinfo, MonoReflectionParamBuilder *, i);
if (!pb)
continue;
- mono_image_add_cattrs (assembly, pb->table_idx, CUSTOM_ATTR_PARAMDEF, pb->cattrs);
+ mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PARAMDEF, pb->cattrs);
}
}
type_add_cattrs (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb) {
int i;
- mono_image_add_cattrs (assembly, tb->table_idx, CUSTOM_ATTR_TYPEDEF, tb->cattrs);
+ mono_image_add_cattrs (assembly, tb->table_idx, MONO_CUSTOM_ATTR_TYPEDEF, tb->cattrs);
if (tb->fields) {
for (i = 0; i < tb->num_fields; ++i) {
MonoReflectionFieldBuilder* fb;
fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i);
- mono_image_add_cattrs (assembly, fb->table_idx, CUSTOM_ATTR_FIELDDEF, fb->cattrs);
+ mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs);
}
}
if (tb->events) {
for (i = 0; i < mono_array_length (tb->events); ++i) {
MonoReflectionEventBuilder* eb;
eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
- mono_image_add_cattrs (assembly, eb->table_idx, CUSTOM_ATTR_EVENT, eb->cattrs);
+ mono_image_add_cattrs (assembly, eb->table_idx, MONO_CUSTOM_ATTR_EVENT, eb->cattrs);
}
}
if (tb->properties) {
for (i = 0; i < mono_array_length (tb->properties); ++i) {
MonoReflectionPropertyBuilder* pb;
pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
- mono_image_add_cattrs (assembly, pb->table_idx, CUSTOM_ATTR_PROPERTY, pb->cattrs);
+ mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PROPERTY, pb->cattrs);
}
}
if (tb->ctors) {
for (i = 0; i < mono_array_length (tb->ctors); ++i) {
MonoReflectionCtorBuilder* cb;
cb = mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i);
- mono_image_add_cattrs (assembly, cb->table_idx, CUSTOM_ATTR_METHODDEF, cb->cattrs);
+ mono_image_add_cattrs (assembly, cb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, cb->cattrs);
params_add_cattrs (assembly, cb->pinfo);
}
}
for (i = 0; i < tb->num_methods; ++i) {
MonoReflectionMethodBuilder* mb;
mb = mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
- mono_image_add_cattrs (assembly, mb->table_idx, CUSTOM_ATTR_METHODDEF, mb->cattrs);
+ mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs);
params_add_cattrs (assembly, mb->pinfo);
}
}
module_add_cattrs (MonoDynamicImage *assembly, MonoReflectionModuleBuilder *mb) {
int i;
- mono_image_add_cattrs (assembly, mb->table_idx, CUSTOM_ATTR_MODULE, mb->cattrs);
+ mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_MODULE, mb->cattrs);
/* no types in the module */
if (!mb->types)
values [MONO_EXP_TYPE_FLAGS] = klass->flags;
values [MONO_EXP_TYPE_TYPEDEF] = klass->type_token;
if (klass->nested_in)
- values [MONO_EXP_TYPE_IMPLEMENTATION] = (parent_index << IMPLEMENTATION_BITS) + IMPLEMENTATION_EXP_TYPE;
+ values [MONO_EXP_TYPE_IMPLEMENTATION] = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
else
- values [MONO_EXP_TYPE_IMPLEMENTATION] = (module_index << IMPLEMENTATION_BITS) + IMPLEMENTATION_FILE;
+ values [MONO_EXP_TYPE_IMPLEMENTATION] = (module_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_FILE;
values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
values = table->values + ((i + 1) * MONO_CUSTOM_ATTR_SIZE);
type = values [MONO_CUSTOM_ATTR_TYPE];
- if ((type & CUSTOM_ATTR_TYPE_MASK) == CUSTOM_ATTR_TYPE_METHODDEF) {
- idx = type >> CUSTOM_ATTR_TYPE_BITS;
+ if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
+ idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
ctor = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
g_assert (ctor);
if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
MonoMethod *m = ((MonoReflectionMethod*)ctor)->method;
idx = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->method_to_table_idx, m));
- values [MONO_CUSTOM_ATTR_TYPE] = (idx << CUSTOM_ATTR_TYPE_BITS) | CUSTOM_ATTR_TYPE_METHODDEF;
+ values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
}
}
}
g_free (name);
idx = table->next_idx++;
rsrc->offset = 0;
- idx = IMPLEMENTATION_FILE | (idx << IMPLEMENTATION_BITS);
+ idx = MONO_IMPLEMENTATION_FILE | (idx << MONO_IMPLEMENTATION_BITS);
} else {
char sizebuf [4];
offset = mono_array_length (rsrc->data);
int len = mono_array_length (file_module->resources);
for (j = 0; j < len; ++j) {
MonoReflectionResource* res = (MonoReflectionResource*)mono_array_addr (file_module->resources, MonoReflectionResource, j);
- assembly_add_resource_manifest (file_module, assembly, res, IMPLEMENTATION_FILE | (module_index << IMPLEMENTATION_BITS));
+ assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS));
}
}
}
* table->rows is already set above and in mono_image_fill_module_table.
*/
/* add all the custom attributes at the end, once all the indexes are stable */
- mono_image_add_cattrs (assembly, 1, CUSTOM_ATTR_ASSEMBLY, assemblyb->cattrs);
+ mono_image_add_cattrs (assembly, 1, MONO_CUSTOM_ATTR_ASSEMBLY, assemblyb->cattrs);
module_add_cattrs (assembly, moduleb);
}
parent = mono_image_typedef_or_ref (assembly, &method->klass->byval_arg);
- g_assert ((parent & TYPEDEFORREF_MASK) == MEMBERREF_PARENT_TYPEREF);
- parent >>= TYPEDEFORREF_BITS;
+ g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF);
+ parent >>= MONO_TYPEDEFORREF_BITS;
- parent <<= MEMBERREF_PARENT_BITS;
- parent |= MEMBERREF_PARENT_TYPEREF;
+ parent <<= MONO_MEMBERREF_PARENT_BITS;
+ parent |= MONO_MEMBERREF_PARENT_TYPEREF;
sig_token = method_encode_signature (assembly, sig);
token = mono_image_get_varargs_method_token (
parent = mono_image_create_token (assembly, obj);
g_assert (mono_metadata_token_table (parent) == MONO_TABLE_METHOD);
- parent = mono_metadata_token_index (parent) << MEMBERREF_PARENT_BITS;
- parent |= MEMBERREF_PARENT_METHODDEF;
+ parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
+ parent |= MONO_MEMBERREF_PARENT_METHODDEF;
token = mono_image_get_varargs_method_token (
assembly, parent, mono_string_to_utf8 (rmb.name), sig);
ainfo->image = image;
for (i = 0, tmp = list; i < len; ++i, tmp = tmp->next) {
mono_metadata_decode_row (ca, GPOINTER_TO_UINT (tmp->data), cols, MONO_CUSTOM_ATTR_SIZE);
- mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> CUSTOM_ATTR_TYPE_BITS;
- switch (cols [MONO_CUSTOM_ATTR_TYPE] & CUSTOM_ATTR_TYPE_MASK) {
- case CUSTOM_ATTR_TYPE_METHODDEF:
+ mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
+ switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
+ case MONO_CUSTOM_ATTR_TYPE_METHODDEF:
mtoken |= MONO_TOKEN_METHOD_DEF;
break;
- case CUSTOM_ATTR_TYPE_MEMBERREF:
+ case MONO_CUSTOM_ATTR_TYPE_MEMBERREF:
mtoken |= MONO_TOKEN_MEMBER_REF;
break;
default:
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, method)))
return cinfo;
idx = find_method_index (method);
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_METHODDEF;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_METHODDEF;
return mono_custom_attrs_from_index (method->klass->image, idx);
}
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, klass)))
return cinfo;
idx = mono_metadata_token_index (klass->type_token);
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_TYPEDEF;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_TYPEDEF;
return mono_custom_attrs_from_index (klass->image, idx);
}
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, assembly)))
return cinfo;
idx = 1; /* there is only one assembly */
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_ASSEMBLY;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_ASSEMBLY;
return mono_custom_attrs_from_index (assembly->image, idx);
}
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, image)))
return cinfo;
idx = 1; /* there is only one module */
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_MODULE;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_MODULE;
return mono_custom_attrs_from_index (image, idx);
}
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, property)))
return cinfo;
idx = find_property_index (klass, property);
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_PROPERTY;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_PROPERTY;
return mono_custom_attrs_from_index (klass->image, idx);
}
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, event)))
return cinfo;
idx = find_event_index (klass, event);
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_EVENT;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_EVENT;
return mono_custom_attrs_from_index (klass->image, idx);
}
if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, field)))
return cinfo;
idx = find_field_index (klass, field);
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_FIELDDEF;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_FIELDDEF;
return mono_custom_attrs_from_index (klass->image, idx);
}
if (!found)
return NULL;
idx = i;
- idx <<= CUSTOM_ATTR_BITS;
- idx |= CUSTOM_ATTR_PARAMDEF;
+ idx <<= MONO_CUSTOM_ATTR_BITS;
+ idx |= MONO_CUSTOM_ATTR_PARAMDEF;
return mono_custom_attrs_from_index (image, idx);
}
*/
enum {
- TYPEDEFORREF_TYPEDEF,
- TYPEDEFORREF_TYPEREF,
- TYPEDEFORREF_TYPESPEC,
- TYPEDEFORREF_BITS = 2,
- TYPEDEFORREF_MASK = 3
+ MONO_TYPEDEFORREF_TYPEDEF,
+ MONO_TYPEDEFORREF_TYPEREF,
+ MONO_TYPEDEFORREF_TYPESPEC,
+ MONO_TYPEDEFORREF_BITS = 2,
+ MONO_TYPEDEFORREF_MASK = 3
};
enum {
- HASCONSTANT_FIEDDEF,
- HASCONSTANT_PARAM,
- HASCONSTANT_PROPERTY,
- HASCONSTANT_BITS = 2,
- HASCONSTANT_MASK = 3
+ MONO_HASCONSTANT_FIEDDEF,
+ MONO_HASCONSTANT_PARAM,
+ MONO_HASCONSTANT_PROPERTY,
+ MONO_HASCONSTANT_BITS = 2,
+ MONO_HASCONSTANT_MASK = 3
};
enum {
- CUSTOM_ATTR_METHODDEF,
- CUSTOM_ATTR_FIELDDEF,
- CUSTOM_ATTR_TYPEREF,
- CUSTOM_ATTR_TYPEDEF,
- CUSTOM_ATTR_PARAMDEF,
- CUSTOM_ATTR_INTERFACE,
- CUSTOM_ATTR_MEMBERREF,
- CUSTOM_ATTR_MODULE,
- CUSTOM_ATTR_PERMISSION,
- CUSTOM_ATTR_PROPERTY,
- CUSTOM_ATTR_EVENT,
- CUSTOM_ATTR_SIGNATURE,
- CUSTOM_ATTR_MODULEREF,
- CUSTOM_ATTR_TYPESPEC,
- CUSTOM_ATTR_ASSEMBLY,
- CUSTOM_ATTR_ASSEMBLYREF,
- CUSTOM_ATTR_FILE,
- CUSTOM_ATTR_EXP_TYPE,
- CUSTOM_ATTR_MANIFEST,
- CUSTOM_ATTR_GENERICPAR,
- CUSTOM_ATTR_BITS = 5,
- CUSTOM_ATTR_MASK = 0x1F
+ MONO_CUSTOM_ATTR_METHODDEF,
+ MONO_CUSTOM_ATTR_FIELDDEF,
+ MONO_CUSTOM_ATTR_TYPEREF,
+ MONO_CUSTOM_ATTR_TYPEDEF,
+ MONO_CUSTOM_ATTR_PARAMDEF,
+ MONO_CUSTOM_ATTR_INTERFACE,
+ MONO_CUSTOM_ATTR_MEMBERREF,
+ MONO_CUSTOM_ATTR_MODULE,
+ MONO_CUSTOM_ATTR_PERMISSION,
+ MONO_CUSTOM_ATTR_PROPERTY,
+ MONO_CUSTOM_ATTR_EVENT,
+ MONO_CUSTOM_ATTR_SIGNATURE,
+ MONO_CUSTOM_ATTR_MODULEREF,
+ MONO_CUSTOM_ATTR_TYPESPEC,
+ MONO_CUSTOM_ATTR_ASSEMBLY,
+ MONO_CUSTOM_ATTR_ASSEMBLYREF,
+ MONO_CUSTOM_ATTR_FILE,
+ MONO_CUSTOM_ATTR_EXP_TYPE,
+ MONO_CUSTOM_ATTR_MANIFEST,
+ MONO_CUSTOM_ATTR_GENERICPAR,
+ MONO_CUSTOM_ATTR_BITS = 5,
+ MONO_CUSTOM_ATTR_MASK = 0x1F
};
enum {
- HAS_FIELD_MARSHAL_FIELDSREF,
- HAS_FIELD_MARSHAL_PARAMDEF,
- HAS_FIELD_MARSHAL_BITS = 1,
- HAS_FIELD_MARSHAL_MASK = 1
+ MONO_HAS_FIELD_MARSHAL_FIELDSREF,
+ MONO_HAS_FIELD_MARSHAL_PARAMDEF,
+ MONO_HAS_FIELD_MARSHAL_BITS = 1,
+ MONO_HAS_FIELD_MARSHAL_MASK = 1
};
enum {
- HAS_DECL_SECURITY_TYPEDEF,
- HAS_DECL_SECURITY_METHODDEF,
- HAS_DECL_SECURITY_ASSEMBLY,
- HAS_DECL_SECURITY_BITS = 2,
- HAS_DECL_SECURITY_MASK = 3
+ MONO_HAS_DECL_SECURITY_TYPEDEF,
+ MONO_HAS_DECL_SECURITY_METHODDEF,
+ MONO_HAS_DECL_SECURITY_ASSEMBLY,
+ MONO_HAS_DECL_SECURITY_BITS = 2,
+ MONO_HAS_DECL_SECURITY_MASK = 3
};
enum {
- MEMBERREF_PARENT_TYPEDEF, /* not used */
- MEMBERREF_PARENT_TYPEREF,
- MEMBERREF_PARENT_MODULEREF,
- MEMBERREF_PARENT_METHODDEF,
- MEMBERREF_PARENT_TYPESPEC,
- MEMBERREF_PARENT_BITS = 3,
- MEMBERREF_PARENT_MASK = 7
+ MONO_MEMBERREF_PARENT_TYPEDEF, /* not used */
+ MONO_MEMBERREF_PARENT_TYPEREF,
+ MONO_MEMBERREF_PARENT_MODULEREF,
+ MONO_MEMBERREF_PARENT_METHODDEF,
+ MONO_MEMBERREF_PARENT_TYPESPEC,
+ MONO_MEMBERREF_PARENT_BITS = 3,
+ MONO_MEMBERREF_PARENT_MASK = 7
};
enum {
- HAS_SEMANTICS_EVENT,
- HAS_SEMANTICS_PROPERTY,
- HAS_SEMANTICS_BITS = 1,
- HAS_SEMANTICS_MASK = 1
+ MONO_HAS_SEMANTICS_EVENT,
+ MONO_HAS_SEMANTICS_PROPERTY,
+ MONO_HAS_SEMANTICS_BITS = 1,
+ MONO_HAS_SEMANTICS_MASK = 1
};
enum {
- METHODDEFORREF_METHODDEF,
- METHODDEFORREF_METHODREF,
- METHODDEFORREF_BITS = 1,
- METHODDEFORREF_MASK = 1
+ MONO_METHODDEFORREF_METHODDEF,
+ MONO_METHODDEFORREF_METHODREF,
+ MONO_METHODDEFORREF_BITS = 1,
+ MONO_METHODDEFORREF_MASK = 1
};
enum {
- MEMBERFORWD_FIELDDEF,
- MEMBERFORWD_METHODDEF,
- MEMBERFORWD_BITS = 1,
- MEMBERFORWD_MASK = 1
+ MONO_MEMBERFORWD_FIELDDEF,
+ MONO_MEMBERFORWD_METHODDEF,
+ MONO_MEMBERFORWD_BITS = 1,
+ MONO_MEMBERFORWD_MASK = 1
};
enum {
- IMPLEMENTATION_FILE,
- IMPLEMENTATION_ASSEMBLYREF,
- IMPLEMENTATION_EXP_TYPE,
- IMPLEMENTATION_BITS = 2,
- IMPLEMENTATION_MASK = 3
+ MONO_IMPLEMENTATION_FILE,
+ MONO_IMPLEMENTATION_ASSEMBLYREF,
+ MONO_IMPLEMENTATION_EXP_TYPE,
+ MONO_IMPLEMENTATION_BITS = 2,
+ MONO_IMPLEMENTATION_MASK = 3
};
enum {
- CUSTOM_ATTR_TYPE_TYPEREF, /* not used */
- CUSTOM_ATTR_TYPE_TYPEDEF, /* not used */
- CUSTOM_ATTR_TYPE_METHODDEF,
- CUSTOM_ATTR_TYPE_MEMBERREF,
- CUSTOM_ATTR_TYPE_STRING, /* not used */
- CUSTOM_ATTR_TYPE_BITS = 3,
- CUSTOM_ATTR_TYPE_MASK = 7
+ MONO_CUSTOM_ATTR_TYPE_TYPEREF, /* not used */
+ MONO_CUSTOM_ATTR_TYPE_TYPEDEF, /* not used */
+ MONO_CUSTOM_ATTR_TYPE_METHODDEF,
+ MONO_CUSTOM_ATTR_TYPE_MEMBERREF,
+ MONO_CUSTOM_ATTR_TYPE_STRING, /* not used */
+ MONO_CUSTOM_ATTR_TYPE_BITS = 3,
+ MONO_CUSTOM_ATTR_TYPE_MASK = 7
};
enum {
- RESOLTION_SCOPE_MODULE,
- RESOLTION_SCOPE_MODULEREF,
- RESOLTION_SCOPE_ASSEMBLYREF,
- RESOLTION_SCOPE_TYPEREF,
- RESOLTION_SCOPE_BITS = 2,
- RESOLTION_SCOPE_MASK = 3
+ MONO_RESOLTION_SCOPE_MODULE,
+ MONO_RESOLTION_SCOPE_MODULEREF,
+ MONO_RESOLTION_SCOPE_ASSEMBLYREF,
+ MONO_RESOLTION_SCOPE_TYPEREF,
+ MONO_RESOLTION_SCOPE_BITS = 2,
+ MONO_RESOLTION_SCOPE_MASK = 3
};
enum {
#endif /* __MONO_METADATA_ROW_INDEXES_H__ */
+
ADD_ERROR (list, g_strdup_printf ("Type 0x%x is invalid in Constant row %d", cols [MONO_CONSTANT_TYPE], i + 1));
}
if (level & MONO_VERIFY_ERROR) {
- value = cols [MONO_CONSTANT_PARENT] >> HASCONSTANT_BITS;
- switch (cols [MONO_CONSTANT_PARENT] & HASCONSTANT_MASK) {
- case HASCONSTANT_FIEDDEF:
+ value = cols [MONO_CONSTANT_PARENT] >> MONO_HASCONSTANT_BITS;
+ switch (cols [MONO_CONSTANT_PARENT] & MONO_HASCONSTANT_MASK) {
+ case MONO_HASCONSTANT_FIEDDEF:
if (value > image->tables [MONO_TABLE_FIELD].rows)
ADD_ERROR (list, g_strdup_printf ("Parent (field) is invalid in Constant row %d", i + 1));
break;
- case HASCONSTANT_PARAM:
+ case MONO_HASCONSTANT_PARAM:
if (value > image->tables [MONO_TABLE_PARAM].rows)
ADD_ERROR (list, g_strdup_printf ("Parent (param) is invalid in Constant row %d", i + 1));
break;
- case HASCONSTANT_PROPERTY:
+ case MONO_HASCONSTANT_PROPERTY:
if (value > image->tables [MONO_TABLE_PROPERTY].rows)
ADD_ERROR (list, g_strdup_printf ("Parent (property) is invalid in Constant row %d", i + 1));
break;
}
if (level & MONO_VERIFY_ERROR && cols [MONO_EVENT_TYPE]) {
- value = cols [MONO_EVENT_TYPE] >> TYPEDEFORREF_BITS;
- switch (cols [MONO_EVENT_TYPE] & TYPEDEFORREF_MASK) {
- case TYPEDEFORREF_TYPEDEF:
+ value = cols [MONO_EVENT_TYPE] >> MONO_TYPEDEFORREF_BITS;
+ switch (cols [MONO_EVENT_TYPE] & MONO_TYPEDEFORREF_MASK) {
+ case MONO_TYPEDEFORREF_TYPEDEF:
if (!value || value > image->tables [MONO_TABLE_TYPEDEF].rows)
ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
break;
- case TYPEDEFORREF_TYPEREF:
+ case MONO_TYPEDEFORREF_TYPEREF:
if (!value || value > image->tables [MONO_TABLE_TYPEREF].rows)
ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
break;
- case TYPEDEFORREF_TYPESPEC:
+ case MONO_TYPEDEFORREF_TYPESPEC:
if (!value || value > image->tables [MONO_TABLE_TYPESPEC].rows)
ADD_ERROR (list, g_strdup_printf ("Type invalid in Event row %d", i + 1));
break;
t = mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
token = mono_metadata_token_index (class->type_token);
- token <<= TYPEDEFORREF_BITS;
- token |= TYPEDEFORREF_TYPEDEF;
+ token <<= MONO_TYPEDEFORREF_BITS;
+ token |= MONO_TYPEDEFORREF_TYPEDEF;
/* use a subgraph? */
for (i = 0; i < mono_table_info_get_rows (t); ++i) {
fprintf (output, "%s", graph_properties);
/* TODO: handle inetrface defined in one image and class defined in another. */
token = mono_metadata_token_index (class->type_token);
- token <<= TYPEDEFORREF_BITS;
- token |= TYPEDEFORREF_TYPEDEF;
+ token <<= MONO_TYPEDEFORREF_BITS;
+ token |= MONO_TYPEDEFORREF_TYPEDEF;
for (i = 0; i < mono_table_info_get_rows (intf); ++i) {
mono_metadata_decode_row (intf, i, cols, MONO_INTERFACEIMPL_SIZE);
/*g_print ("index: %d [%d implements %d]\n", index, cols [MONO_INTERFACEIMPL_CLASS], cols [MONO_INTERFACEIMPL_INTERFACE]);*/
projects / mono.git / commitdiff