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         MonoArray *other_methods;
 505 } MonoEventInfo;
 506
 507 typedef struct {
 508         MonoString *name;
 509         MonoString *name_space;
 510         MonoReflectionType *etype;
 511         MonoReflectionType *nested_in;
 512         MonoReflectionAssembly *assembly;
 513         guint32 rank;
 514         MonoBoolean isprimitive;
 515 } MonoTypeInfo;
 516
 517 typedef struct {
 518         MonoObject *member;
 519         gint32 code_pos;
 520 } MonoReflectionILTokenInfo;
 521
 522 typedef struct {
 523         MonoObject object;
 524         MonoArray *code;
 525         gint32 code_len;
 526         gint32 max_stack;
 527         gint32 cur_stack;
 528         MonoArray *locals;
 529         MonoArray *ex_handlers;
 530         gint32 num_token_fixups;
 531         MonoArray *token_fixups;
 532 } MonoReflectionILGen;
 533
 534 typedef struct {
 535         MonoArray *handlers;
 536         gint32 start;
 537         gint32 len;
 538         gint32 label;
 539 } MonoILExceptionInfo;
 540
 541 typedef struct {
 542         MonoReflectionType *extype;
 543         gint32 type;
 544         gint32 start;
 545         gint32 len;
 546         gint32 filter_offset;
 547 } MonoILExceptionBlock;
 548
 549 typedef struct {
 550         MonoObject object;
 551         MonoReflectionType *type;
 552         MonoString *name;
 553         MonoBoolean is_pinned;
 554 } MonoReflectionLocalBuilder;
 555
 556 typedef struct {
 557         MonoObject object;
 558         gint32 count;
 559         gint32 type;
 560         gint32 eltype;
 561         MonoString *guid;
 562         MonoString *mcookie;
 563         MonoString *marshaltype;
 564         MonoReflectionType *marshaltyperef;
 565 } MonoReflectionMarshal;
 566
 567 typedef struct {
 568         MonoObject object;
 569         MonoObject* methodb;
 570         MonoString *name;
 571         MonoArray *cattrs;
 572         MonoReflectionMarshal *marshal_info;
 573         guint32 attrs;
 574         int position;
 575         guint32 table_idx;
 576         MonoObject *def_value;
 577 } MonoReflectionParamBuilder;
 578
 579 typedef struct {
 580         MonoObject object;
 581         MonoMethod *mhandle;
 582         MonoReflectionILGen *ilgen;
 583         MonoArray *parameters;
 584         guint32 attrs;
 585         guint32 iattrs;
 586         guint32 table_idx;
 587         guint32 call_conv;
 588         MonoObject *type;
 589         MonoArray *pinfo;
 590         MonoArray *cattrs;
 591         MonoBoolean init_locals;
 592         MonoArray *param_modreq;
 593         MonoArray *param_modopt;
 594         MonoArray *permissions;
 595 } MonoReflectionCtorBuilder;
 596
 597 typedef struct {
 598         MonoObject object;
 599         MonoMethod *mhandle;
 600         MonoReflectionType *rtype;
 601         MonoArray *parameters;
 602         guint32 attrs;
 603         guint32 iattrs;
 604         MonoString *name;
 605         guint32 table_idx;
 606         MonoArray *code;
 607         MonoReflectionILGen *ilgen;
 608         MonoObject *type;
 609         MonoArray *pinfo;
 610         MonoArray *cattrs;
 611         MonoReflectionMethod *override_method;
 612         MonoString *dll;
 613         MonoString *dllentry;
 614         guint32 charset;
 615         guint32 native_cc;
 616         guint32 call_conv;
 617         MonoBoolean init_locals;
 618         MonoArray *generic_params;
 619         MonoArray *return_modreq;
 620         MonoArray *return_modopt;
 621         MonoArray *param_modreq;
 622         MonoArray *param_modopt;
 623         MonoArray *permissions;
 624 } MonoReflectionMethodBuilder;
 625
 626 typedef struct {
 627         MonoObject object;
 628         MonoMethod *mhandle;
 629         MonoReflectionType *parent;
 630         MonoReflectionType *ret;
 631         MonoArray *parameters;
 632         MonoString *name;
 633         guint32 table_idx;
 634         guint32 call_conv;
 635 } MonoReflectionArrayMethod;
 636
 637 typedef struct {
 638         MonoArray *data;
 639         MonoString *name;
 640         MonoString *filename;
 641         guint32 attrs;
 642         guint32 offset;
 643 } MonoReflectionResource;
 644
 645 typedef struct {
 646         guint32 res_type;
 647         guint32 res_id;
 648         guint32 lang_id;
 649         MonoArray *res_data;
 650 } MonoReflectionWin32Resource;
 651
 652 typedef struct {
 653         guint32 action;
 654         MonoString *pset;
 655 } MonoReflectionPermissionSet;
 656
 657 typedef struct {
 658         MonoReflectionAssembly assembly;
 659         MonoDynamicAssembly *dynamic_assembly;
 660         MonoReflectionMethod *entry_point;
 661         MonoArray *modules;
 662         MonoString *name;
 663         MonoString *dir;
 664         MonoArray *cattrs;
 665         MonoArray *resources;
 666         MonoArray *public_key;
 667         MonoString *version;
 668         MonoString *culture;
 669         guint32 algid;
 670         guint32 flags;
 671         guint32 pekind;
 672         MonoBoolean delay_sign;
 673         guint32 access;
 674         MonoArray *loaded_modules;
 675         MonoArray *win32_resources;
 676         /* CAS related */
 677         MonoArray *permissions_minimum;
 678         MonoArray *permissions_optional;
 679         MonoArray *permissions_refused;
 680 } MonoReflectionAssemblyBuilder;
 681
 682 typedef struct {
 683         MonoObject object;
 684         guint32 attrs;
 685         MonoReflectionType *type;
 686         MonoString *name;
 687         MonoObject *def_value;
 688         gint32 offset;
 689         gint32 table_idx;
 690         MonoReflectionType *typeb;
 691         MonoArray *rva_data;
 692         MonoArray *cattrs;
 693         MonoReflectionMarshal *marshal_info;
 694         MonoClassField *handle;
 695         MonoArray *modreq;
 696         MonoArray *modopt;
 697 } MonoReflectionFieldBuilder;
 698
 699 typedef struct {
 700         MonoObject object;
 701         guint32 attrs;
 702         MonoString *name;
 703         MonoReflectionType *type;
 704         MonoArray *parameters;
 705         MonoArray *cattrs;
 706         MonoObject *def_value;
 707         MonoReflectionMethodBuilder *set_method;
 708         MonoReflectionMethodBuilder *get_method;
 709         gint32 table_idx;
 710 } MonoReflectionPropertyBuilder;
 711
 712 struct _MonoReflectionModule {
 713         MonoObject      obj;
 714         MonoImage  *image;
 715         MonoReflectionAssembly *assembly;
 716         MonoString *fqname;
 717         MonoString *name;
 718         MonoString *scopename;
 719         MonoBoolean is_resource;
 720         guint32 token;
 721 };
 722
 723 typedef struct {
 724         MonoReflectionModule module;
 725         MonoDynamicImage *dynamic_image;
 726         gint32     num_types;
 727         MonoArray *types;
 728         MonoArray *cattrs;
 729         MonoArray *guid;
 730         guint32    table_idx;
 731         MonoReflectionAssemblyBuilder *assemblyb;
 732         MonoArray *global_methods;
 733         MonoArray *global_fields;
 734         gboolean is_main;
 735         MonoArray *resources;
 736 } MonoReflectionModuleBuilder;
 737
 738 typedef struct {
 739         MonoReflectionType type;
 740         MonoString *name;
 741         MonoString *nspace;
 742         MonoReflectionType *parent;
 743         MonoReflectionType *nesting_type;
 744         MonoArray *interfaces;
 745         gint32     num_methods;
 746         MonoArray *methods;
 747         MonoArray *ctors;
 748         MonoArray *properties;
 749         gint32     num_fields;
 750         MonoArray *fields;
 751         MonoArray *events;
 752         MonoArray *cattrs;
 753         MonoArray *subtypes;
 754         guint32 attrs;
 755         guint32 table_idx;
 756         MonoReflectionModuleBuilder *module;
 757         gint32 class_size;
 758         gint32 packing_size;
 759         MonoArray *generic_params;
 760         MonoArray *permissions;
 761 } MonoReflectionTypeBuilder;
 762
 763 typedef struct {
 764         MonoReflectionType type;
 765         MonoReflectionTypeBuilder *tbuilder;
 766         MonoReflectionMethodBuilder *mbuilder;
 767         MonoString *name;
 768         guint32 index;
 769         MonoReflectionType *base_type;
 770         MonoArray *iface_constraints;
 771         MonoBoolean has_ctor_constraint;
 772         MonoBoolean has_reference_type;
 773         MonoBoolean has_value_type;
 774 } MonoReflectionGenericParam;
 775
 776 typedef struct _MonoReflectionGenericInst MonoReflectionGenericInst;
 777 struct _MonoReflectionGenericInst {
 778         MonoReflectionType type;
 779         MonoReflectionType *generic_type;
 780         guint32 initialized;
 781 };
 782
 783 typedef struct {
 784         MonoObject  obj;
 785         MonoString *name;
 786         MonoString *codebase;
 787         gint32 major, minor, build, revision;
 788         /* FIXME: add missing stuff */
 789 /*      CultureInfo cultureinfo;
 790         AssemblyNameFlags flags;
 791         AssemblyHashAlgorithm hashalg;
 792         StrongNameKeyPair keypair;
 793         AssemblyVersionCompatibility versioncompat;*/
 794         MonoObject  *cultureInfo;
 795         guint32     flags;
 796         guint32     hashalg;
 797         MonoObject  *keypair;
 798         MonoArray   *publicKey;
 799         MonoArray   *keyToken;
 800         MonoObject  *versioncompat;
 801 } MonoReflectionAssemblyName;
 802
 803 typedef struct {
 804         MonoObject  obj;
 805         MonoString *name;
 806         MonoReflectionType *type;
 807         MonoReflectionTypeBuilder *typeb;
 808         MonoArray *cattrs;
 809         MonoReflectionMethodBuilder *add_method;
 810         MonoReflectionMethodBuilder *remove_method;
 811         MonoReflectionMethodBuilder *raise_method;
 812         MonoArray *other_methods;
 813         guint32 attrs;
 814         guint32 table_idx;
 815 } MonoReflectionEventBuilder;
 816
 817 typedef struct {
 818         MonoObject  obj;
 819         MonoReflectionMethod *ctor;
 820         MonoArray *data;
 821 } MonoReflectionCustomAttr;
 822
 823 typedef struct {
 824         MonoObject object;
 825         MonoMethod *mhandle;
 826         MonoString *name;
 827         MonoReflectionType *rtype;
 828         MonoArray *parameters;
 829         guint32 attrs;
 830         guint32 call_conv;
 831         MonoReflectionModule *module;
 832         MonoBoolean skip_visibility;
 833         MonoBoolean init_locals;
 834         MonoReflectionILGen *ilgen;
 835         gint32 nrefs;
 836         MonoArray *refs;
 837 } MonoReflectionDynamicMethod;
 838
 839 typedef struct {
 840         MonoObject object;
 841         MonoReflectionModuleBuilder *module;
 842         MonoArray *arguments;
 843         guint32 type;
 844         MonoReflectionType *return_type;
 845         guint32 call_conv;
 846         guint32 unmanaged_call_conv;
 847 } MonoReflectionSigHelper;
 848
 849 enum {
 850         RESOURCE_LOCATION_EMBEDDED = 1,
 851         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
 852         RESOURCE_LOCATION_IN_MANIFEST = 4
 853 };
 854
 855 typedef struct {
 856         MonoObject object;
 857         MonoReflectionAssembly *assembly;
 858         MonoString *filename;
 859         guint32 location;
 860 } MonoManifestResourceInfo;
 861
 862 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module);
 863 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 864 MonoReflectionModule * mono_image_load_module (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name);
 865 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str);
 866 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec);
 867 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types);
 868 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
 869
 870 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 871
 872 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 873
 874 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb);
 875
 876 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 877
 878 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
 879
 880 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
 881
 882 MonoType*
 883 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types);
 884 MonoReflectionMethod*
 885 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
 886 void
 887 mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
 888 MonoReflectionEvent *
 889 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
 890
 891 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 892
 893 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 894
 895 gpointer
 896 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token);
 897
 898 void
 899 mono_image_build_metadata (MonoReflectionModuleBuilder *module);
 900
 901 int
 902 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, char *blob, void *value);
 903
 904 #endif /* __MONO_OBJECT_INTERNALS_H__ */
 905