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 a176eca78e123b5b4482794caf67e203b75617e4..dd6923f2e40320dfc65224d741e12346e90e3070 100644 (file)
--- a/mono/metadata/image.h
+++ b/mono/metadata/image.h
@@ -3,6 +3,7 @@
 
 #include <stdio.h>
 #include <glib.h>
+#include <gmodule.h>
 
 typedef struct _MonoImage MonoImage;
 
@@ -10,19 +11,23 @@ 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;
-       gint16 major, minor, build, revision;
+       guint16 major, minor, build, revision;
 } MonoAssemblyName;
 
 typedef struct {
        int   ref_count;
        char *basedir;
+       gboolean in_gac;
        MonoAssemblyName aname;
-       
+       GModule *aot_module;
        MonoImage *image;
-       MonoImage **modules;
        /* Load files here */
+       gboolean dynamic;
 } MonoAssembly;
 
 typedef struct {
@@ -50,9 +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;
        const char *assembly_name;
        const char *module_name;
+       const char *version;
+       char *guid;
        void *image_info;
 
        char                *raw_metadata;
@@ -77,6 +88,10 @@ struct _MonoImage {
         */
        MonoAssembly **references;
 
+       MonoImage **modules;
+
+       MonoImage **files;
+
        /*
         * The Assembly this image was loaded from.
         */
@@ -87,6 +102,19 @@ struct _MonoImage {
         */
        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.
         */
@@ -99,12 +127,20 @@ struct _MonoImage {
        GHashTable *array_cache;
 
        /*
-        * indexed by MonoMethod pointers 
+        * 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;
 
@@ -113,6 +149,12 @@ struct _MonoImage {
         * metadata engine
         */
        void *user_info;
+
+       /* dll map entries */
+       GHashTable *dll_map;
+
+       /* Whenever this is a dynamically emitted module */
+       gboolean dynamic;
 };
 
 typedef enum {
@@ -122,20 +164,39 @@ typedef enum {
        MONO_IMAGE_IMAGE_INVALID
 } MonoImageOpenStatus;
 
+void          mono_images_init    (void);
+
 MonoImage    *mono_image_open     (const char *fname,
                                   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);
+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