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