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         MonoGHashTable *tokens;
 267         GHashTable *blob_cache;
 268         GList *array_methods;
 269         MonoGHashTable *token_fixups;
 270         MonoGHashTable *method_to_table_idx;
 271         MonoGHashTable *field_to_table_idx;
 272         char *strong_name;
 273         guint32 strong_name_size;
 274         MonoDynamicStream pefile;
 275         MonoDynamicStream sheap;
 276         MonoDynamicStream code; /* used to store method headers and bytecode */
 277         MonoDynamicStream resources; /* managed embedded resources */
 278         MonoDynamicStream us;
 279         MonoDynamicStream blob;
 280         MonoDynamicStream tstream;
 281         MonoDynamicStream guid;
 282         MonoDynamicTable tables [64];
 283 } MonoDynamicAssembly;
 284
 285 typedef struct {
 286         MonoArray *data;
 287         MonoString *name;
 288         MonoString *filename;
 289         guint32 attrs;
 290 } MonoReflectionResource;
 291
 292 typedef struct {
 293         MonoReflectionAssembly assembly;
 294         MonoDynamicAssembly *dynamic_assembly;
 295         MonoReflectionMethodBuilder *entry_point;
 296         MonoArray *modules;
 297         MonoString *name;
 298         MonoString *dir;
 299         MonoArray *cattrs;
 300         MonoArray *resources;
 301         MonoString *keyfile;
 302         MonoString *version;
 303         MonoString *culture;
 304         guint32 algid;
 305         guint32 flags;
 306         guint32 pekind;
 307         MonoBoolean delay_sign;
 308 } MonoReflectionAssemblyBuilder;
 309
 310 typedef struct {
 311         MonoObject object;
 312         guint32 attrs;
 313         MonoReflectionType *type;
 314         MonoString *name;
 315         MonoObject *def_value;
 316         gint32 offset;
 317         gint32 table_idx;
 318         MonoReflectionType *typeb;
 319         MonoArray *rva_data;
 320         MonoArray *cattrs;
 321         MonoReflectionMarshal *marshal_info;
 322         MonoClassField *handle;
 323 } MonoReflectionFieldBuilder;
 324
 325 typedef struct {
 326         MonoObject object;
 327         guint32 attrs;
 328         MonoString *name;
 329         MonoReflectionType *type;
 330         MonoArray *parameters;
 331         MonoArray *cattrs;
 332         MonoObject *def_value;
 333         MonoReflectionMethodBuilder *set_method;
 334         MonoReflectionMethodBuilder *get_method;
 335         gint32 table_idx;
 336 } MonoReflectionPropertyBuilder;
 337
 338 typedef struct {
 339         MonoObject      obj;
 340         MonoImage  *image;
 341         MonoReflectionAssembly *assembly;
 342         MonoString *fqname;
 343         MonoString *name;
 344         MonoString *scopename;
 345 } MonoReflectionModule;
 346
 347 typedef struct {
 348         MonoReflectionModule module;
 349         MonoArray *types;
 350         MonoArray *cattrs;
 351         MonoArray *guid;
 352         guint32    table_idx;
 353         MonoReflectionAssemblyBuilder *assemblyb;
 354         MonoArray *global_methods;
 355         MonoArray *global_fields;
 356 } MonoReflectionModuleBuilder;
 357
 358 typedef struct {
 359         MonoReflectionType type;
 360         MonoString *name;
 361         MonoString *nspace;
 362         MonoReflectionType *parent;
 363         MonoReflectionType *nesting_type;
 364         MonoArray *interfaces;
 365         MonoArray *methods;
 366         MonoArray *ctors;
 367         MonoArray *properties;
 368         MonoArray *fields;
 369         MonoArray *events;
 370         MonoArray *cattrs;
 371         MonoArray *subtypes;
 372         guint32 attrs;
 373         guint32 table_idx;
 374         MonoReflectionModuleBuilder *module;
 375         gint32 class_size;
 376         gint32 packing_size;
 377 } MonoReflectionTypeBuilder;
 378
 379 typedef struct {
 380         MonoObject  obj;
 381         MonoString *name;
 382         MonoString *codebase;
 383         gint32 major, minor, build, revision;
 384         /* FIXME: add missing stuff */
 385 /*      CultureInfo cultureinfo;
 386         AssemblyNameFlags flags;
 387         AssemblyHashAlgorithm hashalg;
 388         StrongNameKeyPair keypair;
 389         AssemblyVersionCompatibility versioncompat;*/
 390         MonoObject  *cultureInfo;
 391         MonoObject  *flags;
 392         MonoObject  *hashalg;
 393         MonoObject  *keypair;
 394         MonoArray   *publicKey;
 395         MonoArray   *keyToken;
 396         MonoObject  *versioncompat;
 397 } MonoReflectionAssemblyName;
 398
 399 typedef struct {
 400         MonoObject  obj;
 401         MonoString *name;
 402         MonoReflectionType *type;
 403         MonoReflectionTypeBuilder *typeb;
 404         MonoArray *cattrs;
 405         MonoReflectionMethodBuilder *add_method;
 406         MonoReflectionMethodBuilder *remove_method;
 407         MonoReflectionMethodBuilder *raise_method;
 408         MonoArray *other_methods;
 409         guint32 attrs;
 410         guint32 table_idx;
 411 } MonoReflectionEventBuilder;
 412
 413 typedef struct {
 414         MonoObject  obj;
 415         MonoReflectionMethod *ctor;
 416         MonoArray *data;
 417 } MonoReflectionCustomAttr;
 418
 419 typedef struct MonoTypeNameParse MonoTypeNameParse;
 420
 421 struct MonoTypeNameParse {
 422         char *name_space;
 423         char *name;
 424         MonoAssemblyName assembly;
 425         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 426         GList *nested;
 427 };
 428
 429 typedef struct {
 430         MonoObject object;
 431         MonoReflectionModuleBuilder *module;
 432         MonoArray *arguments;
 433         guint32 type;
 434         MonoReflectionType *return_type;
 435         guint32 call_conv;
 436         guint32 unmanaged_call_conv;
 437 } MonoReflectionSigHelper;
 438
 439
 440
 441 char*         mono_type_get_name         (MonoType *type);
 442 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 443 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 444 MonoType*     mono_reflection_type_from_name (char *name, MonoImage *image);
 445
 446 void          mono_image_create_pefile (MonoReflectionAssemblyBuilder *assembly);
 447 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 448 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 449 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 450 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
 451
 452 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 453 MonoReflectionModule*   mono_module_get_object   (MonoDomain *domain, MonoImage *image);
 454 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 455 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method, MonoClass *refclass);
 456 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 457 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 458 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 459 /* note: this one is slightly different: we keep the whole array of params in the cache */
 460 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 461
 462 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 463 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 464
 465 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 466
 467 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 468
 469 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 470
 471 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 472
 473 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 474
 475 gpointer
 476 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token);
 477
 478 void
 479 mono_image_build_metadata (MonoReflectionAssemblyBuilder *assemblyb);
 480
 481 #endif /* __METADATA_REFLECTION_H__ */
 482