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/metadata/mempool.h>
   7 #include <mono/io-layer/io-layer.h>
   8
   9 #if 1
  10 #ifdef __GNUC__
  11 #define mono_assert(expr)                  G_STMT_START{                  \
  12      if (!(expr))                                                         \
  13        {                                                                  \
  14                 MonoException *ex;                                        \
  15                 char *msg = g_strdup_printf ("file %s: line %d (%s): "    \
  16                 "assertion failed: (%s)", __FILE__, __LINE__,             \
  17                 __PRETTY_FUNCTION__, #expr);                              \
  18                 ex = mono_get_exception_execution_engine (msg);           \
  19                 g_free (msg);                                             \
  20                 mono_raise_exception (ex);                                \
  21        };                               }G_STMT_END
  22
  23 #define mono_assert_not_reached()                 G_STMT_START{           \
  24      MonoException *ex;                                                   \
  25      char *msg = g_strdup_printf ("file %s: line %d (%s): "               \
  26      "should not be reached", __FILE__, __LINE__, __PRETTY_FUNCTION__);   \
  27      ex = mono_get_exception_execution_engine (msg);                      \
  28      g_free (msg);                                                        \
  29      mono_raise_exception (ex);                                           \
  30 }G_STMT_END
  31 #else /* not GNUC */
  32 #define mono_assert(expr)                  G_STMT_START{                  \
  33      if (!(expr))                                                         \
  34        {                                                                  \
  35                 MonoException *ex;                                        \
  36                 char *msg = g_strdup_printf ("file %s: line %d: "         \
  37                 "assertion failed: (%s)", __FILE__, __LINE__,             \
  38                 #expr);                                                   \
  39                 ex = mono_get_exception_execution_engine (msg);           \
  40                 g_free (msg);                                             \
  41                 mono_raise_exception (ex);                                \
  42        };                               }G_STMT_END
  43
  44 #define mono_assert_not_reached()                 G_STMT_START{           \
  45      MonoException *ex;                                                   \
  46      char *msg = g_strdup_printf ("file %s: line %d): "                   \
  47      "should not be reached", __FILE__, __LINE__);                        \
  48      ex = mono_get_exception_execution_engine (msg);                      \
  49      g_free (msg);                                                        \
  50      mono_raise_exception (ex);                                           \
  51 }G_STMT_END
  52 #endif
  53 #else
  54 #define mono_assert(expr) g_assert(expr)
  55 #define mono_assert_not_reached() g_assert_not_reached()
  56 #endif
  57
  58 #define MONO_CHECK_ARG(arg, expr)               G_STMT_START{             \
  59      if (!(expr))                                                         \
  60        {                                                                  \
  61                 MonoException *ex;                                        \
  62                 char *msg = g_strdup_printf ("assertion `%s' failed",     \
  63                 #expr);                                                   \
  64                 if (arg) {} /* check if the name exists */                \
  65                 ex = mono_get_exception_argument (#arg, msg);             \
  66                 g_free (msg);                                             \
  67                 mono_raise_exception (ex);                                \
  68        };                               }G_STMT_END
  69
  70 #define MONO_CHECK_ARG_NULL(arg)            G_STMT_START{                 \
  71      if (arg == NULL)                                                     \
  72        {                                                                  \
  73                 MonoException *ex;                                        \
  74                 if (arg) {} /* check if the name exists */                \
  75                 ex = mono_get_exception_argument_null (#arg);             \
  76                 mono_raise_exception (ex);                                \
  77        };                               }G_STMT_END
  78
  79
  80 /* 16 == default capacity */
  81 #define mono_stringbuilder_capacity(sb) ((sb)->str ? ((sb)->str->length) : 16)
  82
  83 typedef struct {
  84         MonoObject obj;
  85         MonoObject *identity;
  86 } MonoMarshalByRefObject;
  87
  88 /* This is a copy of System.AppDomain */
  89 struct _MonoAppDomain {
  90         MonoMarshalByRefObject mbr;
  91         MonoDomain *data;
  92 };
  93
  94 typedef struct {
  95         MonoObject object;
  96         gint32 length;
  97         MonoString *str;
  98         MonoString *cached_str;
  99         gint32 max_capacity;
 100 } MonoStringBuilder;
 101
 102 typedef struct {
 103         MonoType *type;
 104         gpointer  value;
 105         MonoClass *klass;
 106 } MonoTypedRef;
 107
 108 typedef struct {
 109         gpointer args;
 110 } MonoArgumentHandle;
 111
 112 typedef struct {
 113         MonoMethodSignature *sig;
 114         gpointer args;
 115         gint32 next_arg;
 116         gint32 num_args;
 117 } MonoArgIterator;
 118
 119 struct _MonoException {
 120         MonoObject object;
 121         MonoArray  *trace_ips;
 122         MonoObject *inner_ex;
 123         MonoString *message;
 124         MonoString *help_link;
 125         MonoString *class_name;
 126         MonoString *stack_trace;
 127         MonoString *remote_stack_trace;
 128         gint32      remote_stack_index;
 129         gint32      hresult;
 130         MonoString *source;
 131 };
 132
 133 typedef struct {
 134         MonoException base;
 135 } MonoSystemException;
 136
 137 typedef struct {
 138         MonoSystemException base;
 139         MonoString *param_name;
 140 } MonoArgumentException;
 141
 142 typedef struct {
 143         MonoSystemException base;
 144         MonoString *msg;
 145         MonoString *type_name;
 146 } MonoTypeLoadException;
 147
 148 typedef struct {
 149         MonoObject   object;
 150         MonoObject  *async_state;
 151         MonoObject  *handle;
 152         MonoObject  *async_delegate;
 153         gpointer    *data;
 154         MonoObject  *object_data;
 155         MonoBoolean  sync_completed;
 156         MonoBoolean  completed;
 157         MonoBoolean  endinvoke_called;
 158         MonoObject  *async_callback;
 159         MonoObject  *execution_context;
 160         MonoObject  *original_context;
 161 } MonoAsyncResult;
 162
 163 typedef struct {
 164         MonoMarshalByRefObject object;
 165         gpointer     handle;
 166         MonoBoolean  disposed;
 167 } MonoWaitHandle;
 168
 169 /* This is a copy of System.Runtime.Remoting.Messaging.CallType */
 170 typedef enum {
 171         CallType_Sync = 0,
 172         CallType_BeginInvoke = 1,
 173         CallType_EndInvoke = 2,
 174         CallType_OneWay = 3
 175 } MonoCallType;
 176
 177 struct _MonoReflectionType {
 178         MonoObject object;
 179         MonoType  *type;
 180 };
 181
 182 typedef struct {
 183         MonoObject  object;
 184         MonoReflectionType *class_to_proxy;
 185         MonoObject *context;
 186         MonoObject *unwrapped_server;
 187         gint32      target_domain_id;
 188         MonoString *target_uri;
 189         MonoObject *object_identity;
 190         MonoObject *obj_TP;
 191         MonoObject *stub_data;
 192 } MonoRealProxy;
 193
 194 typedef struct {
 195         MonoRealProxy real_proxy;
 196         MonoObject *com_object;
 197 } MonoComInteropProxy;
 198
 199 typedef struct {
 200         MonoMarshalByRefObject object;
 201         GHashTable* itf_hash;
 202 } MonoComObject;
 203
 204 typedef struct {
 205         MonoObject       object;
 206         MonoRealProxy   *rp;
 207         MonoRemoteClass *remote_class;
 208         MonoBoolean      custom_type_info;
 209 } MonoTransparentProxy;
 210
 211 typedef struct {
 212         MonoObject obj;
 213         MonoReflectionMethod *method;
 214         MonoArray  *args;
 215         MonoArray  *names;
 216         MonoArray  *arg_types;
 217         MonoObject *ctx;
 218         MonoObject *rval;
 219         MonoObject *exc;
 220         MonoAsyncResult *async_result;
 221         guint32     call_type;
 222 } MonoMethodMessage;
 223
 224 typedef struct {
 225         MonoObject obj;
 226         gint32 il_offset;
 227         gint32 native_offset;
 228         MonoReflectionMethod *method;
 229         MonoString *filename;
 230         gint32 line;
 231         gint32 column;
 232         MonoString *internal_method_name;
 233 } MonoStackFrame;
 234
 235 struct _MonoThread {
 236         MonoObject  obj;
 237         int         lock_thread_id; /* to be used as the pre-shifted thread id in thin locks */
 238         HANDLE      handle;
 239         MonoArray  *cached_culture_info;
 240         gpointer    unused1;
 241         MonoBoolean threadpool_thread;
 242         gunichar2  *name;
 243         guint32     name_len;
 244         guint32     state;
 245         MonoException *abort_exc;
 246         MonoObject *abort_state;
 247         guint64 tid;    /* This is accessed as a gsize in the code (so it can hold a 64bit pointer on systems that need it), but needs to reserve 64 bits of space on all machines as it corresponds to a field in managed code */
 248         HANDLE      start_notify;
 249         gpointer stack_ptr;
 250         gpointer *static_data;
 251         gpointer jit_data;
 252         gpointer lock_data;
 253         MonoAppContext *current_appcontext;
 254         int stack_size;
 255         MonoObject *start_obj;
 256         GSList *appdomain_refs;
 257         MonoBoolean interruption_requested;
 258         gpointer suspend_event;
 259         gpointer suspended_event;
 260         gpointer resume_event;
 261         MonoObject *synch_lock;
 262         guint8* serialized_culture_info;
 263         guint32 serialized_culture_info_len;
 264         guint8* serialized_ui_culture_info;
 265         guint32 serialized_ui_culture_info_len;
 266         MonoObject *execution_context;
 267         /*
 268          * These fields are used to avoid having to increment corlib versions
 269          * when a new field is added to the unmanaged MonoThread structure.
 270          */
 271         MonoBoolean thread_dump_requested;
 272         gpointer end_stack; /* This is only used when running in the debugger. */
 273         gpointer unused3;
 274         gpointer unused4;
 275         gpointer unused5;
 276         gpointer unused6;
 277         gpointer unused7;
 278 };
 279
 280 typedef struct {
 281         MonoString *name;
 282         MonoReflectionType *type;
 283         MonoObject *value;
 284 } MonoSerializationEntry;
 285
 286 typedef struct {
 287         guint32 state;
 288         MonoObject *additional;
 289 } MonoStreamingContext;
 290
 291 typedef struct {
 292         MonoObject obj;
 293         MonoBoolean readOnly;
 294         MonoString *AMDesignator;
 295         MonoString *PMDesignator;
 296         MonoString *DateSeparator;
 297         MonoString *TimeSeparator;
 298         MonoString *ShortDatePattern;
 299         MonoString *LongDatePattern;
 300         MonoString *ShortTimePattern;
 301         MonoString *LongTimePattern;
 302         MonoString *MonthDayPattern;
 303         MonoString *YearMonthPattern;
 304         MonoString *FullDateTimePattern;
 305         MonoString *RFC1123Pattern;
 306         MonoString *SortableDateTimePattern;
 307         MonoString *UniversalSortableDateTimePattern;
 308         guint32 FirstDayOfWeek;
 309         MonoObject *Calendar;
 310         guint32 CalendarWeekRule;
 311         MonoArray *AbbreviatedDayNames;
 312         MonoArray *DayNames;
 313         MonoArray *MonthNames;
 314         MonoArray *AbbreviatedMonthNames;
 315         MonoArray *ShortDatePatterns;
 316         MonoArray *LongDatePatterns;
 317         MonoArray *ShortTimePatterns;
 318         MonoArray *LongTimePatterns;
 319 } MonoDateTimeFormatInfo;
 320
 321 typedef struct
 322 {
 323         MonoObject obj;
 324         MonoBoolean readOnly;
 325         MonoString *decimalFormats;
 326         MonoString *currencyFormats;
 327         MonoString *percentFormats;
 328         MonoString *digitPattern;
 329         MonoString *zeroPattern;
 330         gint32 currencyDecimalDigits;
 331         MonoString *currencyDecimalSeparator;
 332         MonoString *currencyGroupSeparator;
 333         MonoArray *currencyGroupSizes;
 334         gint32 currencyNegativePattern;
 335         gint32 currencyPositivePattern;
 336         MonoString *currencySymbol;
 337         MonoString *naNSymbol;
 338         MonoString *negativeInfinitySymbol;
 339         MonoString *negativeSign;
 340         guint32 numberDecimalDigits;
 341         MonoString *numberDecimalSeparator;
 342         MonoString *numberGroupSeparator;
 343         MonoArray *numberGroupSizes;
 344         gint32 numberNegativePattern;
 345         gint32 percentDecimalDigits;
 346         MonoString *percentDecimalSeparator;
 347         MonoString *percentGroupSeparator;
 348         MonoArray *percentGroupSizes;
 349         gint32 percentNegativePattern;
 350         gint32 percentPositivePattern;
 351         MonoString *percentSymbol;
 352         MonoString *perMilleSymbol;
 353         MonoString *positiveInfinitySymbol;
 354         MonoString *positiveSign;
 355 } MonoNumberFormatInfo;
 356
 357 typedef struct {
 358         MonoObject obj;
 359         gint32 lcid;
 360         MonoString *icu_name;
 361         gpointer ICU_collator;
 362 } MonoCompareInfo;
 363
 364 typedef struct {
 365         MonoObject obj;
 366         MonoBoolean is_read_only;
 367         gint32 lcid;
 368         gint32 parent_lcid;
 369         gint32 specific_lcid;
 370         gint32 datetime_index;
 371         gint32 number_index;
 372         MonoBoolean use_user_override;
 373         MonoNumberFormatInfo *number_format;
 374         MonoDateTimeFormatInfo *datetime_format;
 375         MonoObject *textinfo;
 376         MonoString *name;
 377         MonoString *displayname;
 378         MonoString *englishname;
 379         MonoString *nativename;
 380         MonoString *iso3lang;
 381         MonoString *iso2lang;
 382         MonoString *icu_name;
 383         MonoString *win3lang;
 384         MonoCompareInfo *compareinfo;
 385         const gint32 *calendar_data;
 386         const void* text_info_data;
 387 } MonoCultureInfo;
 388
 389 typedef struct {
 390         MonoObject obj;
 391         gint32 region_id;
 392         MonoString *iso2name;
 393         MonoString *iso3name;
 394         MonoString *win3name;
 395         MonoString *english_name;
 396         MonoString *currency_symbol;
 397         MonoString *iso_currency_symbol;
 398         MonoString *currency_english_name;
 399 } MonoRegionInfo;
 400
 401 typedef struct {
 402         MonoObject obj;
 403         MonoString *str;
 404         gint32 options;
 405         MonoArray *key;
 406         gint32 lcid;
 407 } MonoSortKey;
 408
 409 typedef struct {
 410         MonoObject object;
 411         guint16 intType;
 412 } MonoInterfaceTypeAttribute;
 413
 414 /* used to free a dynamic method */
 415 typedef void        (*MonoFreeMethodFunc)        (MonoDomain *domain, MonoMethod *method);
 416
 417 /* Used to initialize the method pointers inside vtables */
 418 typedef gboolean    (*MonoInitVTableFunc)    (MonoVTable *vtable);
 419
 420 /* remoting and async support */
 421
 422 MonoAsyncResult *
 423 mono_async_result_new       (MonoDomain *domain, HANDLE handle,
 424                              MonoObject *state, gpointer data, MonoObject *object_data);
 425
 426 MonoWaitHandle *
 427 mono_wait_handle_new        (MonoDomain *domain, HANDLE handle);
 428
 429 void
 430 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 431                              MonoReflectionMethod *method, MonoArray *out_args);
 432
 433 MonoObject *
 434 mono_remoting_invoke        (MonoObject *real_proxy, MonoMethodMessage *msg,
 435                              MonoObject **exc, MonoArray **out_args);
 436
 437 MonoObject *
 438 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg,
 439                              MonoObject **exc, MonoArray **out_args);
 440
 441 MonoMethodMessage *
 442 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 443                               MonoDelegate **cb, MonoObject **state);
 444
 445 void
 446 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args);
 447
 448 void
 449 mono_delegate_ctor          (MonoObject *this_obj, MonoObject *target, gpointer addr);
 450
 451 void*
 452 mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words);
 453
 454 void
 455 mono_runtime_free_method    (MonoDomain *domain, MonoMethod *method);
 456
 457 /* runtime initialization functions */
 458 typedef void (*MonoExceptionFunc) (MonoException *ex);
 459
 460 void
 461 mono_install_handler        (MonoExceptionFunc func);
 462
 463 void
 464 mono_install_runtime_invoke (MonoInvokeFunc func);
 465
 466 void
 467 mono_install_compile_method (MonoCompileFunc func);
 468
 469 void
 470 mono_install_free_method    (MonoFreeMethodFunc func);
 471
 472 void
 473 mono_install_init_vtable    (MonoInitVTableFunc func);
 474
 475 void
 476 mono_type_initialization_init (void);
 477
 478 void
 479 mono_type_initialization_cleanup (void);
 480
 481 guint32
 482 mono_thread_get_tls_key    (void);
 483
 484 gint32
 485 mono_thread_get_tls_offset (void);
 486
 487 guint32
 488 mono_domain_get_tls_key    (void);
 489
 490 gint32
 491 mono_domain_get_tls_offset (void);
 492
 493 /* Reflection and Reflection.Emit support */
 494
 495 /*
 496  * The following structure must match the C# implementation in our corlib.
 497  */
 498
 499 struct _MonoReflectionMethod {
 500         MonoObject object;
 501         MonoMethod *method;
 502         MonoString *name;
 503         MonoReflectionType *reftype;
 504 };
 505
 506 typedef struct _MonoReflectionGenericMethod MonoReflectionGenericMethod;
 507 struct _MonoReflectionGenericMethod {
 508         MonoReflectionMethod method;
 509 };
 510
 511 struct _MonoDelegate {
 512         MonoObject object;
 513         MonoObject *target_type;
 514         MonoObject *target;
 515         MonoString *method_name;
 516         gpointer method_ptr;
 517         gpointer delegate_trampoline;
 518         MonoReflectionMethod *method_info;
 519 };
 520
 521 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
 522 struct _MonoMulticastDelegate {
 523         MonoDelegate delegate;
 524         MonoMulticastDelegate *prev;
 525 };
 526
 527 struct _MonoReflectionField {
 528         MonoObject object;
 529         MonoClass *klass;
 530         MonoClassField *field;
 531         MonoString *name;
 532         MonoReflectionType *type;
 533         guint32 attrs;
 534 };
 535
 536 struct _MonoReflectionProperty {
 537         MonoObject object;
 538         MonoClass *klass;
 539         MonoProperty *property;
 540 };
 541
 542 struct _MonoReflectionEvent {
 543         MonoObject object;
 544         MonoClass *klass;
 545         MonoEvent *event;
 546 };
 547
 548 typedef struct {
 549         MonoObject object;
 550         MonoReflectionType *ClassImpl;
 551         MonoObject *DefaultValueImpl;
 552         MonoObject *MemberImpl;
 553         MonoString *NameImpl;
 554         gint32 PositionImpl;
 555         guint32 AttrsImpl;
 556         MonoObject *MarshalAsImpl;
 557 } MonoReflectionParameter;
 558
 559 struct _MonoReflectionMethodBody {
 560         MonoObject object;
 561         MonoArray *clauses;
 562         MonoArray *locals;
 563         MonoArray *il;
 564         MonoBoolean init_locals;
 565         guint32 local_var_sig_token;
 566         guint32 max_stack;
 567 };
 568
 569 struct _MonoReflectionAssembly {
 570         MonoObject object;
 571         MonoAssembly *assembly;
 572         MonoObject *resolve_event_holder;
 573         /* CAS related */
 574         MonoObject *evidence;   /* Evidence */
 575         MonoObject *minimum;    /* PermissionSet - for SecurityAction.RequestMinimum */
 576         MonoObject *optional;   /* PermissionSet - for SecurityAction.RequestOptional */
 577         MonoObject *refuse;     /* PermissionSet - for SecurityAction.RequestRefuse */
 578         MonoObject *granted;    /* PermissionSet - for the resolved assembly granted permissions */
 579         MonoObject *denied;     /* PermissionSet - for the resolved assembly denied permissions */
 580         /* */
 581         MonoBoolean from_byte_array;
 582         MonoString *name;
 583 };
 584
 585 typedef struct {
 586         MonoReflectionType *utype;
 587         MonoArray *values;
 588         MonoArray *names;
 589 } MonoEnumInfo;
 590
 591 typedef struct {
 592         MonoReflectionType *parent;
 593         MonoReflectionType *ret;
 594         guint32 attrs;
 595         guint32 implattrs;
 596         guint32 callconv;
 597 } MonoMethodInfo;
 598
 599 typedef struct {
 600         MonoReflectionType *parent;
 601         MonoString *name;
 602         MonoReflectionMethod *get;
 603         MonoReflectionMethod *set;
 604         guint32 attrs;
 605 } MonoPropertyInfo;
 606
 607 typedef struct {
 608         MonoReflectionType *declaring_type;
 609         MonoReflectionType *reflected_type;
 610         MonoString *name;
 611         MonoReflectionMethod *add_method;
 612         MonoReflectionMethod *remove_method;
 613         MonoReflectionMethod *raise_method;
 614         guint32 attrs;
 615         MonoArray *other_methods;
 616 } MonoEventInfo;
 617
 618 typedef struct {
 619         MonoString *name;
 620         MonoString *name_space;
 621         MonoReflectionType *etype;
 622         MonoReflectionType *nested_in;
 623         MonoReflectionAssembly *assembly;
 624         guint32 rank;
 625         MonoBoolean isprimitive;
 626 } MonoTypeInfo;
 627
 628 typedef struct {
 629         MonoObject *member;
 630         gint32 code_pos;
 631 } MonoReflectionILTokenInfo;
 632
 633 typedef struct {
 634         MonoObject object;
 635         MonoArray *code;
 636         gint32 code_len;
 637         gint32 max_stack;
 638         gint32 cur_stack;
 639         MonoArray *locals;
 640         MonoArray *ex_handlers;
 641         gint32 num_token_fixups;
 642         MonoArray *token_fixups;
 643 } MonoReflectionILGen;
 644
 645 typedef struct {
 646         MonoArray *handlers;
 647         gint32 start;
 648         gint32 len;
 649         gint32 label;
 650 } MonoILExceptionInfo;
 651
 652 typedef struct {
 653         MonoReflectionType *extype;
 654         gint32 type;
 655         gint32 start;
 656         gint32 len;
 657         gint32 filter_offset;
 658 } MonoILExceptionBlock;
 659
 660 typedef struct {
 661         MonoObject object;
 662         MonoReflectionType *catch_type;
 663         gint32 filter_offset;
 664         gint32 flags;
 665         gint32 try_offset;
 666         gint32 try_length;
 667         gint32 handler_offset;
 668         gint32 handler_length;
 669 } MonoReflectionExceptionHandlingClause;
 670
 671 typedef struct {
 672         MonoObject object;
 673         MonoReflectionType *local_type;
 674         MonoBoolean is_pinned;
 675         guint16 local_index;
 676 } MonoReflectionLocalVariableInfo;
 677
 678 typedef struct {
 679         /*
 680          * Must have the same layout as MonoReflectionLocalVariableInfo, since
 681          * LocalBuilder inherits from it under net 2.0.
 682          */
 683         MonoObject object;
 684         MonoReflectionType *type;
 685         MonoBoolean is_pinned;
 686         guint16 local_index;
 687         MonoString *name;
 688 } MonoReflectionLocalBuilder;
 689
 690 typedef struct {
 691         MonoObject object;
 692         gint32 count;
 693         gint32 type;
 694         gint32 eltype;
 695         MonoString *guid;
 696         MonoString *mcookie;
 697         MonoString *marshaltype;
 698         MonoReflectionType *marshaltyperef;
 699         gint32 param_num;
 700         MonoBoolean has_size;
 701 } MonoReflectionMarshal;
 702
 703 typedef struct {
 704         MonoObject object;
 705         MonoObject* methodb;
 706         MonoString *name;
 707         MonoArray *cattrs;
 708         MonoReflectionMarshal *marshal_info;
 709         guint32 attrs;
 710         int position;
 711         guint32 table_idx;
 712         MonoObject *def_value;
 713 } MonoReflectionParamBuilder;
 714
 715 typedef struct {
 716         MonoObject object;
 717         MonoMethod *mhandle;
 718         MonoReflectionILGen *ilgen;
 719         MonoArray *parameters;
 720         guint32 attrs;
 721         guint32 iattrs;
 722         guint32 table_idx;
 723         guint32 call_conv;
 724         MonoObject *type;
 725         MonoArray *pinfo;
 726         MonoArray *cattrs;
 727         MonoBoolean init_locals;
 728         MonoArray *param_modreq;
 729         MonoArray *param_modopt;
 730         MonoArray *permissions;
 731 } MonoReflectionCtorBuilder;
 732
 733 typedef struct {
 734         MonoObject object;
 735         MonoMethod *mhandle;
 736         MonoReflectionType *rtype;
 737         MonoArray *parameters;
 738         guint32 attrs;
 739         guint32 iattrs;
 740         MonoString *name;
 741         guint32 table_idx;
 742         MonoArray *code;
 743         MonoReflectionILGen *ilgen;
 744         MonoObject *type;
 745         MonoArray *pinfo;
 746         MonoArray *cattrs;
 747         MonoReflectionMethod *override_method;
 748         MonoString *dll;
 749         MonoString *dllentry;
 750         guint32 charset;
 751         guint32 extra_flags;
 752         guint32 native_cc;
 753         guint32 call_conv;
 754         MonoBoolean init_locals;
 755         MonoGenericContainer *generic_container;
 756         MonoArray *generic_params;
 757         MonoArray *return_modreq;
 758         MonoArray *return_modopt;
 759         MonoArray *param_modreq;
 760         MonoArray *param_modopt;
 761         MonoArray *permissions;
 762 } MonoReflectionMethodBuilder;
 763
 764 typedef struct {
 765         MonoObject object;
 766         MonoMethod *mhandle;
 767         MonoReflectionType *parent;
 768         MonoReflectionType *ret;
 769         MonoArray *parameters;
 770         MonoString *name;
 771         guint32 table_idx;
 772         guint32 call_conv;
 773 } MonoReflectionArrayMethod;
 774
 775 typedef struct {
 776         MonoArray *data;
 777         MonoString *name;
 778         MonoString *filename;
 779         guint32 attrs;
 780         guint32 offset;
 781         MonoObject *stream;
 782 } MonoReflectionResource;
 783
 784 typedef struct {
 785         guint32 res_type;
 786         guint32 res_id;
 787         guint32 lang_id;
 788         MonoArray *res_data;
 789 } MonoReflectionWin32Resource;
 790
 791 typedef struct {
 792         guint32 action;
 793         MonoString *pset;
 794 } MonoReflectionPermissionSet;
 795
 796 typedef struct {
 797         MonoReflectionAssembly assembly;
 798         MonoDynamicAssembly *dynamic_assembly;
 799         MonoReflectionMethod *entry_point;
 800         MonoArray *modules;
 801         MonoString *name;
 802         MonoString *dir;
 803         MonoArray *cattrs;
 804         MonoArray *resources;
 805         MonoArray *public_key;
 806         MonoString *version;
 807         MonoString *culture;
 808         guint32 algid;
 809         guint32 flags;
 810         guint32 pekind;
 811         MonoBoolean delay_sign;
 812         guint32 access;
 813         MonoArray *loaded_modules;
 814         MonoArray *win32_resources;
 815         /* CAS related */
 816         MonoArray *permissions_minimum;
 817         MonoArray *permissions_optional;
 818         MonoArray *permissions_refused;
 819         gint32 pe_kind;
 820         gint32 machine;
 821         MonoBoolean corlib_internal;
 822         MonoArray *type_forwarders;
 823 } MonoReflectionAssemblyBuilder;
 824
 825 typedef struct {
 826         MonoObject object;
 827         guint32 attrs;
 828         MonoReflectionType *type;
 829         MonoString *name;
 830         MonoObject *def_value;
 831         gint32 offset;
 832         gint32 table_idx;
 833         MonoReflectionType *typeb;
 834         MonoArray *rva_data;
 835         MonoArray *cattrs;
 836         MonoReflectionMarshal *marshal_info;
 837         MonoClassField *handle;
 838         MonoArray *modreq;
 839         MonoArray *modopt;
 840 } MonoReflectionFieldBuilder;
 841
 842 typedef struct {
 843         MonoObject object;
 844         guint32 attrs;
 845         MonoString *name;
 846         MonoReflectionType *type;
 847         MonoArray *parameters;
 848         MonoArray *cattrs;
 849         MonoObject *def_value;
 850         MonoReflectionMethodBuilder *set_method;
 851         MonoReflectionMethodBuilder *get_method;
 852         gint32 table_idx;
 853 } MonoReflectionPropertyBuilder;
 854
 855 struct _MonoReflectionModule {
 856         MonoObject      obj;
 857         MonoImage  *image;
 858         MonoReflectionAssembly *assembly;
 859         MonoString *fqname;
 860         MonoString *name;
 861         MonoString *scopename;
 862         MonoBoolean is_resource;
 863         guint32 token;
 864 };
 865
 866 typedef struct {
 867         MonoReflectionModule module;
 868         MonoDynamicImage *dynamic_image;
 869         gint32     num_types;
 870         MonoArray *types;
 871         MonoArray *cattrs;
 872         MonoArray *guid;
 873         guint32    table_idx;
 874         MonoReflectionAssemblyBuilder *assemblyb;
 875         MonoArray *global_methods;
 876         MonoArray *global_fields;
 877         gboolean is_main;
 878         MonoArray *resources;
 879 } MonoReflectionModuleBuilder;
 880
 881 typedef struct {
 882         MonoReflectionType type;
 883         MonoString *name;
 884         MonoString *nspace;
 885         MonoReflectionType *parent;
 886         MonoReflectionType *nesting_type;
 887         MonoArray *interfaces;
 888         gint32     num_methods;
 889         MonoArray *methods;
 890         MonoArray *ctors;
 891         MonoArray *properties;
 892         gint32     num_fields;
 893         MonoArray *fields;
 894         MonoArray *events;
 895         MonoArray *cattrs;
 896         MonoArray *subtypes;
 897         guint32 attrs;
 898         guint32 table_idx;
 899         MonoReflectionModuleBuilder *module;
 900         gint32 class_size;
 901         gint32 packing_size;
 902         MonoGenericContainer *generic_container;
 903         MonoArray *generic_params;
 904         MonoArray *permissions;
 905         MonoReflectionType *created;
 906 } MonoReflectionTypeBuilder;
 907
 908 typedef struct {
 909         MonoReflectionType type;
 910         MonoReflectionTypeBuilder *tbuilder;
 911         MonoReflectionMethodBuilder *mbuilder;
 912         MonoString *name;
 913         guint32 index;
 914         MonoReflectionType *base_type;
 915         MonoArray *iface_constraints;
 916         MonoArray *cattrs;
 917         guint32 attrs;
 918 } MonoReflectionGenericParam;
 919
 920 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
 921 struct _MonoReflectionGenericClass {
 922         MonoReflectionType type;
 923         MonoReflectionType *generic_type;
 924         guint32 initialized;
 925 };
 926
 927 typedef struct {
 928         MonoObject  obj;
 929         MonoString *name;
 930         MonoString *codebase;
 931         gint32 major, minor, build, revision;
 932         MonoObject  *cultureInfo;
 933         guint32     flags;
 934         guint32     hashalg;
 935         MonoObject  *keypair;
 936         MonoArray   *publicKey;
 937         MonoArray   *keyToken;
 938         guint32     versioncompat;
 939         MonoObject *version;
 940 } MonoReflectionAssemblyName;
 941
 942 typedef struct {
 943         MonoObject  obj;
 944         MonoString *name;
 945         MonoReflectionType *type;
 946         MonoReflectionTypeBuilder *typeb;
 947         MonoArray *cattrs;
 948         MonoReflectionMethodBuilder *add_method;
 949         MonoReflectionMethodBuilder *remove_method;
 950         MonoReflectionMethodBuilder *raise_method;
 951         MonoArray *other_methods;
 952         guint32 attrs;
 953         guint32 table_idx;
 954 } MonoReflectionEventBuilder;
 955
 956 typedef struct {
 957         MonoObject  obj;
 958         MonoReflectionMethod *ctor;
 959         MonoArray *data;
 960 } MonoReflectionCustomAttr;
 961
 962 typedef struct {
 963         MonoObject object;
 964         gint32 call_conv;
 965         gint32 charset;
 966         MonoString *dll;
 967         MonoString *entry_point;
 968         MonoBoolean exact_spelling;
 969         MonoBoolean preserve_sig;
 970         MonoBoolean set_last_error;
 971         MonoBoolean best_fit_mapping;
 972         MonoBoolean throw_on_unmappable;
 973 } MonoReflectionDllImportAttribute;
 974
 975 typedef struct {
 976         MonoObject object;
 977         gint32 call_conv;
 978         gint32 charset;
 979         MonoBoolean set_last_error;
 980         MonoBoolean best_fit_mapping;
 981         MonoBoolean throw_on_unmappable;
 982 } MonoReflectionUnmanagedFunctionPointerAttribute;
 983
 984 typedef struct {
 985         MonoObject object;
 986         MonoMethod *mhandle;
 987         MonoString *name;
 988         MonoReflectionType *rtype;
 989         MonoArray *parameters;
 990         guint32 attrs;
 991         guint32 call_conv;
 992         MonoReflectionModule *module;
 993         MonoBoolean skip_visibility;
 994         MonoBoolean init_locals;
 995         MonoReflectionILGen *ilgen;
 996         gint32 nrefs;
 997         MonoArray *refs;
 998 } MonoReflectionDynamicMethod;
 999
1000 typedef struct {
1001         MonoObject object;
1002         MonoReflectionModuleBuilder *module;
1003         MonoArray *arguments;
1004         guint32 type;
1005         MonoReflectionType *return_type;
1006         guint32 call_conv;
1007         guint32 unmanaged_call_conv;
1008 } MonoReflectionSigHelper;
1009
1010 enum {
1011         RESOURCE_LOCATION_EMBEDDED = 1,
1012         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
1013         RESOURCE_LOCATION_IN_MANIFEST = 4
1014 };
1015
1016 typedef struct {
1017         MonoObject object;
1018         MonoReflectionAssembly *assembly;
1019         MonoString *filename;
1020         guint32 location;
1021 } MonoManifestResourceInfo;
1022
1023 /* Keep in sync with System.GenericParameterAttributes */
1024 typedef enum {
1025         GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT         = 0,
1026         GENERIC_PARAMETER_ATTRIBUTE_COVARIANT           = 1,
1027         GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT       = 2,
1028         GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK       = 3,
1029
1030         GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT       = 0,
1031         GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT   = 4,
1032         GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT       = 8,
1033         GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT      = 16,
1034         GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK    = 28
1035 } GenericParameterAttributes;
1036
1037 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file);
1038 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
1039 MonoReflectionModule * mono_image_load_module (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name);
1040 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str);
1041 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec);
1042 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types);
1043 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
1044
1045 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
1046
1047 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
1048
1049 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb);
1050
1051 void        mono_reflection_create_generic_class  (MonoReflectionTypeBuilder *tb);
1052
1053 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
1054
1055 void        mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides);
1056
1057 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
1058
1059 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
1060
1061 MonoType*
1062 mono_class_bind_generic_parameters (MonoType *type, int type_argc, MonoType **types);
1063 MonoType*
1064 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types);
1065 MonoReflectionMethod*
1066 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
1067 void
1068 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
1069 MonoReflectionEvent *
1070 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
1071
1072 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
1073
1074 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
1075
1076 MonoReflectionMarshal* mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec);
1077
1078 gpointer
1079 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, MonoClass **handle_class);
1080
1081 gboolean
1082 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass);
1083
1084 void
1085 mono_image_build_metadata (MonoReflectionModuleBuilder *module);
1086
1087 int
1088 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value);
1089
1090 void
1091 mono_release_type_locks (MonoThread *thread);
1092
1093 char *
1094 mono_string_to_utf8_mp  (MonoMemPool *mp, MonoString *s);
1095
1096 MonoArray*
1097 mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array);
1098
1099 void
1100 mono_array_full_copy (MonoArray *src, MonoArray *dest);
1101
1102 gpointer
1103 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy);
1104
1105 MonoMethodSignature*
1106 mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 token, MonoGenericContext *context);
1107
1108 void
1109 mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass);
1110
1111 gpointer
1112 mono_get_addr_from_ftnptr (gpointer descr);
1113
1114 void
1115 mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass);
1116
1117 MonoObject*
1118 mono_nullable_box (guint8 *buf, MonoClass *klass);
1119
1120 #endif /* __MONO_OBJECT_INTERNALS_H__ */
1121