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