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 #include <mono/utils/mono-hash.h>
   9
  10 typedef struct {
  11         GHashTable *hash;
  12         char *data;
  13         guint32 alloc_size; /* malloced bytes */
  14         guint32 index;
  15         guint32 offset; /* from start of metadata */
  16 } MonoDynamicStream;
  17
  18 typedef struct {
  19         guint32 rows;
  20         guint32 row_size; /*  calculated later with column_sizes */
  21         guint32 columns;
  22         guint32 column_sizes [9];
  23         guint32 *values; /* rows * columns */
  24         guint32 next_idx;
  25 } MonoDynamicTable;
  26
  27 /*
  28  * The followinbg structure must match the C# implementation in our corlib.
  29  */
  30
  31 struct _MonoReflectionMethod {
  32         MonoObject object;
  33         MonoMethod *method;
  34         MonoString *name;
  35         MonoReflectionType *reftype;
  36 };
  37
  38 struct _MonoDelegate {
  39         MonoObject object;
  40         MonoObject *target_type;
  41         MonoObject *target;
  42         MonoString *method_name;
  43         gpointer method_ptr;
  44         gpointer delegate_trampoline;
  45         MonoReflectionMethod *method_info;
  46 };
  47
  48 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
  49 struct _MonoMulticastDelegate {
  50         MonoDelegate delegate;
  51         MonoMulticastDelegate *prev;
  52 };
  53
  54 typedef struct {
  55         MonoObject object;
  56         MonoClass *klass;
  57         MonoClassField *field;
  58 } MonoReflectionField;
  59
  60 typedef struct {
  61         MonoObject object;
  62         MonoClass *klass;
  63         MonoProperty *property;
  64 } MonoReflectionProperty;
  65
  66 typedef struct {
  67         MonoObject object;
  68         MonoClass *klass;
  69         MonoEvent *event;
  70 } MonoReflectionEvent;
  71
  72 typedef struct {
  73         MonoObject object;
  74         MonoReflectionType *ClassImpl;
  75         MonoObject *DefaultValueImpl;
  76         MonoObject *MemberImpl;
  77         MonoString *NameImpl;
  78         gint32 PositionImpl;
  79         guint32 AttrsImpl;
  80 } MonoReflectionParameter;
  81
  82 typedef struct {
  83         MonoObject object;
  84         MonoAssembly *assembly;
  85 } MonoReflectionAssembly;
  86
  87 typedef struct {
  88         MonoReflectionType *utype;
  89         MonoArray *values;
  90         MonoArray *names;
  91 } MonoEnumInfo;
  92
  93 typedef struct {
  94         MonoReflectionType *parent;
  95         MonoReflectionType *ret;
  96         guint32 attrs;
  97         guint32 implattrs;
  98 } MonoMethodInfo;
  99
 100 typedef struct {
 101         MonoReflectionType *parent;
 102         MonoString *name;
 103         MonoReflectionMethod *get;
 104         MonoReflectionMethod *set;
 105         guint32 attrs;
 106 } MonoPropertyInfo;
 107
 108 typedef struct {
 109         MonoReflectionType *parent;
 110         MonoString *name;
 111         MonoReflectionMethod *add_method;
 112         MonoReflectionMethod *remove_method;
 113         MonoReflectionMethod *raise_method;
 114         guint32 attrs;
 115 } MonoEventInfo;
 116
 117 typedef struct {
 118         MonoReflectionType *parent;
 119         MonoReflectionType *type;
 120         MonoString *name;
 121         guint32 attrs;
 122 } MonoFieldInfo;
 123
 124 typedef struct {
 125         MonoString *name;
 126         MonoString *name_space;
 127         MonoReflectionType *etype;
 128         MonoReflectionType *nested_in;
 129         MonoReflectionAssembly *assembly;
 130         guint32 rank;
 131         MonoBoolean isprimitive;
 132 } MonoTypeInfo;
 133
 134 typedef struct {
 135         MonoObject *member;
 136         gint32 code_pos;
 137 } MonoReflectionILTokenInfo;
 138
 139 typedef struct {
 140         MonoObject object;
 141         MonoArray *code;
 142         MonoObject *mbuilder;
 143         gint32 code_len;
 144         gint32 max_stack;
 145         gint32 cur_stack;
 146         MonoArray *locals;
 147         MonoArray *ex_handlers;
 148         gint32 num_token_fixups;
 149         MonoArray *token_fixups;
 150 } MonoReflectionILGen;
 151
 152 typedef struct {
 153         MonoArray *handlers;
 154         gint32 start;
 155         gint32 len;
 156         gint32 label;
 157 } MonoILExceptionInfo;
 158
 159 typedef struct {
 160         MonoReflectionType *extype;
 161         gint32 type;
 162         gint32 start;
 163         gint32 len;
 164         gint32 filter_offset;
 165 } MonoILExceptionBlock;
 166
 167 typedef struct {
 168         MonoObject object;
 169         MonoReflectionType *type;
 170         MonoString *name;
 171 } MonoReflectionLocalBuilder;
 172
 173 typedef struct {
 174         MonoObject object;
 175         gint32 count;
 176         gint32 type;
 177         gint32 eltype;
 178 } MonoReflectionMarshal;
 179
 180 typedef struct {
 181         MonoObject object;
 182         MonoObject* methodb;
 183         MonoString *name;
 184         MonoArray *cattrs;
 185         MonoReflectionMarshal *marshal_info;
 186         guint32 attrs;
 187         int position;
 188         guint32 table_idx;
 189 } MonoReflectionParamBuilder;
 190
 191 typedef struct {
 192         MonoObject object;
 193         MonoMethod *mhandle;
 194         MonoReflectionILGen *ilgen;
 195         MonoArray *parameters;
 196         guint32 attrs;
 197         guint32 iattrs;
 198         guint32 table_idx;
 199         guint32 call_conv;
 200         MonoObject *type;
 201         MonoArray *pinfo;
 202         MonoArray *cattrs;
 203         MonoBoolean init_locals;
 204 } MonoReflectionCtorBuilder;
 205
 206 typedef struct {
 207         MonoObject object;
 208         MonoMethod *mhandle;
 209         MonoReflectionType *rtype;
 210         MonoArray *parameters;
 211         guint32 attrs;
 212         guint32 iattrs;
 213         MonoString *name;
 214         guint32 table_idx;
 215         MonoArray *code;
 216         MonoReflectionILGen *ilgen;
 217         MonoObject *type;
 218         MonoArray *pinfo;
 219         MonoArray *cattrs;
 220         MonoReflectionMethod *override_method;
 221         MonoString *dll;
 222         MonoString *dllentry;
 223         guint32 charset;
 224         guint32 native_cc;
 225         guint32 call_conv;
 226         MonoBoolean init_locals;
 227 } MonoReflectionMethodBuilder;
 228
 229 typedef struct {
 230         MonoObject object;
 231         MonoMethod *mhandle;
 232         MonoReflectionType *parent;
 233         MonoReflectionType *ret;
 234         MonoArray *parameters;
 235         MonoString *name;
 236         guint32 table_idx;
 237         guint32 call_conv;
 238 } MonoReflectionArrayMethod;
 239
 240 enum {
 241         MONO_SECTION_TEXT,
 242         MONO_SECTION_RSRC,
 243         MONO_SECTION_RELOC,
 244         MONO_SECTION_MAX
 245 };
 246
 247 typedef struct {
 248         MonoAssembly assembly;
 249         guint32 meta_size;
 250         guint32 text_rva;
 251         guint32 metadata_rva;
 252         guint32 image_base;
 253         guint32 cli_header_offset;
 254         guint32 iat_offset;
 255         guint32 idt_offset;
 256         guint32 ilt_offset;
 257         guint32 imp_names_offset;
 258         struct {
 259                 guint32 rva;
 260                 guint32 size;
 261                 guint32 offset;
 262                 guint32 attrs;
 263         } sections [MONO_SECTION_MAX];
 264         GHashTable *typeref;
 265         GHashTable *handleref;
 266         GList *array_methods;
 267         MonoGHashTable *token_fixups;
 268         MonoDynamicStream pefile;
 269         MonoDynamicStream sheap;
 270         MonoDynamicStream code; /* used to store method headers and bytecode */
 271         MonoDynamicStream resources; /* managed embedded resources */
 272         MonoDynamicStream us;
 273         MonoDynamicStream blob;
 274         MonoDynamicStream tstream;
 275         MonoDynamicStream guid;
 276         MonoDynamicTable tables [64];
 277 } MonoDynamicAssembly;
 278
 279 typedef struct {
 280         MonoArray *data;
 281         MonoString *name;
 282         MonoString *filename;
 283         guint32 attrs;
 284 } MonoReflectionResource;
 285
 286 typedef struct {
 287         MonoReflectionAssembly assembly;
 288         MonoDynamicAssembly *dynamic_assembly;
 289         MonoReflectionMethodBuilder *entry_point;
 290         MonoArray *modules;
 291         MonoString *name;
 292         MonoString *dir;
 293         MonoArray *cattrs;
 294         MonoArray *resources;
 295 } MonoReflectionAssemblyBuilder;
 296
 297 typedef struct {
 298         MonoObject object;
 299         guint32 attrs;
 300         MonoReflectionType *type;
 301         MonoString *name;
 302         MonoObject *def_value;
 303         gint32 offset;
 304         gint32 table_idx;
 305         MonoReflectionType *typeb;
 306         MonoArray *rva_data;
 307         MonoArray *cattrs;
 308         MonoReflectionMarshal *marshal_info;
 309 } MonoReflectionFieldBuilder;
 310
 311 typedef struct {
 312         MonoObject object;
 313         guint32 attrs;
 314         MonoString *name;
 315         MonoReflectionType *type;
 316         MonoArray *parameters;
 317         MonoArray *cattrs;
 318         MonoObject *def_value;
 319         MonoReflectionMethodBuilder *set_method;
 320         MonoReflectionMethodBuilder *get_method;
 321         gint32 table_idx;
 322 } MonoReflectionPropertyBuilder;
 323
 324 typedef struct {
 325         MonoObject      obj;
 326         MonoImage  *image;
 327         MonoReflectionAssembly *assembly;
 328         MonoString *fqname;
 329         MonoString *name;
 330         MonoString *scopename;
 331 } MonoReflectionModule;
 332
 333 typedef struct {
 334         MonoReflectionModule module;
 335         MonoArray *types;
 336         MonoArray *cattrs;
 337         MonoArray *guid;
 338         guint32    table_idx;
 339         MonoReflectionAssemblyBuilder *assemblyb;
 340 } MonoReflectionModuleBuilder;
 341
 342 typedef struct {
 343         MonoReflectionType type;
 344         MonoString *name;
 345         MonoString *nspace;
 346         MonoReflectionType *parent;
 347         MonoReflectionType *nesting_type;
 348         MonoArray *interfaces;
 349         MonoArray *methods;
 350         MonoArray *ctors;
 351         MonoArray *properties;
 352         MonoArray *fields;
 353         MonoArray *events;
 354         MonoArray *cattrs;
 355         MonoArray *subtypes;
 356         guint32 attrs;
 357         guint32 table_idx;
 358         MonoReflectionModuleBuilder *module;
 359         gint32 class_size;
 360         gint32 packing_size;
 361 } MonoReflectionTypeBuilder;
 362
 363 typedef struct {
 364         MonoObject  obj;
 365         MonoString *name;
 366         MonoString *codebase;
 367         gint32 major, minor, build, revision;
 368         /* FIXME: add missing stuff */
 369 /*      CultureInfo cultureinfo;
 370         AssemblyNameFlags flags;
 371         AssemblyHashAlgorithm hashalg;
 372         StrongNameKeyPair keypair;
 373         AssemblyVersionCompatibility versioncompat;*/
 374         MonoObject  *cultureInfo;
 375         MonoObject  *flags;
 376         MonoObject  *hashalg;
 377         MonoObject  *keypair;
 378         MonoObject  *versioncompat;
 379 } MonoReflectionAssemblyName;
 380
 381 typedef struct {
 382         MonoObject  obj;
 383         MonoString *name;
 384         MonoReflectionType *type;
 385         MonoReflectionTypeBuilder *typeb;
 386         MonoArray *cattrs;
 387         MonoReflectionMethodBuilder *add_method;
 388         MonoReflectionMethodBuilder *remove_method;
 389         MonoReflectionMethodBuilder *raise_method;
 390         MonoArray *other_methods;
 391         guint32 attrs;
 392         guint32 table_idx;
 393 } MonoReflectionEventBuilder;
 394
 395 typedef struct {
 396         MonoObject  obj;
 397         MonoReflectionMethod *ctor;
 398         MonoArray *data;
 399 } MonoReflectionCustomAttr;
 400
 401 typedef struct MonoTypeNameParse MonoTypeNameParse;
 402
 403 struct MonoTypeNameParse {
 404         char *name_space;
 405         char *name;
 406         MonoAssemblyName assembly;
 407         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 408         GList *nested;
 409 };
 410
 411 typedef struct {
 412         MonoObject object;
 413         MonoReflectionModuleBuilder *module;
 414         MonoArray *arguments;
 415         guint32 type;
 416 } MonoReflectionSigHelper;
 417
 418
 419
 420 char*         mono_type_get_name         (MonoType *type);
 421 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 422 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 423 MonoType*     mono_reflection_type_from_name (char *name, MonoImage *image);
 424
 425 void          mono_image_create_pefile (MonoReflectionAssemblyBuilder *assembly);
 426 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 427 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 428 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 429
 430 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 431 MonoReflectionModule*   mono_module_get_object   (MonoDomain *domain, MonoImage *image);
 432 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 433 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method, MonoClass *refclass);
 434 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 435 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 436 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 437 /* note: this one is slightly different: we keep the whole array of params in the cache */
 438 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 439
 440 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 441 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 442
 443 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 444
 445 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 446
 447 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 448
 449 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 450
 451 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 452
 453 #endif /* __METADATA_REFLECTION_H__ */
 454