mono/metadata/reflection.h

   1 #ifndef __METADATA_REFLECTION_H__
   2 #define __METADATA_REFLECTION_H__
   3
   4 #include <mono/metadata/image.h>
   5 #include <mono/metadata/metadata.h>
   6 #include <mono/metadata/class.h>
   7 #include <mono/metadata/object.h>
   8
   9 typedef struct {
  10         char *name;
  11         char *data;
  12         guint32 alloc_size; /* malloced bytes */
  13         guint32 index;
  14         guint32 offset; /* from start of metadata */
  15 } MonoDynamicStream;
  16
  17 typedef struct {
  18         guint32 rows;
  19         guint32 row_size; /*  calculated later with column_sizes */
  20         guint32 columns;
  21         guint32 column_sizes [9];
  22         guint32 *values; /* rows * columns */
  23         guint32 next_idx;
  24 } MonoDynamicTable;
  25
  26 typedef struct {
  27         GHashTable *hash;
  28         char *data;
  29         guint32 index;
  30         guint32 alloc_size;
  31         guint32 offset; /* from start of metadata */
  32 } MonoStringHeap;
  33
  34 /*
  35  * The followinbg structure must match the C# implementation in our corlib.
  36  */
  37
  38 typedef struct {
  39         MonoObject object;
  40         MonoType  *type;
  41 } MonoReflectionType;
  42
  43 typedef struct {
  44         MonoObject object;
  45         MonoMethod *method;
  46 } MonoReflectionMethod;
  47
  48 typedef struct {
  49         MonoObject object;
  50         MonoClass *klass;
  51         MonoClassField *field;
  52 } MonoReflectionField;
  53
  54 typedef struct {
  55         MonoObject object;
  56         MonoClass *klass;
  57         MonoProperty *property;
  58 } MonoReflectionProperty;
  59
  60 typedef struct {
  61         MonoObject object;
  62         MonoReflectionType *ClassImpl;
  63         MonoObject *DefaultValueImpl;
  64         MonoObject *MemberImpl;
  65         MonoString *NameImpl;
  66         gint32 PositionImpl;
  67         guint32 AttrsImpl;
  68 } MonoReflectionParameter;
  69
  70 typedef struct {
  71         MonoReflectionType *utype;
  72         MonoArray *values;
  73         MonoArray *names;
  74 } MonoEnumInfo;
  75
  76 typedef struct {
  77         MonoReflectionType *parent;
  78         MonoReflectionType *ret;
  79         MonoString *name;
  80         guint32 attrs;
  81         guint32 implattrs;
  82 } MonoMethodInfo;
  83
  84 typedef struct {
  85         MonoReflectionType *parent;
  86         MonoString *name;
  87         MonoReflectionMethod *get;
  88         MonoReflectionMethod *set;
  89         guint32 attrs;
  90 } MonoPropertyInfo;
  91
  92 typedef struct {
  93         MonoReflectionType *parent;
  94         MonoReflectionType *type;
  95         MonoString *name;
  96         guint32 attrs;
  97 } MonoFieldInfo;
  98
  99 typedef struct {
 100         MonoString *name;
 101         MonoString *name_space;
 102         MonoReflectionType *parent;
 103         MonoReflectionType *etype;
 104         MonoArray *interfaces;
 105         MonoAssembly *assembly;
 106         guint32 attrs;
 107         guint32 rank;
 108 } MonoTypeInfo;
 109
 110 typedef struct {
 111         MonoObject object;
 112         MonoArray *code;
 113         MonoObject *mbuilder;
 114         gint32 code_len;
 115         gint32 max_stack;
 116         gint32 cur_stack;
 117         MonoArray *locals;
 118         MonoArray *ex_handlers;
 119 } MonoReflectionILGen;
 120
 121 typedef struct {
 122         MonoArray *handlers;
 123         gint32 start;
 124         gint32 len;
 125 } MonoILExceptionInfo;
 126
 127 typedef struct {
 128         MonoReflectionType *extype;
 129         gint32 type;
 130         gint32 start;
 131         gint32 len;
 132         gint32 filter_offset;
 133 } MonoILExceptionBlock;
 134
 135 typedef struct {
 136         MonoObject object;
 137         MonoReflectionType *type;
 138         MonoString *name;
 139 } MonoReflectionLocalBuilder;
 140
 141 typedef struct {
 142         MonoObject object;
 143         MonoObject* methodb;
 144         MonoString *name;
 145         guint32 attrs;
 146         int position;
 147         guint32 table_idx;
 148 } MonoReflectionParamBuilder;
 149
 150 typedef struct {
 151         MonoObject object;
 152         MonoReflectionILGen *ilgen;
 153         MonoArray *parameters;
 154         guint32 attrs;
 155         guint32 iattrs;
 156         guint32 table_idx;
 157         guint32 call_conv;
 158         MonoObject *type;
 159         MonoArray *pinfo;
 160 } MonoReflectionCtorBuilder;
 161
 162 typedef struct {
 163         MonoObject object;
 164         MonoMethod *mhandle;
 165         MonoReflectionType *rtype;
 166         MonoArray *parameters;
 167         guint32 attrs;
 168         guint32 iattrs;
 169         MonoString *name;
 170         guint32 table_idx;
 171         MonoArray *code;
 172         MonoReflectionILGen *ilgen;
 173         MonoObject *type;
 174         MonoArray *pinfo;
 175         MonoReflectionMethod *override_method;
 176         MonoString *dll;
 177         MonoString *dllentry;
 178         guint32 charset;
 179         guint32 native_cc;
 180         guint32 call_conv;
 181 } MonoReflectionMethodBuilder;
 182
 183 typedef struct {
 184         MonoAssembly assembly;
 185         guint32 meta_size;
 186         guint32 text_rva;
 187         guint32 metadata_rva;
 188         GHashTable *typeref;
 189         MonoStringHeap sheap;
 190         MonoDynamicStream code; /* used to store method headers and bytecode */
 191         MonoDynamicStream us;
 192         MonoDynamicStream blob;
 193         MonoDynamicStream tstream;
 194         MonoDynamicStream guid;
 195         MonoDynamicTable tables [64];
 196 } MonoDynamicAssembly;
 197
 198 typedef struct {
 199         MonoObject object;
 200         MonoAssembly *assembly;
 201 } MonoReflectionAssembly;
 202
 203 typedef struct {
 204         MonoReflectionAssembly assembly;
 205         MonoDynamicAssembly *dynamic_assembly;
 206         MonoReflectionMethodBuilder *entry_point;
 207         MonoArray *modules;
 208         MonoString *name;
 209 } MonoReflectionAssemblyBuilder;
 210
 211 typedef struct {
 212         MonoObject object;
 213         guint32 attrs;
 214         MonoReflectionType *type;
 215         MonoString *name;
 216         MonoObject *def_value;
 217         gint32 offset;
 218         gint32 table_idx;
 219 } MonoReflectionFieldBuilder;
 220
 221 typedef struct {
 222         MonoObject object;
 223         guint32 attrs;
 224         MonoString *name;
 225         MonoReflectionType *type;
 226         MonoArray *parameters;
 227         MonoObject *def_value;
 228         MonoReflectionMethodBuilder *set_method;
 229         MonoReflectionMethodBuilder *get_method;
 230         gint32 table_idx;
 231 } MonoReflectionPropertyBuilder;
 232
 233 typedef struct {
 234         MonoObject      obj;
 235         MonoImage  *image;
 236         MonoObject *assembly;
 237         MonoString *fqname;
 238         MonoString *name;
 239         MonoString *scopename;
 240 } MonoReflectionModule;
 241
 242 typedef struct {
 243         MonoReflectionModule module;
 244         MonoArray *types;
 245         guint32    table_idx;
 246 } MonoReflectionModuleBuilder;
 247
 248 typedef struct {
 249         MonoReflectionType type;
 250         MonoString *name;
 251         MonoString *nspace;
 252         MonoReflectionType *parent;
 253         MonoArray *interfaces;
 254         MonoArray *methods;
 255         MonoArray *ctors;
 256         MonoArray *properties;
 257         MonoArray *fields;
 258         MonoArray *subtypes;
 259         guint32 attrs;
 260         guint32 table_idx;
 261         MonoReflectionModuleBuilder *module;
 262 } MonoReflectionTypeBuilder;
 263
 264 typedef struct {
 265         MonoObject  obj;
 266         MonoString *name;
 267         MonoString *codebase;
 268         MonoObject *version;
 269 } MonoReflectionAssemblyName;
 270
 271 typedef struct {
 272         char *nest_name_space;
 273         char *nest_name;
 274         char *name_space;
 275         char *name;
 276         char *assembly;
 277         int rank; /* we may need more info than this */
 278         int isbyref;
 279         int ispointer;
 280 } MonoTypeNameParse;
 281
 282 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 283
 284 int           mono_image_get_header (MonoReflectionAssemblyBuilder *assembly, char *buffer, int maxsize);
 285 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 286 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 287 guint32       mono_image_create_token  (MonoReflectionAssemblyBuilder *assembly, MonoObject *obj);
 288
 289 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 290 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 291 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method);
 292 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 293 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 294 /* note: this one is slightly different: we keep the whole array of params in the cache */
 295 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 296
 297 #endif /* __METADATA_REFLECTION_H__ */
 298