mono/metadata/object-internals.h

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