Fri May 31 15:58:22 CEST 2002 Paolo Molaro <lupus@ximian.com>

[mono.git] / mono / metadata / image.c

diff --git a/mono/metadata/image.c b/mono/metadata/image.c
index 9f46067a5d4b21e4b7417e6521af232b4a084070..018d5c3a7eadf8a7c990fa1650420f52d01e9032 100644 (file)
--- a/mono/metadata/image.c
+++ b/mono/metadata/image.c
@@ -21,6 +21,7 @@
 #include "rawbuffer.h"
 #include "mono-endian.h"
 #include "private.h"
+#include "tabledefs.h"
 
 #define INVALID_ADDRESS 0xffffffff
 
@@ -266,23 +267,23 @@ load_metadata_ptrs (MonoImage *image, MonoCLIImageInfo *iinfo)
 
        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 {
@@ -302,8 +303,8 @@ load_metadata_ptrs (MonoImage *image, MonoCLIImageInfo *iinfo)
 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;
@@ -314,7 +315,7 @@ load_tables (MonoImage *image)
        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){
@@ -332,7 +333,7 @@ load_tables (MonoImage *image)
        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;
@@ -348,29 +349,34 @@ load_metadata (MonoImage *image, MonoCLIImageInfo *iinfo)
 }
 
 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;
@@ -379,7 +385,7 @@ do_mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
        int n;
 
        image = g_new0 (MonoImage, 1);
-       image->f = fopen (fname, "r");
+       image->f = fopen (fname, "rb");
        image->name = g_strdup (fname);
        iinfo = g_new0 (MonoCLIImageInfo, 1);
        image->image_info = iinfo;
@@ -387,7 +393,7 @@ do_mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
        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;
                
@@ -509,7 +515,9 @@ do_mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
 
        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));
 
@@ -523,6 +531,13 @@ invalid_image:
                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
@@ -532,7 +547,7 @@ invalid_image:
  * 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;
        
@@ -553,7 +568,9 @@ mono_image_open (const char *fname, enum MonoImageOpenStatus *status)
        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;
 }
 
@@ -620,7 +637,7 @@ mono_image_close (MonoImage *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: