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 typedef struct {
  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 } MonoDelegate;
  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         MonoReflectionType *type;
 110         MonoString *name;
 111         guint32 attrs;
 112 } MonoFieldInfo;
 113
 114 typedef struct {
 115         MonoString *name;
 116         MonoString *name_space;
 117         MonoReflectionType *parent;
 118         MonoReflectionType *etype;
 119         MonoReflectionAssembly *assembly;
 120         guint32 attrs;
 121         guint32 rank;
 122         MonoBoolean isbyref, ispointer, isprimitive;
 123 } MonoTypeInfo;
 124
 125 typedef struct {
 126         MonoObject *member;
 127         gint32 code_pos;
 128 } MonoReflectionILTokenInfo;
 129
 130 typedef struct {
 131         MonoObject object;
 132         MonoArray *code;
 133         MonoObject *mbuilder;
 134         gint32 code_len;
 135         gint32 max_stack;
 136         gint32 cur_stack;
 137         MonoArray *locals;
 138         MonoArray *ex_handlers;
 139         gint32 num_token_fixups;
 140         MonoArray *token_fixups;
 141 } MonoReflectionILGen;
 142
 143 typedef struct {
 144         MonoArray *handlers;
 145         gint32 start;
 146         gint32 len;
 147         gint32 label;
 148 } MonoILExceptionInfo;
 149
 150 typedef struct {
 151         MonoReflectionType *extype;
 152         gint32 type;
 153         gint32 start;
 154         gint32 len;
 155         gint32 filter_offset;
 156 } MonoILExceptionBlock;
 157
 158 typedef struct {
 159         MonoObject object;
 160         MonoReflectionType *type;
 161         MonoString *name;
 162 } MonoReflectionLocalBuilder;
 163
 164 typedef struct {
 165         MonoObject object;
 166         MonoObject* methodb;
 167         MonoString *name;
 168         MonoArray *cattrs;
 169         guint32 attrs;
 170         int position;
 171         guint32 table_idx;
 172 } MonoReflectionParamBuilder;
 173
 174 typedef struct {
 175         MonoObject object;
 176         MonoReflectionILGen *ilgen;
 177         MonoArray *parameters;
 178         guint32 attrs;
 179         guint32 iattrs;
 180         guint32 table_idx;
 181         guint32 call_conv;
 182         MonoObject *type;
 183         MonoArray *pinfo;
 184         MonoArray *cattrs;
 185         MonoBoolean init_locals;
 186 } MonoReflectionCtorBuilder;
 187
 188 typedef struct {
 189         MonoObject object;
 190         MonoMethod *mhandle;
 191         MonoReflectionType *rtype;
 192         MonoArray *parameters;
 193         guint32 attrs;
 194         guint32 iattrs;
 195         MonoString *name;
 196         guint32 table_idx;
 197         MonoArray *code;
 198         MonoReflectionILGen *ilgen;
 199         MonoObject *type;
 200         MonoArray *pinfo;
 201         MonoArray *cattrs;
 202         MonoReflectionMethod *override_method;
 203         MonoString *dll;
 204         MonoString *dllentry;
 205         guint32 charset;
 206         guint32 native_cc;
 207         guint32 call_conv;
 208         MonoBoolean init_locals;
 209 } MonoReflectionMethodBuilder;
 210
 211 typedef struct {
 212         MonoAssembly assembly;
 213         guint32 meta_size;
 214         guint32 text_rva;
 215         guint32 metadata_rva;
 216         GHashTable *typeref;
 217         GHashTable *handleref;
 218         MonoGHashTable *token_fixups;
 219         MonoDynamicStream sheap;
 220         MonoDynamicStream code; /* used to store method headers and bytecode */
 221         MonoDynamicStream us;
 222         MonoDynamicStream blob;
 223         MonoDynamicStream tstream;
 224         MonoDynamicStream guid;
 225         MonoDynamicTable tables [64];
 226 } MonoDynamicAssembly;
 227
 228 typedef struct {
 229         MonoReflectionAssembly assembly;
 230         MonoDynamicAssembly *dynamic_assembly;
 231         MonoReflectionMethodBuilder *entry_point;
 232         MonoArray *modules;
 233         MonoString *name;
 234         MonoString *dir;
 235         MonoArray *cattrs;
 236 } MonoReflectionAssemblyBuilder;
 237
 238 typedef struct {
 239         MonoObject object;
 240         guint32 attrs;
 241         MonoReflectionType *type;
 242         MonoString *name;
 243         MonoObject *def_value;
 244         gint32 offset;
 245         gint32 table_idx;
 246         MonoReflectionType *typeb;
 247         MonoArray *rva_data;
 248         MonoArray *cattrs;
 249 } MonoReflectionFieldBuilder;
 250
 251 typedef struct {
 252         MonoObject object;
 253         guint32 attrs;
 254         MonoString *name;
 255         MonoReflectionType *type;
 256         MonoArray *parameters;
 257         MonoArray *cattrs;
 258         MonoObject *def_value;
 259         MonoReflectionMethodBuilder *set_method;
 260         MonoReflectionMethodBuilder *get_method;
 261         gint32 table_idx;
 262 } MonoReflectionPropertyBuilder;
 263
 264 typedef struct {
 265         MonoObject      obj;
 266         MonoImage  *image;
 267         MonoObject *assembly;
 268         MonoString *fqname;
 269         MonoString *name;
 270         MonoString *scopename;
 271 } MonoReflectionModule;
 272
 273 typedef struct {
 274         MonoReflectionModule module;
 275         MonoArray *types;
 276         MonoArray *cattrs;
 277         MonoArray *guid;
 278         guint32    table_idx;
 279         MonoReflectionAssemblyBuilder *assemblyb;
 280 } MonoReflectionModuleBuilder;
 281
 282 typedef struct {
 283         MonoReflectionType type;
 284         MonoString *name;
 285         MonoString *nspace;
 286         MonoReflectionType *parent;
 287         MonoArray *interfaces;
 288         MonoArray *methods;
 289         MonoArray *ctors;
 290         MonoArray *properties;
 291         MonoArray *fields;
 292         MonoArray *events;
 293         MonoArray *cattrs;
 294         MonoArray *subtypes;
 295         guint32 attrs;
 296         guint32 table_idx;
 297         MonoReflectionModuleBuilder *module;
 298         gint32 class_size;
 299         gint32 packing_size;
 300 } MonoReflectionTypeBuilder;
 301
 302 typedef struct {
 303         MonoObject  obj;
 304         MonoString *name;
 305         MonoString *codebase;
 306         gint32 major, minor, build, revision;
 307         /* FIXME: add missing stuff */
 308 } MonoReflectionAssemblyName;
 309
 310 typedef struct {
 311         MonoObject  obj;
 312         MonoString *name;
 313         MonoReflectionType *type;
 314         MonoReflectionTypeBuilder *typeb;
 315         MonoArray *cattrs;
 316         MonoReflectionMethodBuilder *add_method;
 317         MonoReflectionMethodBuilder *remove_method;
 318         MonoReflectionMethodBuilder *raise_method;
 319         MonoArray *other_methods;
 320         guint32 attrs;
 321         guint32 table_idx;
 322 } MonoReflectionEventBuilder;
 323
 324 typedef struct {
 325         MonoObject  obj;
 326         MonoReflectionMethod *ctor;
 327         MonoArray *data;
 328 } MonoReflectionCustomAttr;
 329
 330 typedef struct {
 331         char *nest_name_space;
 332         char *nest_name;
 333         char *name_space;
 334         char *name;
 335         char *assembly;
 336         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 337 } MonoTypeNameParse;
 338
 339 typedef struct {
 340         MonoObject object;
 341         MonoReflectionModuleBuilder *module;
 342         MonoArray *arguments;
 343         guint32 type;
 344 } MonoReflectionSigHelper;
 345
 346
 347
 348 char*         mono_type_get_name         (MonoType *type);
 349 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 350 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 351
 352 int           mono_image_get_header (MonoReflectionAssemblyBuilder *assembly, char *buffer, int maxsize);
 353 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 354 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 355 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 356
 357 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 358 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 359 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method);
 360 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 361 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 362 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 363 /* note: this one is slightly different: we keep the whole array of params in the cache */
 364 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 365
 366 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 367 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 368
 369 void        mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb);
 370
 371 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 372
 373 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 374
 375 #endif /* __METADATA_REFLECTION_H__ */
 376