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         MonoClass *klass;
  51         MonoClassField *field;
  52 } MonoReflectionField;
  53
  54 typedef struct {
  55         MonoObject object;
  56         MonoClass *klass;
  57         MonoProperty *property;
  58 } MonoReflectionProperty;
  59
  60 typedef struct {
  61         MonoObject object;
  62         MonoClass *klass;
  63         MonoEvent *event;
  64 } MonoReflectionEvent;
  65
  66 typedef struct {
  67         MonoObject object;
  68         MonoReflectionType *ClassImpl;
  69         MonoObject *DefaultValueImpl;
  70         MonoObject *MemberImpl;
  71         MonoString *NameImpl;
  72         gint32 PositionImpl;
  73         guint32 AttrsImpl;
  74 } MonoReflectionParameter;
  75
  76 typedef struct {
  77         MonoReflectionType *utype;
  78         MonoArray *values;
  79         MonoArray *names;
  80 } MonoEnumInfo;
  81
  82 typedef struct {
  83         MonoReflectionType *parent;
  84         MonoReflectionType *ret;
  85         MonoString *name;
  86         guint32 attrs;
  87         guint32 implattrs;
  88 } MonoMethodInfo;
  89
  90 typedef struct {
  91         MonoReflectionType *parent;
  92         MonoString *name;
  93         MonoReflectionMethod *get;
  94         MonoReflectionMethod *set;
  95         guint32 attrs;
  96 } MonoPropertyInfo;
  97
  98 typedef struct {
  99         MonoReflectionType *parent;
 100         MonoReflectionType *type;
 101         MonoString *name;
 102         guint32 attrs;
 103 } MonoFieldInfo;
 104
 105 typedef struct {
 106         MonoString *name;
 107         MonoString *name_space;
 108         MonoReflectionType *parent;
 109         MonoReflectionType *etype;
 110         MonoAssembly *assembly;
 111         guint32 attrs;
 112         guint32 rank;
 113         MonoBoolean isbyref, ispointer, isprimitive;
 114 } MonoTypeInfo;
 115
 116 typedef struct {
 117         MonoObject *member;
 118         gint32 code_pos;
 119 } MonoReflectionILTokenInfo;
 120
 121 typedef struct {
 122         MonoObject object;
 123         MonoArray *code;
 124         MonoObject *mbuilder;
 125         gint32 code_len;
 126         gint32 max_stack;
 127         gint32 cur_stack;
 128         MonoArray *locals;
 129         MonoArray *ex_handlers;
 130         gint32 num_token_fixups;
 131         MonoArray *token_fixups;
 132 } MonoReflectionILGen;
 133
 134 typedef struct {
 135         MonoArray *handlers;
 136         gint32 start;
 137         gint32 len;
 138         gint32 label;
 139 } MonoILExceptionInfo;
 140
 141 typedef struct {
 142         MonoReflectionType *extype;
 143         gint32 type;
 144         gint32 start;
 145         gint32 len;
 146         gint32 filter_offset;
 147 } MonoILExceptionBlock;
 148
 149 typedef struct {
 150         MonoObject object;
 151         MonoReflectionType *type;
 152         MonoString *name;
 153 } MonoReflectionLocalBuilder;
 154
 155 typedef struct {
 156         MonoObject object;
 157         MonoObject* methodb;
 158         MonoString *name;
 159         MonoArray *cattrs;
 160         guint32 attrs;
 161         int position;
 162         guint32 table_idx;
 163 } MonoReflectionParamBuilder;
 164
 165 typedef struct {
 166         MonoObject object;
 167         MonoReflectionILGen *ilgen;
 168         MonoArray *parameters;
 169         guint32 attrs;
 170         guint32 iattrs;
 171         guint32 table_idx;
 172         guint32 call_conv;
 173         MonoObject *type;
 174         MonoArray *pinfo;
 175         MonoArray *cattrs;
 176 } MonoReflectionCtorBuilder;
 177
 178 typedef struct {
 179         MonoObject object;
 180         MonoMethod *mhandle;
 181         MonoReflectionType *rtype;
 182         MonoArray *parameters;
 183         guint32 attrs;
 184         guint32 iattrs;
 185         MonoString *name;
 186         guint32 table_idx;
 187         MonoArray *code;
 188         MonoReflectionILGen *ilgen;
 189         MonoObject *type;
 190         MonoArray *pinfo;
 191         MonoArray *cattrs;
 192         MonoReflectionMethod *override_method;
 193         MonoString *dll;
 194         MonoString *dllentry;
 195         guint32 charset;
 196         guint32 native_cc;
 197         guint32 call_conv;
 198 } MonoReflectionMethodBuilder;
 199
 200 typedef struct {
 201         MonoAssembly assembly;
 202         guint32 meta_size;
 203         guint32 text_rva;
 204         guint32 metadata_rva;
 205         GHashTable *typeref;
 206         GHashTable *token_fixups;
 207         MonoStringHeap sheap;
 208         MonoDynamicStream code; /* used to store method headers and bytecode */
 209         MonoDynamicStream us;
 210         MonoDynamicStream blob;
 211         MonoDynamicStream tstream;
 212         MonoDynamicStream guid;
 213         MonoDynamicTable tables [64];
 214 } MonoDynamicAssembly;
 215
 216 typedef struct {
 217         MonoObject object;
 218         MonoAssembly *assembly;
 219 } MonoReflectionAssembly;
 220
 221 typedef struct {
 222         MonoReflectionAssembly assembly;
 223         MonoDynamicAssembly *dynamic_assembly;
 224         MonoReflectionMethodBuilder *entry_point;
 225         MonoArray *modules;
 226         MonoString *name;
 227         MonoArray *cattrs;
 228 } MonoReflectionAssemblyBuilder;
 229
 230 typedef struct {
 231         MonoObject object;
 232         guint32 attrs;
 233         MonoReflectionType *type;
 234         MonoString *name;
 235         MonoObject *def_value;
 236         gint32 offset;
 237         gint32 table_idx;
 238         MonoReflectionType *typeb;
 239         MonoArray *rva_data;
 240         MonoArray *cattrs;
 241 } MonoReflectionFieldBuilder;
 242
 243 typedef struct {
 244         MonoObject object;
 245         guint32 attrs;
 246         MonoString *name;
 247         MonoReflectionType *type;
 248         MonoArray *parameters;
 249         MonoArray *cattrs;
 250         MonoObject *def_value;
 251         MonoReflectionMethodBuilder *set_method;
 252         MonoReflectionMethodBuilder *get_method;
 253         gint32 table_idx;
 254 } MonoReflectionPropertyBuilder;
 255
 256 typedef struct {
 257         MonoObject      obj;
 258         MonoImage  *image;
 259         MonoObject *assembly;
 260         MonoString *fqname;
 261         MonoString *name;
 262         MonoString *scopename;
 263 } MonoReflectionModule;
 264
 265 typedef struct {
 266         MonoReflectionModule module;
 267         MonoArray *types;
 268         MonoArray *cattrs;
 269         guint32    table_idx;
 270         MonoReflectionAssemblyBuilder *assemblyb;
 271 } MonoReflectionModuleBuilder;
 272
 273 typedef struct {
 274         MonoReflectionType type;
 275         MonoString *name;
 276         MonoString *nspace;
 277         MonoReflectionType *parent;
 278         MonoArray *interfaces;
 279         MonoArray *methods;
 280         MonoArray *ctors;
 281         MonoArray *properties;
 282         MonoArray *fields;
 283         MonoArray *events;
 284         MonoArray *cattrs;
 285         MonoArray *subtypes;
 286         guint32 attrs;
 287         guint32 table_idx;
 288         MonoReflectionModuleBuilder *module;
 289         gint32 class_size;
 290         gint32 packing_size;
 291 } MonoReflectionTypeBuilder;
 292
 293 typedef struct {
 294         MonoObject  obj;
 295         MonoString *name;
 296         MonoString *codebase;
 297         MonoObject *version;
 298 } MonoReflectionAssemblyName;
 299
 300 typedef struct {
 301         MonoObject  obj;
 302         MonoString *name;
 303         MonoReflectionType *type;
 304         MonoReflectionTypeBuilder *typeb;
 305         MonoArray *cattrs;
 306         MonoReflectionMethodBuilder *add_method;
 307         MonoReflectionMethodBuilder *remove_method;
 308         MonoReflectionMethodBuilder *raise_method;
 309         MonoArray *other_methods;
 310         guint32 attrs;
 311         guint32 table_idx;
 312 } MonoReflectionEventBuilder;
 313
 314 typedef struct {
 315         MonoObject  obj;
 316         MonoReflectionMethod *ctor;
 317         MonoArray *data;
 318 } MonoReflectionCustomAttr;
 319
 320 typedef struct {
 321         char *nest_name_space;
 322         char *nest_name;
 323         char *name_space;
 324         char *name;
 325         char *assembly;
 326         int rank; /* we may need more info than this */
 327         int isbyref;
 328         int ispointer;
 329 } MonoTypeNameParse;
 330
 331 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 332
 333 int           mono_image_get_header (MonoReflectionAssemblyBuilder *assembly, char *buffer, int maxsize);
 334 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 335 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 336 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 337
 338 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 339 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 340 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method);
 341 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 342 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 343 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 344 /* note: this one is slightly different: we keep the whole array of params in the cache */
 345 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 346
 347
 348 typedef MonoObject* (*MonoInvokeFunc) (MonoMethod *method, void *obj, void **params);
 349
 350 extern MonoInvokeFunc mono_default_runtime_invoke;
 351
 352 void        mono_install_runtime_invoke (MonoInvokeFunc func);
 353 MonoObject* mono_runtime_invoke         (MonoMethod *method, void *obj, void **params);
 354 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 355 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 356
 357 void        mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb);
 358
 359 #endif /* __METADATA_REFLECTION_H__ */
 360