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