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
   9 typedef struct {
  10         char *name;
  11         char *data;
  12         guint32 alloc_size; /* malloced bytes */
  13         guint32 index;
  14         guint32 offset; /* from start of metadata */
  15 } MonoDynamicStream;
  16
  17 typedef struct {
  18         guint32 rows;
  19         guint32 row_size; /*  calculated later with column_sizes */
  20         guint32 columns;
  21         guint32 column_sizes [9];
  22         guint32 *values; /* rows * columns */
  23         guint32 next_idx;
  24 } MonoDynamicTable;
  25
  26 typedef struct {
  27         GHashTable *hash;
  28         char *data;
  29         guint32 index;
  30         guint32 alloc_size;
  31         guint32 offset; /* from start of metadata */
  32 } MonoStringHeap;
  33
  34 /*
  35  * The followinbg structure must match the C# implementation in our corlib.
  36  */
  37
  38 typedef struct {
  39         MonoObject object;
  40         MonoType  *type;
  41 } MonoReflectionType;
  42
  43 typedef struct {
  44         MonoObject object;
  45         MonoMethod *method;
  46 } MonoReflectionMethod;
  47
  48 typedef struct {
  49         MonoObject object;
  50         MonoObject *target_type;
  51         MonoObject *target;
  52         MonoString *method_name;
  53         gpointer method_ptr;
  54         MonoReflectionMethod *method_info;
  55 } MonoDelegate;
  56
  57 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
  58 struct _MonoMulticastDelegate {
  59         MonoDelegate delegate;
  60         MonoMulticastDelegate *prev;
  61 };
  62
  63 typedef struct {
  64         MonoObject object;
  65         MonoClass *klass;
  66         MonoClassField *field;
  67 } MonoReflectionField;
  68
  69 typedef struct {
  70         MonoObject object;
  71         MonoClass *klass;
  72         MonoProperty *property;
  73 } MonoReflectionProperty;
  74
  75 typedef struct {
  76         MonoObject object;
  77         MonoClass *klass;
  78         MonoEvent *event;
  79 } MonoReflectionEvent;
  80
  81 typedef struct {
  82         MonoObject object;
  83         MonoReflectionType *ClassImpl;
  84         MonoObject *DefaultValueImpl;
  85         MonoObject *MemberImpl;
  86         MonoString *NameImpl;
  87         gint32 PositionImpl;
  88         guint32 AttrsImpl;
  89 } MonoReflectionParameter;
  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         MonoString *name;
 101         guint32 attrs;
 102         guint32 implattrs;
 103 } MonoMethodInfo;
 104
 105 typedef struct {
 106         MonoReflectionType *parent;
 107         MonoString *name;
 108         MonoReflectionMethod *get;
 109         MonoReflectionMethod *set;
 110         guint32 attrs;
 111 } MonoPropertyInfo;
 112
 113 typedef struct {
 114         MonoReflectionType *parent;
 115         MonoReflectionType *type;
 116         MonoString *name;
 117         guint32 attrs;
 118 } MonoFieldInfo;
 119
 120 typedef struct {
 121         MonoString *name;
 122         MonoString *name_space;
 123         MonoReflectionType *parent;
 124         MonoReflectionType *etype;
 125         MonoAssembly *assembly;
 126         guint32 attrs;
 127         guint32 rank;
 128         MonoBoolean isbyref, ispointer, 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         MonoObject* methodb;
 173         MonoString *name;
 174         MonoArray *cattrs;
 175         guint32 attrs;
 176         int position;
 177         guint32 table_idx;
 178 } MonoReflectionParamBuilder;
 179
 180 typedef struct {
 181         MonoObject object;
 182         MonoReflectionILGen *ilgen;
 183         MonoArray *parameters;
 184         guint32 attrs;
 185         guint32 iattrs;
 186         guint32 table_idx;
 187         guint32 call_conv;
 188         MonoObject *type;
 189         MonoArray *pinfo;
 190         MonoArray *cattrs;
 191 } MonoReflectionCtorBuilder;
 192
 193 typedef struct {
 194         MonoObject object;
 195         MonoMethod *mhandle;
 196         MonoReflectionType *rtype;
 197         MonoArray *parameters;
 198         guint32 attrs;
 199         guint32 iattrs;
 200         MonoString *name;
 201         guint32 table_idx;
 202         MonoArray *code;
 203         MonoReflectionILGen *ilgen;
 204         MonoObject *type;
 205         MonoArray *pinfo;
 206         MonoArray *cattrs;
 207         MonoReflectionMethod *override_method;
 208         MonoString *dll;
 209         MonoString *dllentry;
 210         guint32 charset;
 211         guint32 native_cc;
 212         guint32 call_conv;
 213 } MonoReflectionMethodBuilder;
 214
 215 typedef struct {
 216         MonoAssembly assembly;
 217         guint32 meta_size;
 218         guint32 text_rva;
 219         guint32 metadata_rva;
 220         GHashTable *typeref;
 221         GHashTable *token_fixups;
 222         MonoStringHeap sheap;
 223         MonoDynamicStream code; /* used to store method headers and bytecode */
 224         MonoDynamicStream us;
 225         MonoDynamicStream blob;
 226         MonoDynamicStream tstream;
 227         MonoDynamicStream guid;
 228         MonoDynamicTable tables [64];
 229 } MonoDynamicAssembly;
 230
 231 typedef struct {
 232         MonoObject object;
 233         MonoAssembly *assembly;
 234 } MonoReflectionAssembly;
 235
 236 typedef struct {
 237         MonoReflectionAssembly assembly;
 238         MonoDynamicAssembly *dynamic_assembly;
 239         MonoReflectionMethodBuilder *entry_point;
 240         MonoArray *modules;
 241         MonoString *name;
 242         MonoArray *cattrs;
 243 } MonoReflectionAssemblyBuilder;
 244
 245 typedef struct {
 246         MonoObject object;
 247         guint32 attrs;
 248         MonoReflectionType *type;
 249         MonoString *name;
 250         MonoObject *def_value;
 251         gint32 offset;
 252         gint32 table_idx;
 253         MonoReflectionType *typeb;
 254         MonoArray *rva_data;
 255         MonoArray *cattrs;
 256 } MonoReflectionFieldBuilder;
 257
 258 typedef struct {
 259         MonoObject object;
 260         guint32 attrs;
 261         MonoString *name;
 262         MonoReflectionType *type;
 263         MonoArray *parameters;
 264         MonoArray *cattrs;
 265         MonoObject *def_value;
 266         MonoReflectionMethodBuilder *set_method;
 267         MonoReflectionMethodBuilder *get_method;
 268         gint32 table_idx;
 269 } MonoReflectionPropertyBuilder;
 270
 271 typedef struct {
 272         MonoObject      obj;
 273         MonoImage  *image;
 274         MonoObject *assembly;
 275         MonoString *fqname;
 276         MonoString *name;
 277         MonoString *scopename;
 278 } MonoReflectionModule;
 279
 280 typedef struct {
 281         MonoReflectionModule module;
 282         MonoArray *types;
 283         MonoArray *cattrs;
 284         guint32    table_idx;
 285         MonoReflectionAssemblyBuilder *assemblyb;
 286 } MonoReflectionModuleBuilder;
 287
 288 typedef struct {
 289         MonoReflectionType type;
 290         MonoString *name;
 291         MonoString *nspace;
 292         MonoReflectionType *parent;
 293         MonoArray *interfaces;
 294         MonoArray *methods;
 295         MonoArray *ctors;
 296         MonoArray *properties;
 297         MonoArray *fields;
 298         MonoArray *events;
 299         MonoArray *cattrs;
 300         MonoArray *subtypes;
 301         guint32 attrs;
 302         guint32 table_idx;
 303         MonoReflectionModuleBuilder *module;
 304         gint32 class_size;
 305         gint32 packing_size;
 306 } MonoReflectionTypeBuilder;
 307
 308 typedef struct {
 309         MonoObject  obj;
 310         MonoString *name;
 311         MonoString *codebase;
 312         MonoObject *version;
 313 } MonoReflectionAssemblyName;
 314
 315 typedef struct {
 316         MonoObject  obj;
 317         MonoString *name;
 318         MonoReflectionType *type;
 319         MonoReflectionTypeBuilder *typeb;
 320         MonoArray *cattrs;
 321         MonoReflectionMethodBuilder *add_method;
 322         MonoReflectionMethodBuilder *remove_method;
 323         MonoReflectionMethodBuilder *raise_method;
 324         MonoArray *other_methods;
 325         guint32 attrs;
 326         guint32 table_idx;
 327 } MonoReflectionEventBuilder;
 328
 329 typedef struct {
 330         MonoObject  obj;
 331         MonoReflectionMethod *ctor;
 332         MonoArray *data;
 333 } MonoReflectionCustomAttr;
 334
 335 typedef struct {
 336         char *nest_name_space;
 337         char *nest_name;
 338         char *name_space;
 339         char *name;
 340         char *assembly;
 341         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 342 } MonoTypeNameParse;
 343
 344 typedef struct {
 345         MonoObject object;
 346         MonoReflectionModuleBuilder *module;
 347         MonoArray *arguments;
 348         guint32 type;
 349 } MonoReflectionSigHelper;
 350
 351
 352
 353 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 354 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 355
 356 int           mono_image_get_header (MonoReflectionAssemblyBuilder *assembly, char *buffer, int maxsize);
 357 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 358 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 359 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 360
 361 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 362 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 363 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method);
 364 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 365 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 366 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 367 /* note: this one is slightly different: we keep the whole array of params in the cache */
 368 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 369
 370
 371 typedef MonoObject* (*MonoInvokeFunc) (MonoMethod *method, void *obj, void **params);
 372
 373 extern MonoInvokeFunc mono_default_runtime_invoke;
 374
 375 void        mono_install_runtime_invoke (MonoInvokeFunc func);
 376 MonoObject* mono_runtime_invoke         (MonoMethod *method, void *obj, void **params);
 377 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 378 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 379
 380 void        mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb);
 381
 382 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 383
 384 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 385
 386 #endif /* __METADATA_REFLECTION_H__ */
 387