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