mono/metadata/object-internals.h

   1 #ifndef __MONO_OBJECT_INTERNALS_H__
   2 #define __MONO_OBJECT_INTERNALS_H__
   3
   4 #include <mono/metadata/object.h>
   5 #include <mono/metadata/reflection.h>
   6 #include <mono/io-layer/io-layer.h>
   7
   8 #if 1
   9 #ifdef __GNUC__
  10 #define mono_assert(expr)                  G_STMT_START{                  \
  11      if (!(expr))                                                         \
  12        {                                                                  \
  13                 MonoException *ex;                                        \
  14                 char *msg = g_strdup_printf ("file %s: line %d (%s): "    \
  15                 "assertion failed: (%s)", __FILE__, __LINE__,             \
  16                 __PRETTY_FUNCTION__, #expr);                              \
  17                 ex = mono_get_exception_execution_engine (msg);           \
  18                 g_free (msg);                                             \
  19                 mono_raise_exception (ex);                                \
  20        };                               }G_STMT_END
  21
  22 #define mono_assert_not_reached()                 G_STMT_START{           \
  23      MonoException *ex;                                                   \
  24      char *msg = g_strdup_printf ("file %s: line %d (%s): "               \
  25      "should not be reached", __FILE__, __LINE__, __PRETTY_FUNCTION__);   \
  26      ex = mono_get_exception_execution_engine (msg);                      \
  27      g_free (msg);                                                        \
  28      mono_raise_exception (ex);                                           \
  29 }G_STMT_END
  30 #else /* not GNUC */
  31 #define mono_assert(expr)                  G_STMT_START{                  \
  32      if (!(expr))                                                         \
  33        {                                                                  \
  34                 MonoException *ex;                                        \
  35                 char *msg = g_strdup_printf ("file %s: line %d: "         \
  36                 "assertion failed: (%s)", __FILE__, __LINE__,             \
  37                 #expr);                                                   \
  38                 ex = mono_get_exception_execution_engine (msg);           \
  39                 g_free (msg);                                             \
  40                 mono_raise_exception (ex);                                \
  41        };                               }G_STMT_END
  42
  43 #define mono_assert_not_reached()                 G_STMT_START{           \
  44      MonoException *ex;                                                   \
  45      char *msg = g_strdup_printf ("file %s: line %d): "                   \
  46      "should not be reached", __FILE__, __LINE__);                        \
  47      ex = mono_get_exception_execution_engine (msg);                      \
  48      g_free (msg);                                                        \
  49      mono_raise_exception (ex);                                           \
  50 }G_STMT_END
  51 #endif
  52 #else
  53 #define mono_assert(expr) g_assert(expr)
  54 #define mono_assert_not_reached() g_assert_not_reached()
  55 #endif
  56
  57 #define MONO_CHECK_ARG(arg, expr)               G_STMT_START{             \
  58      if (!(expr))                                                         \
  59        {                                                                  \
  60                 MonoException *ex;                                        \
  61                 char *msg = g_strdup_printf ("assertion `%s' failed",     \
  62                 #expr);                                                   \
  63                 if (arg) {} /* check if the name exists */                \
  64                 ex = mono_get_exception_argument (#arg, msg);             \
  65                 g_free (msg);                                             \
  66                 mono_raise_exception (ex);                                \
  67        };                               }G_STMT_END
  68
  69 #define MONO_CHECK_ARG_NULL(arg)            G_STMT_START{                 \
  70      if (arg == NULL)                                                     \
  71        {                                                                  \
  72                 MonoException *ex;                                        \
  73                 if (arg) {} /* check if the name exists */                \
  74                 ex = mono_get_exception_argument_null (#arg);             \
  75                 mono_raise_exception (ex);                                \
  76        };                               }G_STMT_END
  77
  78
  79 #define mono_stringbuilder_capacity(sb) ((sb)->str->length)
  80
  81 typedef struct {
  82         MonoObject obj;
  83         MonoObject *identity;
  84 } MonoMarshalByRefObject;
  85
  86 /* This is a copy of System.AppDomain */
  87 struct _MonoAppDomain {
  88         MonoMarshalByRefObject mbr;
  89         MonoDomain *data;
  90 };
  91
  92 typedef struct {
  93         MonoObject object;
  94         gint32 length;
  95         MonoString *str;
  96 } MonoStringBuilder;
  97
  98 typedef struct {
  99         MonoType *type;
 100         gpointer  value;
 101         MonoClass *klass;
 102 } MonoTypedRef;
 103
 104 typedef struct {
 105         gpointer args;
 106 } MonoArgumentHandle;
 107
 108 typedef struct {
 109         MonoMethodSignature *sig;
 110         gpointer args;
 111         gint32 next_arg;
 112         gint32 num_args;
 113 } MonoArgIterator;
 114
 115 struct _MonoException {
 116         MonoObject object;
 117         MonoArray  *trace_ips;
 118         MonoObject *inner_ex;
 119         MonoString *message;
 120         MonoString *help_link;
 121         MonoString *class_name;
 122         MonoString *stack_trace;
 123         MonoString *remote_stack_trace;
 124         gint32      remote_stack_index;
 125         gint32      hresult;
 126         MonoString *source;
 127 };
 128
 129 typedef struct {
 130         MonoException base;
 131 } MonoSystemException;
 132
 133 typedef struct {
 134         MonoSystemException base;
 135         MonoString *param_name;
 136 } MonoArgumentException;
 137
 138 typedef struct {
 139         MonoSystemException base;
 140         MonoString *msg;
 141         MonoString *type_name;
 142 } MonoTypeLoadException;
 143
 144 typedef struct {
 145         MonoObject   object;
 146         MonoObject  *async_state;
 147         MonoObject  *handle;
 148         MonoObject  *async_delegate;
 149         gpointer     data;
 150         MonoBoolean  sync_completed;
 151         MonoBoolean  completed;
 152         MonoBoolean  endinvoke_called;
 153         MonoObject  *async_callback;
 154 } MonoAsyncResult;
 155
 156 typedef struct {
 157         MonoMarshalByRefObject object;
 158         gpointer     handle;
 159         MonoBoolean  disposed;
 160 } MonoWaitHandle;
 161
 162 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
 163 typedef enum {
 164         CallType_Sync = 0,
 165         CallType_BeginInvoke = 1,
 166         CallType_EndInvoke = 2,
 167         CallType_OneWay = 3
 168 } MonoCallType;
 169
 170 struct _MonoReflectionType {
 171         MonoObject object;
 172         MonoType  *type;
 173 };
 174
 175 typedef struct {
 176         MonoObject  object;
 177         MonoReflectionType *class_to_proxy;
 178         MonoObject *context;
 179         MonoObject *unwrapped_server;
 180 } MonoRealProxy;
 181
 182 typedef struct {
 183         MonoObject       object;
 184         MonoRealProxy   *rp;
 185         MonoRemoteClass *remote_class;
 186         MonoBoolean      custom_type_info;
 187 } MonoTransparentProxy;
 188
 189 typedef struct {
 190         MonoObject obj;
 191         MonoReflectionMethod *method;
 192         MonoArray  *args;
 193         MonoArray  *names;
 194         MonoArray  *arg_types;
 195         MonoObject *ctx;
 196         MonoObject *rval;
 197         MonoObject *exc;
 198         MonoAsyncResult *async_result;
 199         guint32     call_type;
 200 } MonoMethodMessage;
 201
 202 typedef struct {
 203         MonoObject obj;
 204         gint32 il_offset;
 205         gint32 native_offset;
 206         MonoReflectionMethod *method;
 207         MonoString *filename;
 208         gint32 line;
 209         gint32 column;
 210 } MonoStackFrame;
 211
 212 struct _MonoThread {
 213         MonoObject  obj;
 214         HANDLE      handle;
 215         MonoObject *culture_info;
 216         MonoObject *ui_culture_info;
 217         MonoBoolean threadpool_thread;
 218         gunichar2  *name;
 219         guint32     name_len;
 220         guint32     state;
 221         MonoException *abort_exc;
 222         MonoObject *abort_state;
 223         guint32 tid;
 224         HANDLE      start_notify;
 225         gpointer stack_ptr;
 226         gpointer *static_data;
 227         gpointer jit_data;
 228         gpointer lock_data;
 229         GSList *appdomain_refs;
 230         MonoBoolean interruption_requested;
 231         gpointer suspend_event;
 232         gpointer resume_event;
 233         MonoObject *synch_lock;
 234 };
 235
 236 typedef struct {
 237         MonoString *name;
 238         MonoReflectionType *type;
 239         MonoObject *value;
 240 } MonoSerializationEntry;
 241
 242 typedef struct {
 243         guint32 state;
 244         MonoObject *additional;
 245 } MonoStreamingContext;
 246
 247 typedef struct {
 248         MonoObject obj;
 249         MonoBoolean readOnly;
 250         MonoString *AMDesignator;
 251         MonoString *PMDesignator;
 252         MonoString *DateSeparator;
 253         MonoString *TimeSeparator;
 254         MonoString *ShortDatePattern;
 255         MonoString *LongDatePattern;
 256         MonoString *ShortTimePattern;
 257         MonoString *LongTimePattern;
 258         MonoString *MonthDayPattern;
 259         MonoString *YearMonthPattern;
 260         MonoString *FullDateTimePattern;
 261         MonoString *RFC1123Pattern;
 262         MonoString *SortableDateTimePattern;
 263         MonoString *UniversalSortableDateTimePattern;
 264         guint32 FirstDayOfWeek;
 265         MonoObject *Calendar;
 266         guint32 CalendarWeekRule;
 267         MonoArray *AbbreviatedDayNames;
 268         MonoArray *DayNames;
 269         MonoArray *MonthNames;
 270         MonoArray *AbbreviatedMonthNames;
 271         MonoArray *ShortDatePatterns;
 272         MonoArray *LongDatePatterns;
 273         MonoArray *ShortTimePatterns;
 274         MonoArray *LongTimePatterns;
 275 } MonoDateTimeFormatInfo;
 276
 277 typedef struct
 278 {
 279         MonoObject obj;
 280         MonoBoolean readOnly;
 281         MonoString *decimalFormats;
 282         MonoString *currencyFormats;
 283         MonoString *percentFormats;
 284         MonoString *digitPattern;
 285         MonoString *zeroPattern;
 286         gint32 currencyDecimalDigits;
 287         MonoString *currencyDecimalSeparator;
 288         MonoString *currencyGroupSeparator;
 289         MonoArray *currencyGroupSizes;
 290         gint32 currencyNegativePattern;
 291         gint32 currencyPositivePattern;
 292         MonoString *currencySymbol;
 293         MonoString *naNSymbol;
 294         MonoString *negativeInfinitySymbol;
 295         MonoString *negativeSign;
 296         guint32 numberDecimalDigits;
 297         MonoString *numberDecimalSeparator;
 298         MonoString *numberGroupSeparator;
 299         MonoArray *numberGroupSizes;
 300         gint32 numberNegativePattern;
 301         gint32 percentDecimalDigits;
 302         MonoString *percentDecimalSeparator;
 303         MonoString *percentGroupSeparator;
 304         MonoArray *percentGroupSizes;
 305         gint32 percentNegativePattern;
 306         gint32 percentPositivePattern;
 307         MonoString *percentSymbol;
 308         MonoString *perMilleSymbol;
 309         MonoString *positiveInfinitySymbol;
 310         MonoString *positiveSign;
 311 } MonoNumberFormatInfo;
 312
 313 typedef struct {
 314         MonoObject obj;
 315         gint32 lcid;
 316         MonoString *icu_name;
 317         gpointer ICU_collator;
 318 } MonoCompareInfo;
 319
 320 typedef struct {
 321         MonoObject obj;
 322         MonoBoolean is_read_only;
 323         gint32 lcid;
 324         gint32 parent_lcid;
 325         gint32 specific_lcid;
 326         gint32 datetime_index;
 327         gint32 number_index;
 328         MonoBoolean use_user_override;
 329         MonoNumberFormatInfo *number_format;
 330         MonoDateTimeFormatInfo *datetime_format;
 331         MonoObject *textinfo;
 332         MonoString *name;
 333         MonoString *displayname;
 334         MonoString *englishname;
 335         MonoString *nativename;
 336         MonoString *iso3lang;
 337         MonoString *iso2lang;
 338         MonoString *icu_name;
 339         MonoString *win3lang;
 340         MonoCompareInfo *compareinfo;
 341         const gint32 *calendar_data;
 342 } MonoCultureInfo;
 343
 344 typedef struct {
 345         MonoObject obj;
 346         MonoString *str;
 347         gint32 options;
 348         MonoArray *key;
 349         gint32 lcid;
 350 } MonoSortKey;
 351
 352 /* remoting and async support */
 353
 354 MonoAsyncResult *
 355 mono_async_result_new       (MonoDomain *domain, HANDLE handle,
 356                              MonoObject *state, gpointer data);
 357
 358 MonoWaitHandle *
 359 mono_wait_handle_new        (MonoDomain *domain, HANDLE handle);
 360
 361 void
 362 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 363                              MonoReflectionMethod *method, MonoArray *out_args);
 364
 365 MonoObject *
 366 mono_remoting_invoke        (MonoObject *real_proxy, MonoMethodMessage *msg,
 367                              MonoObject **exc, MonoArray **out_args);
 368
 369 MonoObject *
 370 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg,
 371                              MonoObject **exc, MonoArray **out_args);
 372
 373 MonoMethodMessage *
 374 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 375                               MonoDelegate **cb, MonoObject **state);
 376
 377 void
 378 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args);
 379
 380 void
 381 mono_delegate_ctor          (MonoObject *this_obj, MonoObject *target, gpointer addr);
 382
 383 /* runtime initialization functions */
 384 typedef void (*MonoExceptionFunc) (MonoException *ex);
 385
 386 void
 387 mono_install_handler        (MonoExceptionFunc func);
 388
 389 void
 390 mono_install_runtime_invoke (MonoInvokeFunc func);
 391
 392 void
 393 mono_install_compile_method (MonoCompileFunc func);
 394
 395 void
 396 mono_type_initialization_init (void);
 397
 398 /* Reflection and Reflection.Emit support */
 399
 400 /*
 401  * The followinbg structure must match the C# implementation in our corlib.
 402  */
 403
 404 struct _MonoReflectionMethod {
 405         MonoObject object;
 406         MonoMethod *method;
 407         MonoString *name;
 408         MonoReflectionType *reftype;
 409 };
 410
 411 struct _MonoDelegate {
 412         MonoObject object;
 413         MonoObject *target_type;
 414         MonoObject *target;
 415         MonoString *method_name;
 416         gpointer method_ptr;
 417         gpointer delegate_trampoline;
 418         MonoReflectionMethod *method_info;
 419 };
 420
 421 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
 422 struct _MonoMulticastDelegate {
 423         MonoDelegate delegate;
 424         MonoMulticastDelegate *prev;
 425 };
 426
 427 struct _MonoReflectionField {
 428         MonoObject object;
 429         MonoClass *klass;
 430         MonoClassField *field;
 431         MonoString *name;
 432         MonoReflectionType *type;
 433         guint32 attrs;
 434 };
 435
 436 struct _MonoReflectionProperty {
 437         MonoObject object;
 438         MonoClass *klass;
 439         MonoProperty *property;
 440 };
 441
 442 struct _MonoReflectionEvent {
 443         MonoObject object;
 444         MonoClass *klass;
 445         MonoEvent *event;
 446 };
 447
 448 typedef struct {
 449         MonoObject object;
 450         MonoReflectionType *ClassImpl;
 451         MonoObject *DefaultValueImpl;
 452         MonoObject *MemberImpl;
 453         MonoString *NameImpl;
 454         gint32 PositionImpl;
 455         guint32 AttrsImpl;
 456 } MonoReflectionParameter;
 457
 458 struct _MonoReflectionAssembly {
 459         MonoObject object;
 460         MonoAssembly *assembly;
 461         MonoObject *resolve_event_holder;
 462 };
 463
 464 typedef struct {
 465         MonoReflectionType *utype;
 466         MonoArray *values;
 467         MonoArray *names;
 468 } MonoEnumInfo;
 469
 470 typedef struct {
 471         MonoReflectionType *parent;
 472         MonoReflectionType *ret;
 473         guint32 attrs;
 474         guint32 implattrs;
 475         guint32 callconv;
 476 } MonoMethodInfo;
 477
 478 typedef struct {
 479         MonoReflectionType *parent;
 480         MonoString *name;
 481         MonoReflectionMethod *get;
 482         MonoReflectionMethod *set;
 483         guint32 attrs;
 484 } MonoPropertyInfo;
 485
 486 typedef struct {
 487         MonoReflectionType *declaring_type;
 488         MonoReflectionType *reflected_type;
 489         MonoString *name;
 490         MonoReflectionMethod *add_method;
 491         MonoReflectionMethod *remove_method;
 492         MonoReflectionMethod *raise_method;
 493         guint32 attrs;
 494 } MonoEventInfo;
 495
 496 typedef struct {
 497         MonoString *name;
 498         MonoString *name_space;
 499         MonoReflectionType *etype;
 500         MonoReflectionType *nested_in;
 501         MonoReflectionAssembly *assembly;
 502         guint32 rank;
 503         MonoBoolean isprimitive;
 504 } MonoTypeInfo;
 505
 506 typedef struct {
 507         MonoObject *member;
 508         gint32 code_pos;
 509 } MonoReflectionILTokenInfo;
 510
 511 typedef struct {
 512         MonoObject object;
 513         MonoArray *code;
 514         gint32 code_len;
 515         gint32 max_stack;
 516         gint32 cur_stack;
 517         MonoArray *locals;
 518         MonoArray *ex_handlers;
 519         gint32 num_token_fixups;
 520         MonoArray *token_fixups;
 521 } MonoReflectionILGen;
 522
 523 typedef struct {
 524         MonoArray *handlers;
 525         gint32 start;
 526         gint32 len;
 527         gint32 label;
 528 } MonoILExceptionInfo;
 529
 530 typedef struct {
 531         MonoReflectionType *extype;
 532         gint32 type;
 533         gint32 start;
 534         gint32 len;
 535         gint32 filter_offset;
 536 } MonoILExceptionBlock;
 537
 538 typedef struct {
 539         MonoObject object;
 540         MonoReflectionType *type;
 541         MonoString *name;
 542         MonoBoolean is_pinned;
 543 } MonoReflectionLocalBuilder;
 544
 545 typedef struct {
 546         MonoObject object;
 547         gint32 count;
 548         gint32 type;
 549         gint32 eltype;
 550         MonoString *guid;
 551         MonoString *mcookie;
 552         MonoString *marshaltype;
 553         MonoReflectionType *marshaltyperef;
 554 } MonoReflectionMarshal;
 555
 556 typedef struct {
 557         MonoObject object;
 558         MonoObject* methodb;
 559         MonoString *name;
 560         MonoArray *cattrs;
 561         MonoReflectionMarshal *marshal_info;
 562         guint32 attrs;
 563         int position;
 564         guint32 table_idx;
 565         MonoObject *def_value;
 566 } MonoReflectionParamBuilder;
 567
 568 typedef struct {
 569         MonoObject object;
 570         MonoMethod *mhandle;
 571         MonoReflectionILGen *ilgen;
 572         MonoArray *parameters;
 573         guint32 attrs;
 574         guint32 iattrs;
 575         guint32 table_idx;
 576         guint32 call_conv;
 577         MonoObject *type;
 578         MonoArray *pinfo;
 579         MonoArray *cattrs;
 580         MonoBoolean init_locals;
 581         MonoArray *param_modreq;
 582         MonoArray *param_modopt;
 583         MonoArray *permissions;
 584 } MonoReflectionCtorBuilder;
 585
 586 typedef struct {
 587         MonoObject object;
 588         MonoMethod *mhandle;
 589         MonoReflectionType *rtype;
 590         MonoArray *parameters;
 591         guint32 attrs;
 592         guint32 iattrs;
 593         MonoString *name;
 594         guint32 table_idx;
 595         MonoArray *code;
 596         MonoReflectionILGen *ilgen;
 597         MonoObject *type;
 598         MonoArray *pinfo;
 599         MonoArray *cattrs;
 600         MonoReflectionMethod *override_method;
 601         MonoString *dll;
 602         MonoString *dllentry;
 603         guint32 charset;
 604         guint32 native_cc;
 605         guint32 call_conv;
 606         MonoBoolean init_locals;
 607         MonoArray *generic_params;
 608         MonoArray *return_modreq;
 609         MonoArray *return_modopt;
 610         MonoArray *param_modreq;
 611         MonoArray *param_modopt;
 612         MonoArray *permissions;
 613 } MonoReflectionMethodBuilder;
 614
 615 typedef struct {
 616         MonoObject object;
 617         MonoMethod *mhandle;
 618         MonoReflectionType *parent;
 619         MonoReflectionType *ret;
 620         MonoArray *parameters;
 621         MonoString *name;
 622         guint32 table_idx;
 623         guint32 call_conv;
 624 } MonoReflectionArrayMethod;
 625
 626 typedef struct {
 627         MonoArray *data;
 628         MonoString *name;
 629         MonoString *filename;
 630         guint32 attrs;
 631         guint32 offset;
 632 } MonoReflectionResource;
 633
 634 typedef struct {
 635         guint32 res_type;
 636         guint32 res_id;
 637         guint32 lang_id;
 638         MonoArray *res_data;
 639 } MonoReflectionWin32Resource;
 640
 641 typedef struct {
 642         guint32 action;
 643         MonoString *pset;
 644 } MonoReflectionPermissionSet;
 645
 646 typedef struct {
 647         MonoReflectionAssembly assembly;
 648         MonoDynamicAssembly *dynamic_assembly;
 649         MonoReflectionMethod *entry_point;
 650         MonoArray *modules;
 651         MonoString *name;
 652         MonoString *dir;
 653         MonoArray *cattrs;
 654         MonoArray *resources;
 655         MonoArray *public_key;
 656         MonoString *version;
 657         MonoString *culture;
 658         guint32 algid;
 659         guint32 flags;
 660         guint32 pekind;
 661         MonoBoolean delay_sign;
 662         guint32 access;
 663         MonoArray *loaded_modules;
 664         MonoArray *win32_resources;
 665 } MonoReflectionAssemblyBuilder;
 666
 667 typedef struct {
 668         MonoObject object;
 669         guint32 attrs;
 670         MonoReflectionType *type;
 671         MonoString *name;
 672         MonoObject *def_value;
 673         gint32 offset;
 674         gint32 table_idx;
 675         MonoReflectionType *typeb;
 676         MonoArray *rva_data;
 677         MonoArray *cattrs;
 678         MonoReflectionMarshal *marshal_info;
 679         MonoClassField *handle;
 680         MonoArray *modreq;
 681         MonoArray *modopt;
 682 } MonoReflectionFieldBuilder;
 683
 684 typedef struct {
 685         MonoObject object;
 686         guint32 attrs;
 687         MonoString *name;
 688         MonoReflectionType *type;
 689         MonoArray *parameters;
 690         MonoArray *cattrs;
 691         MonoObject *def_value;
 692         MonoReflectionMethodBuilder *set_method;
 693         MonoReflectionMethodBuilder *get_method;
 694         gint32 table_idx;
 695 } MonoReflectionPropertyBuilder;
 696
 697 struct _MonoReflectionModule {
 698         MonoObject      obj;
 699         MonoImage  *image;
 700         MonoReflectionAssembly *assembly;
 701         MonoString *fqname;
 702         MonoString *name;
 703         MonoString *scopename;
 704         MonoBoolean is_resource;
 705 };
 706
 707 typedef struct {
 708         MonoReflectionModule module;
 709         MonoDynamicImage *dynamic_image;
 710         gint32     num_types;
 711         MonoArray *types;
 712         MonoArray *cattrs;
 713         MonoArray *guid;
 714         guint32    table_idx;
 715         MonoReflectionAssemblyBuilder *assemblyb;
 716         MonoArray *global_methods;
 717         MonoArray *global_fields;
 718         gboolean is_main;
 719         MonoArray *resources;
 720 } MonoReflectionModuleBuilder;
 721
 722 typedef struct {
 723         MonoReflectionType type;
 724         MonoString *name;
 725         MonoString *nspace;
 726         MonoReflectionType *parent;
 727         MonoReflectionType *nesting_type;
 728         MonoArray *interfaces;
 729         gint32     num_methods;
 730         MonoArray *methods;
 731         MonoArray *ctors;
 732         MonoArray *properties;
 733         gint32     num_fields;
 734         MonoArray *fields;
 735         MonoArray *events;
 736         MonoArray *cattrs;
 737         MonoArray *subtypes;
 738         guint32 attrs;
 739         guint32 table_idx;
 740         MonoReflectionModuleBuilder *module;
 741         gint32 class_size;
 742         gint32 packing_size;
 743         MonoArray *generic_params;
 744         MonoArray *permissions;
 745 } MonoReflectionTypeBuilder;
 746
 747 typedef struct {
 748         MonoReflectionType type;
 749         MonoReflectionTypeBuilder *tbuilder;
 750         MonoReflectionMethodBuilder *mbuilder;
 751         MonoString *name;
 752         guint32 index;
 753         MonoReflectionType *base_type;
 754         MonoArray *iface_constraints;
 755         MonoBoolean has_ctor_constraint;
 756         MonoBoolean has_reference_type;
 757         MonoBoolean has_value_type;
 758 } MonoReflectionGenericParam;
 759
 760 typedef struct _MonoReflectionGenericInst MonoReflectionGenericInst;
 761 struct _MonoReflectionGenericInst {
 762         MonoReflectionType type;
 763         MonoReflectionType *generic_type;
 764         guint32 initialized;
 765 };
 766
 767 typedef struct {
 768         MonoObject  obj;
 769         MonoString *name;
 770         MonoString *codebase;
 771         gint32 major, minor, build, revision;
 772         /* FIXME: add missing stuff */
 773 /*      CultureInfo cultureinfo;
 774         AssemblyNameFlags flags;
 775         AssemblyHashAlgorithm hashalg;
 776         StrongNameKeyPair keypair;
 777         AssemblyVersionCompatibility versioncompat;*/
 778         MonoObject  *cultureInfo;
 779         guint32     flags;
 780         guint32     hashalg;
 781         MonoObject  *keypair;
 782         MonoArray   *publicKey;
 783         MonoArray   *keyToken;
 784         MonoObject  *versioncompat;
 785 } MonoReflectionAssemblyName;
 786
 787 typedef struct {
 788         MonoObject  obj;
 789         MonoString *name;
 790         MonoReflectionType *type;
 791         MonoReflectionTypeBuilder *typeb;
 792         MonoArray *cattrs;
 793         MonoReflectionMethodBuilder *add_method;
 794         MonoReflectionMethodBuilder *remove_method;
 795         MonoReflectionMethodBuilder *raise_method;
 796         MonoArray *other_methods;
 797         guint32 attrs;
 798         guint32 table_idx;
 799 } MonoReflectionEventBuilder;
 800
 801 typedef struct {
 802         MonoObject  obj;
 803         MonoReflectionMethod *ctor;
 804         MonoArray *data;
 805 } MonoReflectionCustomAttr;
 806
 807 typedef struct {
 808         MonoObject object;
 809         MonoMethod *mhandle;
 810         MonoString *name;
 811         MonoReflectionType *rtype;
 812         MonoArray *parameters;
 813         guint32 attrs;
 814         guint32 call_conv;
 815         MonoReflectionModule *module;
 816         MonoBoolean skip_visibility;
 817         MonoBoolean init_locals;
 818         MonoReflectionILGen *ilgen;
 819         gint32 nrefs;
 820         MonoArray *refs;
 821 } MonoReflectionDynamicMethod;
 822
 823 typedef struct {
 824         MonoObject object;
 825         MonoReflectionModuleBuilder *module;
 826         MonoArray *arguments;
 827         guint32 type;
 828         MonoReflectionType *return_type;
 829         guint32 call_conv;
 830         guint32 unmanaged_call_conv;
 831 } MonoReflectionSigHelper;
 832
 833 enum {
 834         RESOURCE_LOCATION_EMBEDDED = 1,
 835         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
 836         RESOURCE_LOCATION_IN_MANIFEST = 4
 837 };
 838
 839 typedef struct {
 840         MonoObject object;
 841         MonoReflectionAssembly *assembly;
 842         MonoString *filename;
 843         guint32 location;
 844 } MonoManifestResourceInfo;
 845
 846 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module);
 847 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 848 MonoReflectionModule * mono_image_load_module (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name);
 849 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str);
 850 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj);
 851 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types);
 852 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
 853
 854 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 855
 856 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 857
 858 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb);
 859
 860 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 861
 862 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
 863
 864 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
 865
 866 MonoType*
 867 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types);
 868 MonoReflectionMethod*
 869 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
 870 void
 871 mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
 872 MonoReflectionEvent *
 873 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
 874
 875 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 876
 877 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 878
 879 gpointer
 880 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token);
 881
 882 void
 883 mono_image_build_metadata (MonoReflectionModuleBuilder *module);
 884
 885 #endif /* __MONO_OBJECT_INTERNALS_H__ */
 886