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