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