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_install_free_method    (MonoFreeMethodFunc func);
 397
 398 void
 399 mono_type_initialization_init (void);
 400
 401 /* Reflection and Reflection.Emit support */
 402
 403 /*
 404  * The followinbg structure must match the C# implementation in our corlib.
 405  */
 406
 407 struct _MonoReflectionMethod {
 408         MonoObject object;
 409         MonoMethod *method;
 410         MonoString *name;
 411         MonoReflectionType *reftype;
 412 };
 413
 414 struct _MonoDelegate {
 415         MonoObject object;
 416         MonoObject *target_type;
 417         MonoObject *target;
 418         MonoString *method_name;
 419         gpointer method_ptr;
 420         gpointer delegate_trampoline;
 421         MonoReflectionMethod *method_info;
 422 };
 423
 424 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
 425 struct _MonoMulticastDelegate {
 426         MonoDelegate delegate;
 427         MonoMulticastDelegate *prev;
 428 };
 429
 430 struct _MonoReflectionField {
 431         MonoObject object;
 432         MonoClass *klass;
 433         MonoClassField *field;
 434         MonoString *name;
 435         MonoReflectionType *type;
 436         guint32 attrs;
 437 };
 438
 439 struct _MonoReflectionProperty {
 440         MonoObject object;
 441         MonoClass *klass;
 442         MonoProperty *property;
 443 };
 444
 445 struct _MonoReflectionEvent {
 446         MonoObject object;
 447         MonoClass *klass;
 448         MonoEvent *event;
 449 };
 450
 451 typedef struct {
 452         MonoObject object;
 453         MonoReflectionType *ClassImpl;
 454         MonoObject *DefaultValueImpl;
 455         MonoObject *MemberImpl;
 456         MonoString *NameImpl;
 457         gint32 PositionImpl;
 458         guint32 AttrsImpl;
 459 } MonoReflectionParameter;
 460
 461 struct _MonoReflectionAssembly {
 462         MonoObject object;
 463         MonoAssembly *assembly;
 464         MonoObject *resolve_event_holder;
 465         /* CAS related */
 466         MonoObject *evidence;   /* Evidence */
 467         MonoObject *minimum;    /* PermissionSet - for SecurityAction.RequestMinimum */
 468         MonoObject *optional;   /* PermissionSet - for SecurityAction.RequestOptional */
 469         MonoObject *refuse;     /* PermissionSet - for SecurityAction.RequestRefuse */
 470         MonoObject *granted;    /* PermissionSet - for the resolved assembly granted permissions */
 471         MonoObject *denied;     /* PermissionSet - for the resolved assembly denied permissions */
 472 };
 473
 474 typedef struct {
 475         MonoReflectionType *utype;
 476         MonoArray *values;
 477         MonoArray *names;
 478 } MonoEnumInfo;
 479
 480 typedef struct {
 481         MonoReflectionType *parent;
 482         MonoReflectionType *ret;
 483         guint32 attrs;
 484         guint32 implattrs;
 485         guint32 callconv;
 486 } MonoMethodInfo;
 487
 488 typedef struct {
 489         MonoReflectionType *parent;
 490         MonoString *name;
 491         MonoReflectionMethod *get;
 492         MonoReflectionMethod *set;
 493         guint32 attrs;
 494 } MonoPropertyInfo;
 495
 496 typedef struct {
 497         MonoReflectionType *declaring_type;
 498         MonoReflectionType *reflected_type;
 499         MonoString *name;
 500         MonoReflectionMethod *add_method;
 501         MonoReflectionMethod *remove_method;
 502         MonoReflectionMethod *raise_method;
 503         guint32 attrs;
 504 } MonoEventInfo;
 505
 506 typedef struct {
 507         MonoString *name;
 508         MonoString *name_space;
 509         MonoReflectionType *etype;
 510         MonoReflectionType *nested_in;
 511         MonoReflectionAssembly *assembly;
 512         guint32 rank;
 513         MonoBoolean isprimitive;
 514 } MonoTypeInfo;
 515
 516 typedef struct {
 517         MonoObject *member;
 518         gint32 code_pos;
 519 } MonoReflectionILTokenInfo;
 520
 521 typedef struct {
 522         MonoObject object;
 523         MonoArray *code;
 524         gint32 code_len;
 525         gint32 max_stack;
 526         gint32 cur_stack;
 527         MonoArray *locals;
 528         MonoArray *ex_handlers;
 529         gint32 num_token_fixups;
 530         MonoArray *token_fixups;
 531 } MonoReflectionILGen;
 532
 533 typedef struct {
 534         MonoArray *handlers;
 535         gint32 start;
 536         gint32 len;
 537         gint32 label;
 538 } MonoILExceptionInfo;
 539
 540 typedef struct {
 541         MonoReflectionType *extype;
 542         gint32 type;
 543         gint32 start;
 544         gint32 len;
 545         gint32 filter_offset;
 546 } MonoILExceptionBlock;
 547
 548 typedef struct {
 549         MonoObject object;
 550         MonoReflectionType *type;
 551         MonoString *name;
 552         MonoBoolean is_pinned;
 553 } MonoReflectionLocalBuilder;
 554
 555 typedef struct {
 556         MonoObject object;
 557         gint32 count;
 558         gint32 type;
 559         gint32 eltype;
 560         MonoString *guid;
 561         MonoString *mcookie;
 562         MonoString *marshaltype;
 563         MonoReflectionType *marshaltyperef;
 564 } MonoReflectionMarshal;
 565
 566 typedef struct {
 567         MonoObject object;
 568         MonoObject* methodb;
 569         MonoString *name;
 570         MonoArray *cattrs;
 571         MonoReflectionMarshal *marshal_info;
 572         guint32 attrs;
 573         int position;
 574         guint32 table_idx;
 575         MonoObject *def_value;
 576 } MonoReflectionParamBuilder;
 577
 578 typedef struct {
 579         MonoObject object;
 580         MonoMethod *mhandle;
 581         MonoReflectionILGen *ilgen;
 582         MonoArray *parameters;
 583         guint32 attrs;
 584         guint32 iattrs;
 585         guint32 table_idx;
 586         guint32 call_conv;
 587         MonoObject *type;
 588         MonoArray *pinfo;
 589         MonoArray *cattrs;
 590         MonoBoolean init_locals;
 591         MonoArray *param_modreq;
 592         MonoArray *param_modopt;
 593         MonoArray *permissions;
 594 } MonoReflectionCtorBuilder;
 595
 596 typedef struct {
 597         MonoObject object;
 598         MonoMethod *mhandle;
 599         MonoReflectionType *rtype;
 600         MonoArray *parameters;
 601         guint32 attrs;
 602         guint32 iattrs;
 603         MonoString *name;
 604         guint32 table_idx;
 605         MonoArray *code;
 606         MonoReflectionILGen *ilgen;
 607         MonoObject *type;
 608         MonoArray *pinfo;
 609         MonoArray *cattrs;
 610         MonoReflectionMethod *override_method;
 611         MonoString *dll;
 612         MonoString *dllentry;
 613         guint32 charset;
 614         guint32 native_cc;
 615         guint32 call_conv;
 616         MonoBoolean init_locals;
 617         MonoArray *generic_params;
 618         MonoArray *return_modreq;
 619         MonoArray *return_modopt;
 620         MonoArray *param_modreq;
 621         MonoArray *param_modopt;
 622         MonoArray *permissions;
 623 } MonoReflectionMethodBuilder;
 624
 625 typedef struct {
 626         MonoObject object;
 627         MonoMethod *mhandle;
 628         MonoReflectionType *parent;
 629         MonoReflectionType *ret;
 630         MonoArray *parameters;
 631         MonoString *name;
 632         guint32 table_idx;
 633         guint32 call_conv;
 634 } MonoReflectionArrayMethod;
 635
 636 typedef struct {
 637         MonoArray *data;
 638         MonoString *name;
 639         MonoString *filename;
 640         guint32 attrs;
 641         guint32 offset;
 642 } MonoReflectionResource;
 643
 644 typedef struct {
 645         guint32 res_type;
 646         guint32 res_id;
 647         guint32 lang_id;
 648         MonoArray *res_data;
 649 } MonoReflectionWin32Resource;
 650
 651 typedef struct {
 652         guint32 action;
 653         MonoString *pset;
 654 } MonoReflectionPermissionSet;
 655
 656 typedef struct {
 657         MonoReflectionAssembly assembly;
 658         MonoDynamicAssembly *dynamic_assembly;
 659         MonoReflectionMethod *entry_point;
 660         MonoArray *modules;
 661         MonoString *name;
 662         MonoString *dir;
 663         MonoArray *cattrs;
 664         MonoArray *resources;
 665         MonoArray *public_key;
 666         MonoString *version;
 667         MonoString *culture;
 668         guint32 algid;
 669         guint32 flags;
 670         guint32 pekind;
 671         MonoBoolean delay_sign;
 672         guint32 access;
 673         MonoArray *loaded_modules;
 674         MonoArray *win32_resources;
 675         /* CAS related */
 676         MonoArray *permissions_minimum;
 677         MonoArray *permissions_optional;
 678         MonoArray *permissions_refused;
 679 } MonoReflectionAssemblyBuilder;
 680
 681 typedef struct {
 682         MonoObject object;
 683         guint32 attrs;
 684         MonoReflectionType *type;
 685         MonoString *name;
 686         MonoObject *def_value;
 687         gint32 offset;
 688         gint32 table_idx;
 689         MonoReflectionType *typeb;
 690         MonoArray *rva_data;
 691         MonoArray *cattrs;
 692         MonoReflectionMarshal *marshal_info;
 693         MonoClassField *handle;
 694         MonoArray *modreq;
 695         MonoArray *modopt;
 696 } MonoReflectionFieldBuilder;
 697
 698 typedef struct {
 699         MonoObject object;
 700         guint32 attrs;
 701         MonoString *name;
 702         MonoReflectionType *type;
 703         MonoArray *parameters;
 704         MonoArray *cattrs;
 705         MonoObject *def_value;
 706         MonoReflectionMethodBuilder *set_method;
 707         MonoReflectionMethodBuilder *get_method;
 708         gint32 table_idx;
 709 } MonoReflectionPropertyBuilder;
 710
 711 struct _MonoReflectionModule {
 712         MonoObject      obj;
 713         MonoImage  *image;
 714         MonoReflectionAssembly *assembly;
 715         MonoString *fqname;
 716         MonoString *name;
 717         MonoString *scopename;
 718         MonoBoolean is_resource;
 719 };
 720
 721 typedef struct {
 722         MonoReflectionModule module;
 723         MonoDynamicImage *dynamic_image;
 724         gint32     num_types;
 725         MonoArray *types;
 726         MonoArray *cattrs;
 727         MonoArray *guid;
 728         guint32    table_idx;
 729         MonoReflectionAssemblyBuilder *assemblyb;
 730         MonoArray *global_methods;
 731         MonoArray *global_fields;
 732         gboolean is_main;
 733         MonoArray *resources;
 734 } MonoReflectionModuleBuilder;
 735
 736 typedef struct {
 737         MonoReflectionType type;
 738         MonoString *name;
 739         MonoString *nspace;
 740         MonoReflectionType *parent;
 741         MonoReflectionType *nesting_type;
 742         MonoArray *interfaces;
 743         gint32     num_methods;
 744         MonoArray *methods;
 745         MonoArray *ctors;
 746         MonoArray *properties;
 747         gint32     num_fields;
 748         MonoArray *fields;
 749         MonoArray *events;
 750         MonoArray *cattrs;
 751         MonoArray *subtypes;
 752         guint32 attrs;
 753         guint32 table_idx;
 754         MonoReflectionModuleBuilder *module;
 755         gint32 class_size;
 756         gint32 packing_size;
 757         MonoArray *generic_params;
 758         MonoArray *permissions;
 759 } MonoReflectionTypeBuilder;
 760
 761 typedef struct {
 762         MonoReflectionType type;
 763         MonoReflectionTypeBuilder *tbuilder;
 764         MonoReflectionMethodBuilder *mbuilder;
 765         MonoString *name;
 766         guint32 index;
 767         MonoReflectionType *base_type;
 768         MonoArray *iface_constraints;
 769         MonoBoolean has_ctor_constraint;
 770         MonoBoolean has_reference_type;
 771         MonoBoolean has_value_type;
 772 } MonoReflectionGenericParam;
 773
 774 typedef struct _MonoReflectionGenericInst MonoReflectionGenericInst;
 775 struct _MonoReflectionGenericInst {
 776         MonoReflectionType type;
 777         MonoReflectionType *generic_type;
 778         guint32 initialized;
 779 };
 780
 781 typedef struct {
 782         MonoObject  obj;
 783         MonoString *name;
 784         MonoString *codebase;
 785         gint32 major, minor, build, revision;
 786         /* FIXME: add missing stuff */
 787 /*      CultureInfo cultureinfo;
 788         AssemblyNameFlags flags;
 789         AssemblyHashAlgorithm hashalg;
 790         StrongNameKeyPair keypair;
 791         AssemblyVersionCompatibility versioncompat;*/
 792         MonoObject  *cultureInfo;
 793         guint32     flags;
 794         guint32     hashalg;
 795         MonoObject  *keypair;
 796         MonoArray   *publicKey;
 797         MonoArray   *keyToken;
 798         MonoObject  *versioncompat;
 799 } MonoReflectionAssemblyName;
 800
 801 typedef struct {
 802         MonoObject  obj;
 803         MonoString *name;
 804         MonoReflectionType *type;
 805         MonoReflectionTypeBuilder *typeb;
 806         MonoArray *cattrs;
 807         MonoReflectionMethodBuilder *add_method;
 808         MonoReflectionMethodBuilder *remove_method;
 809         MonoReflectionMethodBuilder *raise_method;
 810         MonoArray *other_methods;
 811         guint32 attrs;
 812         guint32 table_idx;
 813 } MonoReflectionEventBuilder;
 814
 815 typedef struct {
 816         MonoObject  obj;
 817         MonoReflectionMethod *ctor;
 818         MonoArray *data;
 819 } MonoReflectionCustomAttr;
 820
 821 typedef struct {
 822         MonoObject object;
 823         MonoMethod *mhandle;
 824         MonoString *name;
 825         MonoReflectionType *rtype;
 826         MonoArray *parameters;
 827         guint32 attrs;
 828         guint32 call_conv;
 829         MonoReflectionModule *module;
 830         MonoBoolean skip_visibility;
 831         MonoBoolean init_locals;
 832         MonoReflectionILGen *ilgen;
 833         gint32 nrefs;
 834         MonoArray *refs;
 835 } MonoReflectionDynamicMethod;
 836
 837 typedef struct {
 838         MonoObject object;
 839         MonoReflectionModuleBuilder *module;
 840         MonoArray *arguments;
 841         guint32 type;
 842         MonoReflectionType *return_type;
 843         guint32 call_conv;
 844         guint32 unmanaged_call_conv;
 845 } MonoReflectionSigHelper;
 846
 847 enum {
 848         RESOURCE_LOCATION_EMBEDDED = 1,
 849         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
 850         RESOURCE_LOCATION_IN_MANIFEST = 4
 851 };
 852
 853 typedef struct {
 854         MonoObject object;
 855         MonoReflectionAssembly *assembly;
 856         MonoString *filename;
 857         guint32 location;
 858 } MonoManifestResourceInfo;
 859
 860 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module);
 861 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 862 MonoReflectionModule * mono_image_load_module (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name);
 863 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str);
 864 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec);
 865 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types);
 866 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
 867
 868 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 869
 870 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 871
 872 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb);
 873
 874 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 875
 876 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
 877
 878 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
 879
 880 MonoType*
 881 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types);
 882 MonoReflectionMethod*
 883 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
 884 void
 885 mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
 886 MonoReflectionEvent *
 887 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
 888
 889 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 890
 891 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 892
 893 gpointer
 894 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token);
 895
 896 void
 897 mono_image_build_metadata (MonoReflectionModuleBuilder *module);
 898
 899 int
 900 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, char *blob, void *value);
 901
 902 #endif /* __MONO_OBJECT_INTERNALS_H__ */
 903