2004-05-26 Sebastien Pouliot <sebastien@ximian.com>

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

diff --git a/mono/metadata/image.h b/mono/metadata/image.h
index 6fcb83296227a36f5007e33b0edfeee084823c0f..dd6923f2e40320dfc65224d741e12346e90e3070 100644 (file)
--- a/mono/metadata/image.h
+++ b/mono/metadata/image.h
@@ -3,26 +3,44 @@
 
 #include <stdio.h>
 #include <glib.h>
+#include <gmodule.h>
 
 typedef struct _MonoImage MonoImage;
-typedef struct _MonoImage MonoMetadata;
 
 typedef struct {
+       const char *name;
+       const char *culture;
+       const char *hash_value;
+       const guint8* public_key;
+       const char *public_tok_value;
+       guint32 hash_alg;
+       guint32 hash_len;
+       guint32 flags;
+       guint16 major, minor, build, revision;
+} MonoAssemblyName;
+
+typedef struct {
+       int   ref_count;
+       char *basedir;
+       gboolean in_gac;
+       MonoAssemblyName aname;
+       GModule *aot_module;
        MonoImage *image;
        /* Load files here */
+       gboolean dynamic;
 } MonoAssembly;
 
 typedef struct {
-       guint32  offset;
+       const char* data;
        guint32  size;
 } MonoStreamHeader;
 
 typedef struct {
        guint32   rows, row_size;
-       char     *base;
+       const char *base;
 
        /*
-        * Tables contain up to 9 rows and the possible sizes of the
+        * Tables contain up to 9 columns and the possible sizes of the
         * fields in the documentation are 1, 2 and 4 bytes.  So we
         * can encode in 2 bits the size.
         *
@@ -37,8 +55,15 @@ typedef struct {
 struct _MonoImage {
        int   ref_count;
        FILE *f;
+       /* if f is NULL the image was loaded from raw data */
+       char *raw_data;
+       guint32 raw_data_len;
+       gboolean raw_data_allocated;
        char *name;
-       char *assembly_name;
+       const char *assembly_name;
+       const char *module_name;
+       const char *version;
+       char *guid;
        void *image_info;
 
        char                *raw_metadata;
@@ -51,7 +76,7 @@ struct _MonoImage {
        MonoStreamHeader     heap_guid;
        MonoStreamHeader     heap_tables;
                            
-       char                *tables_base;
+       const char          *tables_base;
 
        MonoTableInfo        tables [64];
 
@@ -63,11 +88,33 @@ struct _MonoImage {
         */
        MonoAssembly **references;
 
+       MonoImage **modules;
+
+       MonoImage **files;
+
+       /*
+        * The Assembly this image was loaded from.
+        */
+       MonoAssembly *assembly;
+
        /*
         * Indexed by method tokens and typedef tokens.
         */
        GHashTable *method_cache;
        GHashTable *class_cache;
+       /*
+        * Indexed by fielddef and memberref tokens
+        */
+       GHashTable *field_cache;
+
+       /* indexed by typespec tokens. */
+       GHashTable *typespec_cache;
+
+       /*
+        * Indexed by MonoGenericInst.
+        */
+       GHashTable *generic_inst_cache;
+
        /*
         * Indexes namespaces to hash tables that map class name to typedef token.
         */
@@ -79,29 +126,77 @@ struct _MonoImage {
         */
        GHashTable *array_cache;
 
+       /*
+        * indexed by MonoMethodSignature 
+        */
+       GHashTable *delegate_begin_invoke_cache;
+       GHashTable *delegate_end_invoke_cache;
+       GHashTable *delegate_invoke_cache;
+
+       /*
+        * indexed by MonoMethod pointers 
+        */
+       GHashTable *runtime_invoke_cache;
+       GHashTable *managed_wrapper_cache;
+       GHashTable *native_wrapper_cache;
+       GHashTable *remoting_invoke_cache;
+       GHashTable *synchronized_cache;
+
+       void *reflection_info;
+
        /*
         * user_info is a public field and is not touched by the
         * metadata engine
         */
        void *user_info;
+
+       /* dll map entries */
+       GHashTable *dll_map;
+
+       /* Whenever this is a dynamically emitted module */
+       gboolean dynamic;
 };
 
-enum MonoImageOpenStatus {
+typedef enum {
        MONO_IMAGE_OK,
        MONO_IMAGE_ERROR_ERRNO,
        MONO_IMAGE_MISSING_ASSEMBLYREF,
        MONO_IMAGE_IMAGE_INVALID
-};
+} MonoImageOpenStatus;
+
+void          mono_images_init    (void);
 
 MonoImage    *mono_image_open     (const char *fname,
-                                  enum MonoImageOpenStatus *status);
+                                  MonoImageOpenStatus *status);
+MonoImage    *mono_image_open_from_data (char *data, guint32 data_len, gboolean need_copy,
+                                         MonoImageOpenStatus *status);
+MonoImage    *mono_image_loaded   (const char *name);
+MonoImage    *mono_image_loaded_by_guid (const char *guid);
+void          mono_image_init     (MonoImage *image);
 void          mono_image_close    (MonoImage *image);
-const char   *mono_image_strerror (enum MonoImageOpenStatus status);
-
+void          mono_image_addref   (MonoImage *image);
+const char   *mono_image_strerror (MonoImageOpenStatus status);
 
 int           mono_image_ensure_section     (MonoImage *image,
                                             const char *section);
 int           mono_image_ensure_section_idx (MonoImage *image,
                                             int section);
-       
+
+guint32       mono_image_get_entry_point    (MonoImage *image);
+const char   *mono_image_get_resource       (MonoImage *image, guint32 offset, guint32 *size);
+MonoImage*    mono_image_load_file_for_image (MonoImage *image, int fileidx);
+
+/* This actually returns a MonoPEResourceDataEntry *, but declaring it
+ * causes an include file loop.
+ */
+gpointer      mono_image_lookup_resource (MonoImage *image, guint32 res_id,
+                                         guint32 lang_id, gunichar2 *name);
+
+const char*   mono_image_get_public_key  (MonoImage *image, guint32 *size);
+const char*   mono_image_get_strong_name (MonoImage *image, guint32 *size);
+guint32       mono_image_strong_name_position (MonoImage *image, guint32 *size);
+void          mono_image_add_to_name_cache (MonoImage *image, 
+                                                                                       const char *nspace, 
+                                                                                       const char *name, guint32 idx);
+
 #endif