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 };
  36
  37 struct _MonoDelegate {
  38         MonoObject object;
  39         MonoObject *target_type;
  40         MonoObject *target;
  41         MonoString *method_name;
  42         gpointer method_ptr;
  43         gpointer delegate_trampoline;
  44         MonoReflectionMethod *method_info;
  45 };
  46
  47 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
  48 struct _MonoMulticastDelegate {
  49         MonoDelegate delegate;
  50         MonoMulticastDelegate *prev;
  51 };
  52
  53 typedef struct {
  54         MonoObject object;
  55         MonoClass *klass;
  56         MonoClassField *field;
  57 } MonoReflectionField;
  58
  59 typedef struct {
  60         MonoObject object;
  61         MonoClass *klass;
  62         MonoProperty *property;
  63 } MonoReflectionProperty;
  64
  65 typedef struct {
  66         MonoObject object;
  67         MonoClass *klass;
  68         MonoEvent *event;
  69 } MonoReflectionEvent;
  70
  71 typedef struct {
  72         MonoObject object;
  73         MonoReflectionType *ClassImpl;
  74         MonoObject *DefaultValueImpl;
  75         MonoObject *MemberImpl;
  76         MonoString *NameImpl;
  77         gint32 PositionImpl;
  78         guint32 AttrsImpl;
  79 } MonoReflectionParameter;
  80
  81 typedef struct {
  82         MonoObject object;
  83         MonoAssembly *assembly;
  84 } MonoReflectionAssembly;
  85
  86 typedef struct {
  87         MonoReflectionType *utype;
  88         MonoArray *values;
  89         MonoArray *names;
  90 } MonoEnumInfo;
  91
  92 typedef struct {
  93         MonoReflectionType *parent;
  94         MonoReflectionType *ret;
  95         guint32 attrs;
  96         guint32 implattrs;
  97 } MonoMethodInfo;
  98
  99 typedef struct {
 100         MonoReflectionType *parent;
 101         MonoString *name;
 102         MonoReflectionMethod *get;
 103         MonoReflectionMethod *set;
 104         guint32 attrs;
 105 } MonoPropertyInfo;
 106
 107 typedef struct {
 108         MonoReflectionType *parent;
 109         MonoString *name;
 110         MonoReflectionMethod *add_method;
 111         MonoReflectionMethod *remove_method;
 112         MonoReflectionMethod *raise_method;
 113         guint32 attrs;
 114 } MonoEventInfo;
 115
 116 typedef struct {
 117         MonoReflectionType *parent;
 118         MonoReflectionType *type;
 119         MonoString *name;
 120         guint32 attrs;
 121 } MonoFieldInfo;
 122
 123 typedef struct {
 124         MonoString *name;
 125         MonoString *name_space;
 126         MonoReflectionType *parent;
 127         MonoReflectionType *etype;
 128         MonoReflectionAssembly *assembly;
 129         guint32 attrs;
 130         guint32 rank;
 131         MonoBoolean isbyref, ispointer, 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         MonoReflectionILGen *ilgen;
 194         MonoArray *parameters;
 195         guint32 attrs;
 196         guint32 iattrs;
 197         guint32 table_idx;
 198         guint32 call_conv;
 199         MonoObject *type;
 200         MonoArray *pinfo;
 201         MonoArray *cattrs;
 202         MonoBoolean init_locals;
 203 } MonoReflectionCtorBuilder;
 204
 205 typedef struct {
 206         MonoObject object;
 207         MonoMethod *mhandle;
 208         MonoReflectionType *rtype;
 209         MonoArray *parameters;
 210         guint32 attrs;
 211         guint32 iattrs;
 212         MonoString *name;
 213         guint32 table_idx;
 214         MonoArray *code;
 215         MonoReflectionILGen *ilgen;
 216         MonoObject *type;
 217         MonoArray *pinfo;
 218         MonoArray *cattrs;
 219         MonoReflectionMethod *override_method;
 220         MonoString *dll;
 221         MonoString *dllentry;
 222         guint32 charset;
 223         guint32 native_cc;
 224         guint32 call_conv;
 225         MonoBoolean init_locals;
 226 } MonoReflectionMethodBuilder;
 227
 228 typedef struct {
 229         MonoObject object;
 230         MonoMethod *mhandle;
 231         MonoReflectionType *parent;
 232         MonoReflectionType *ret;
 233         MonoArray *parameters;
 234         MonoString *name;
 235         guint32 table_idx;
 236         guint32 call_conv;
 237 } MonoReflectionArrayMethod;
 238
 239 enum {
 240         MONO_SECTION_TEXT,
 241         MONO_SECTION_RSRC,
 242         MONO_SECTION_RELOC,
 243         MONO_SECTION_MAX
 244 };
 245
 246 typedef struct {
 247         MonoAssembly assembly;
 248         guint32 meta_size;
 249         guint32 text_rva;
 250         guint32 metadata_rva;
 251         guint32 image_base;
 252         guint32 cli_header_offset;
 253         guint32 iat_offset;
 254         guint32 idt_offset;
 255         guint32 ilt_offset;
 256         guint32 imp_names_offset;
 257         struct {
 258                 guint32 rva;
 259                 guint32 size;
 260                 guint32 offset;
 261                 guint32 attrs;
 262         } sections [MONO_SECTION_MAX];
 263         GHashTable *typeref;
 264         GHashTable *handleref;
 265         GList *array_methods;
 266         MonoGHashTable *token_fixups;
 267         MonoDynamicStream pefile;
 268         MonoDynamicStream sheap;
 269         MonoDynamicStream code; /* used to store method headers and bytecode */
 270         MonoDynamicStream us;
 271         MonoDynamicStream blob;
 272         MonoDynamicStream tstream;
 273         MonoDynamicStream guid;
 274         MonoDynamicTable tables [64];
 275 } MonoDynamicAssembly;
 276
 277 typedef struct {
 278         MonoReflectionAssembly assembly;
 279         MonoDynamicAssembly *dynamic_assembly;
 280         MonoReflectionMethodBuilder *entry_point;
 281         MonoArray *modules;
 282         MonoString *name;
 283         MonoString *dir;
 284         MonoArray *cattrs;
 285 } MonoReflectionAssemblyBuilder;
 286
 287 typedef struct {
 288         MonoObject object;
 289         guint32 attrs;
 290         MonoReflectionType *type;
 291         MonoString *name;
 292         MonoObject *def_value;
 293         gint32 offset;
 294         gint32 table_idx;
 295         MonoReflectionType *typeb;
 296         MonoArray *rva_data;
 297         MonoArray *cattrs;
 298         MonoReflectionMarshal *marshal_info;
 299 } MonoReflectionFieldBuilder;
 300
 301 typedef struct {
 302         MonoObject object;
 303         guint32 attrs;
 304         MonoString *name;
 305         MonoReflectionType *type;
 306         MonoArray *parameters;
 307         MonoArray *cattrs;
 308         MonoObject *def_value;
 309         MonoReflectionMethodBuilder *set_method;
 310         MonoReflectionMethodBuilder *get_method;
 311         gint32 table_idx;
 312 } MonoReflectionPropertyBuilder;
 313
 314 typedef struct {
 315         MonoObject      obj;
 316         MonoImage  *image;
 317         MonoObject *assembly;
 318         MonoString *fqname;
 319         MonoString *name;
 320         MonoString *scopename;
 321 } MonoReflectionModule;
 322
 323 typedef struct {
 324         MonoReflectionModule module;
 325         MonoArray *types;
 326         MonoArray *cattrs;
 327         MonoArray *guid;
 328         guint32    table_idx;
 329         MonoReflectionAssemblyBuilder *assemblyb;
 330 } MonoReflectionModuleBuilder;
 331
 332 typedef struct {
 333         MonoReflectionType type;
 334         MonoString *name;
 335         MonoString *nspace;
 336         MonoReflectionType *parent;
 337         MonoReflectionType *nesting_type;
 338         MonoArray *interfaces;
 339         MonoArray *methods;
 340         MonoArray *ctors;
 341         MonoArray *properties;
 342         MonoArray *fields;
 343         MonoArray *events;
 344         MonoArray *cattrs;
 345         MonoArray *subtypes;
 346         guint32 attrs;
 347         guint32 table_idx;
 348         MonoReflectionModuleBuilder *module;
 349         gint32 class_size;
 350         gint32 packing_size;
 351 } MonoReflectionTypeBuilder;
 352
 353 typedef struct {
 354         MonoObject  obj;
 355         MonoString *name;
 356         MonoString *codebase;
 357         gint32 major, minor, build, revision;
 358         /* FIXME: add missing stuff */
 359 } MonoReflectionAssemblyName;
 360
 361 typedef struct {
 362         MonoObject  obj;
 363         MonoString *name;
 364         MonoReflectionType *type;
 365         MonoReflectionTypeBuilder *typeb;
 366         MonoArray *cattrs;
 367         MonoReflectionMethodBuilder *add_method;
 368         MonoReflectionMethodBuilder *remove_method;
 369         MonoReflectionMethodBuilder *raise_method;
 370         MonoArray *other_methods;
 371         guint32 attrs;
 372         guint32 table_idx;
 373 } MonoReflectionEventBuilder;
 374
 375 typedef struct {
 376         MonoObject  obj;
 377         MonoReflectionMethod *ctor;
 378         MonoArray *data;
 379 } MonoReflectionCustomAttr;
 380
 381 typedef struct MonoTypeNameParse MonoTypeNameParse;
 382
 383 struct MonoTypeNameParse {
 384         char *name_space;
 385         char *name;
 386         MonoAssemblyName assembly;
 387         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 388         GList *nested;
 389 };
 390
 391 typedef struct {
 392         MonoObject object;
 393         MonoReflectionModuleBuilder *module;
 394         MonoArray *arguments;
 395         guint32 type;
 396 } MonoReflectionSigHelper;
 397
 398
 399
 400 char*         mono_type_get_name         (MonoType *type);
 401 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 402 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 403 MonoType*     mono_reflection_type_from_name (char *name, MonoImage *image);
 404
 405 void          mono_image_create_pefile (MonoReflectionAssemblyBuilder *assembly);
 406 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 407 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 408 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 409
 410 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 411 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 412 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method);
 413 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 414 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 415 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 416 /* note: this one is slightly different: we keep the whole array of params in the cache */
 417 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 418
 419 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 420 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 421
 422 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 423
 424 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 425
 426 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 427
 428 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 429
 430 #endif /* __METADATA_REFLECTION_H__ */
 431