#include "rawbuffer.h"
#include "mono-endian.h"
#include "private.h"
+#include "tabledefs.h"
#define INVALID_ADDRESS 0xffffffff
for (i = 0; i < streams; i++){
if (strncmp (ptr + 8, "#~", 3) == 0){
- image->heap_tables.offset = read32 (ptr);
+ image->heap_tables.data = image->raw_metadata + read32 (ptr);
image->heap_tables.size = read32 (ptr + 4);
ptr += 8 + 3;
} else if (strncmp (ptr + 8, "#Strings", 9) == 0){
- image->heap_strings.offset = read32 (ptr);
+ image->heap_strings.data = image->raw_metadata + read32 (ptr);
image->heap_strings.size = read32 (ptr + 4);
ptr += 8 + 9;
} else if (strncmp (ptr + 8, "#US", 4) == 0){
- image->heap_us.offset = read32 (ptr);
+ image->heap_us.data = image->raw_metadata + read32 (ptr);
image->heap_us.size = read32 (ptr + 4);
ptr += 8 + 4;
} else if (strncmp (ptr + 8, "#Blob", 6) == 0){
- image->heap_blob.offset = read32 (ptr);
+ image->heap_blob.data = image->raw_metadata + read32 (ptr);
image->heap_blob.size = read32 (ptr + 4);
ptr += 8 + 6;
} else if (strncmp (ptr + 8, "#GUID", 6) == 0){
- image->heap_guid.offset = read32 (ptr);
+ image->heap_guid.data = image->raw_metadata + read32 (ptr);
image->heap_guid.size = read32 (ptr + 4);
ptr += 8 + 6;
} else {
static gboolean
load_tables (MonoImage *image)
{
- char *heap_tables = image->raw_metadata + image->heap_tables.offset;
- guint32 *rows;
+ const char *heap_tables = image->heap_tables.data;
+ const guint32 *rows;
guint64 valid_mask;
int valid = 0, table;
int heap_sizes;
image->idx_blob_wide = ((heap_sizes & 0x04) == 4);
valid_mask = read64 (heap_tables + 8);
- rows = (guint32 *) (heap_tables + 24);
+ rows = (const guint32 *) (heap_tables + 24);
for (table = 0; table < 64; table++){
if ((valid_mask & ((guint64) 1 << table)) == 0){
image->tables_base = (heap_tables + 24) + (4 * valid);
/* They must be the same */
- g_assert ((void *) image->tables_base == (void *) rows);
+ g_assert ((const void *) image->tables_base == (const void *) rows);
mono_metadata_compute_table_bases (image);
return TRUE;
}
static void
-load_class_names (MonoImage *image) {
+load_class_names (MonoImage *image)
+{
MonoTableInfo *t = &image->tables [MONO_TABLE_TYPEDEF];
guint32 cols [MONO_TYPEDEF_SIZE];
- const char* name;
+ const char *name;
const char *nspace;
GHashTable *nspace_table;
GHashTable *name_cache = image->name_cache;
- guint32 i;
+ guint32 i, visib;
for (i = 1; i <= t->rows; ++i) {
mono_metadata_decode_row (t, i - 1, cols, MONO_TYPEDEF_SIZE);
+ /* nested types are accessed from the nesting name */
+ visib = cols [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_VISIBILITY_MASK;
+ if (visib > TYPE_ATTRIBUTE_PUBLIC && visib < TYPE_ATTRIBUTE_NESTED_ASSEMBLY)
+ continue;
name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
if (!(nspace_table = g_hash_table_lookup (name_cache, nspace))) {
nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
- g_hash_table_insert (name_cache, nspace, nspace_table);
+ g_hash_table_insert (name_cache, (char *)nspace, (char *)nspace_table);
}
- g_hash_table_insert (nspace_table, name, GUINT_TO_POINTER (i));
+ g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (i));
}
}
static MonoImage *
-do_mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
+do_mono_image_open (const char *fname, MonoImageOpenStatus *status)
{
MonoCLIImageInfo *iinfo;
MonoDotNetHeader *header;
image->method_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
image->class_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
image->name_cache = g_hash_table_new (g_str_hash, g_str_equal);
- image->array_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
+ image->array_cache = g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
header = &iinfo->cli_header;
load_class_names (image);
- image->assembly_name = mono_metadata_string_heap (image,
+ /* modules don't have an assembly table row */
+ if (image->tables [MONO_TABLE_ASSEMBLY].rows)
+ image->assembly_name = mono_metadata_string_heap (image,
mono_metadata_decode_row_col (&image->tables [MONO_TABLE_ASSEMBLY],
0, MONO_ASSEMBLY_NAME));
return NULL;
}
+MonoImage *
+mono_image_loaded (const char *name) {
+ if (loaded_images_hash)
+ return g_hash_table_lookup (loaded_images_hash, name);
+ return NULL;
+}
+
/**
* mono_image_open:
* @fname: filename that points to the module we want to open
* if NULL, then check the value of @status for details on the error
*/
MonoImage *
-mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
+mono_image_open (const char *fname, MonoImageOpenStatus *status)
{
MonoImage *image;
if (!loaded_images_hash)
loaded_images_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (loaded_images_hash, image->name, image);
-
+ if (image->assembly_name)
+ g_hash_table_insert (loaded_images_hash, (char *) image->assembly_name, image);
+
return image;
}
* Returns: a string describing the error
*/
const char *
-mono_image_strerror (enum MonoImageOpenStatus status)
+mono_image_strerror (MonoImageOpenStatus status)
{
switch (status){
case MONO_IMAGE_OK: