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 } MonoReflectionCtorBuilder;
 186
 187 typedef struct {
 188         MonoObject object;
 189         MonoMethod *mhandle;
 190         MonoReflectionType *rtype;
 191         MonoArray *parameters;
 192         guint32 attrs;
 193         guint32 iattrs;
 194         MonoString *name;
 195         guint32 table_idx;
 196         MonoArray *code;
 197         MonoReflectionILGen *ilgen;
 198         MonoObject *type;
 199         MonoArray *pinfo;
 200         MonoArray *cattrs;
 201         MonoReflectionMethod *override_method;
 202         MonoString *dll;
 203         MonoString *dllentry;
 204         guint32 charset;
 205         guint32 native_cc;
 206         guint32 call_conv;
 207 } MonoReflectionMethodBuilder;
 208
 209 typedef struct {
 210         MonoAssembly assembly;
 211         guint32 meta_size;
 212         guint32 text_rva;
 213         guint32 metadata_rva;
 214         GHashTable *typeref;
 215         GHashTable *handleref;
 216         MonoGHashTable *token_fixups;
 217         MonoDynamicStream sheap;
 218         MonoDynamicStream code; /* used to store method headers and bytecode */
 219         MonoDynamicStream us;
 220         MonoDynamicStream blob;
 221         MonoDynamicStream tstream;
 222         MonoDynamicStream guid;
 223         MonoDynamicTable tables [64];
 224 } MonoDynamicAssembly;
 225
 226 typedef struct {
 227         MonoReflectionAssembly assembly;
 228         MonoDynamicAssembly *dynamic_assembly;
 229         MonoReflectionMethodBuilder *entry_point;
 230         MonoArray *modules;
 231         MonoString *name;
 232         MonoString *dir;
 233         MonoArray *cattrs;
 234 } MonoReflectionAssemblyBuilder;
 235
 236 typedef struct {
 237         MonoObject object;
 238         guint32 attrs;
 239         MonoReflectionType *type;
 240         MonoString *name;
 241         MonoObject *def_value;
 242         gint32 offset;
 243         gint32 table_idx;
 244         MonoReflectionType *typeb;
 245         MonoArray *rva_data;
 246         MonoArray *cattrs;
 247 } MonoReflectionFieldBuilder;
 248
 249 typedef struct {
 250         MonoObject object;
 251         guint32 attrs;
 252         MonoString *name;
 253         MonoReflectionType *type;
 254         MonoArray *parameters;
 255         MonoArray *cattrs;
 256         MonoObject *def_value;
 257         MonoReflectionMethodBuilder *set_method;
 258         MonoReflectionMethodBuilder *get_method;
 259         gint32 table_idx;
 260 } MonoReflectionPropertyBuilder;
 261
 262 typedef struct {
 263         MonoObject      obj;
 264         MonoImage  *image;
 265         MonoObject *assembly;
 266         MonoString *fqname;
 267         MonoString *name;
 268         MonoString *scopename;
 269 } MonoReflectionModule;
 270
 271 typedef struct {
 272         MonoReflectionModule module;
 273         MonoArray *types;
 274         MonoArray *cattrs;
 275         MonoArray *guid;
 276         guint32    table_idx;
 277         MonoReflectionAssemblyBuilder *assemblyb;
 278 } MonoReflectionModuleBuilder;
 279
 280 typedef struct {
 281         MonoReflectionType type;
 282         MonoString *name;
 283         MonoString *nspace;
 284         MonoReflectionType *parent;
 285         MonoArray *interfaces;
 286         MonoArray *methods;
 287         MonoArray *ctors;
 288         MonoArray *properties;
 289         MonoArray *fields;
 290         MonoArray *events;
 291         MonoArray *cattrs;
 292         MonoArray *subtypes;
 293         guint32 attrs;
 294         guint32 table_idx;
 295         MonoReflectionModuleBuilder *module;
 296         gint32 class_size;
 297         gint32 packing_size;
 298 } MonoReflectionTypeBuilder;
 299
 300 typedef struct {
 301         MonoObject  obj;
 302         MonoString *name;
 303         MonoString *codebase;
 304         gint32 major, minor, build, revision;
 305         /* FIXME: add missing stuff */
 306 } MonoReflectionAssemblyName;
 307
 308 typedef struct {
 309         MonoObject  obj;
 310         MonoString *name;
 311         MonoReflectionType *type;
 312         MonoReflectionTypeBuilder *typeb;
 313         MonoArray *cattrs;
 314         MonoReflectionMethodBuilder *add_method;
 315         MonoReflectionMethodBuilder *remove_method;
 316         MonoReflectionMethodBuilder *raise_method;
 317         MonoArray *other_methods;
 318         guint32 attrs;
 319         guint32 table_idx;
 320 } MonoReflectionEventBuilder;
 321
 322 typedef struct {
 323         MonoObject  obj;
 324         MonoReflectionMethod *ctor;
 325         MonoArray *data;
 326 } MonoReflectionCustomAttr;
 327
 328 typedef struct {
 329         char *nest_name_space;
 330         char *nest_name;
 331         char *name_space;
 332         char *name;
 333         char *assembly;
 334         GList *modifiers; /* 0 -> byref, -1 -> pointer, > 0 -> array rank */
 335 } MonoTypeNameParse;
 336
 337 typedef struct {
 338         MonoObject object;
 339         MonoReflectionModuleBuilder *module;
 340         MonoArray *arguments;
 341         guint32 type;
 342 } MonoReflectionSigHelper;
 343
 344
 345
 346 char*         mono_type_get_name         (MonoType *type);
 347 int           mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
 348 MonoType*     mono_reflection_get_type   (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase);
 349
 350 int           mono_image_get_header (MonoReflectionAssemblyBuilder *assembly, char *buffer, int maxsize);
 351 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 352 guint32       mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str);
 353 guint32       mono_image_create_token  (MonoDynamicAssembly *assembly, MonoObject *obj);
 354
 355 MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly);
 356 MonoReflectionType*     mono_type_get_object     (MonoDomain *domain, MonoType *type);
 357 MonoReflectionMethod*   mono_method_get_object   (MonoDomain *domain, MonoMethod *method);
 358 MonoReflectionField*    mono_field_get_object    (MonoDomain *domain, MonoClass *klass, MonoClassField *field);
 359 MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property);
 360 MonoReflectionEvent*    mono_event_get_object    (MonoDomain *domain, MonoClass *klass, MonoEvent *event);
 361 /* note: this one is slightly different: we keep the whole array of params in the cache */
 362 MonoReflectionParameter** mono_param_get_objects  (MonoDomain *domain, MonoMethod *method);
 363
 364 MonoArray*  mono_reflection_get_custom_attrs (MonoObject *obj);
 365 MonoArray*  mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues);
 366
 367 void        mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb);
 368
 369 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 370
 371 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 372
 373 #endif /* __METADATA_REFLECTION_H__ */
 374