mono/metadata/object-internals.h

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