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