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         gboolean unmanaged;
 237 };
 238
 239 typedef struct {
 240         MonoString *name;
 241         MonoReflectionType *type;
 242         MonoObject *value;
 243 } MonoSerializationEntry;
 244
 245 typedef struct {
 246         guint32 state;
 247         MonoObject *additional;
 248 } MonoStreamingContext;
 249
 250 typedef struct {
 251         MonoObject obj;
 252         MonoBoolean readOnly;
 253         MonoString *AMDesignator;
 254         MonoString *PMDesignator;
 255         MonoString *DateSeparator;
 256         MonoString *TimeSeparator;
 257         MonoString *ShortDatePattern;
 258         MonoString *LongDatePattern;
 259         MonoString *ShortTimePattern;
 260         MonoString *LongTimePattern;
 261         MonoString *MonthDayPattern;
 262         MonoString *YearMonthPattern;
 263         MonoString *FullDateTimePattern;
 264         MonoString *RFC1123Pattern;
 265         MonoString *SortableDateTimePattern;
 266         MonoString *UniversalSortableDateTimePattern;
 267         guint32 FirstDayOfWeek;
 268         MonoObject *Calendar;
 269         guint32 CalendarWeekRule;
 270         MonoArray *AbbreviatedDayNames;
 271         MonoArray *DayNames;
 272         MonoArray *MonthNames;
 273         MonoArray *AbbreviatedMonthNames;
 274         MonoArray *ShortDatePatterns;
 275         MonoArray *LongDatePatterns;
 276         MonoArray *ShortTimePatterns;
 277         MonoArray *LongTimePatterns;
 278 } MonoDateTimeFormatInfo;
 279
 280 typedef struct
 281 {
 282         MonoObject obj;
 283         MonoBoolean readOnly;
 284         MonoString *decimalFormats;
 285         MonoString *currencyFormats;
 286         MonoString *percentFormats;
 287         MonoString *digitPattern;
 288         MonoString *zeroPattern;
 289         gint32 currencyDecimalDigits;
 290         MonoString *currencyDecimalSeparator;
 291         MonoString *currencyGroupSeparator;
 292         MonoArray *currencyGroupSizes;
 293         gint32 currencyNegativePattern;
 294         gint32 currencyPositivePattern;
 295         MonoString *currencySymbol;
 296         MonoString *naNSymbol;
 297         MonoString *negativeInfinitySymbol;
 298         MonoString *negativeSign;
 299         guint32 numberDecimalDigits;
 300         MonoString *numberDecimalSeparator;
 301         MonoString *numberGroupSeparator;
 302         MonoArray *numberGroupSizes;
 303         gint32 numberNegativePattern;
 304         gint32 percentDecimalDigits;
 305         MonoString *percentDecimalSeparator;
 306         MonoString *percentGroupSeparator;
 307         MonoArray *percentGroupSizes;
 308         gint32 percentNegativePattern;
 309         gint32 percentPositivePattern;
 310         MonoString *percentSymbol;
 311         MonoString *perMilleSymbol;
 312         MonoString *positiveInfinitySymbol;
 313         MonoString *positiveSign;
 314 } MonoNumberFormatInfo;
 315
 316 typedef struct {
 317         MonoObject obj;
 318         gint32 lcid;
 319         MonoString *icu_name;
 320         gpointer ICU_collator;
 321 } MonoCompareInfo;
 322
 323 typedef struct {
 324         MonoObject obj;
 325         MonoBoolean is_read_only;
 326         gint32 lcid;
 327         gint32 parent_lcid;
 328         gint32 specific_lcid;
 329         gint32 datetime_index;
 330         gint32 number_index;
 331         MonoBoolean use_user_override;
 332         MonoNumberFormatInfo *number_format;
 333         MonoDateTimeFormatInfo *datetime_format;
 334         MonoObject *textinfo;
 335         MonoString *name;
 336         MonoString *displayname;
 337         MonoString *englishname;
 338         MonoString *nativename;
 339         MonoString *iso3lang;
 340         MonoString *iso2lang;
 341         MonoString *icu_name;
 342         MonoString *win3lang;
 343         MonoCompareInfo *compareinfo;
 344         const gint32 *calendar_data;
 345 } MonoCultureInfo;
 346
 347 typedef struct {
 348         MonoObject obj;
 349         MonoString *str;
 350         gint32 options;
 351         MonoArray *key;
 352         gint32 lcid;
 353 } MonoSortKey;
 354
 355 /* used to free a dynamic method */
 356 typedef void        (*MonoFreeMethodFunc)        (MonoDomain *domain, MonoMethod *method);
 357
 358 /* remoting and async support */
 359
 360 MonoAsyncResult *
 361 mono_async_result_new       (MonoDomain *domain, HANDLE handle,
 362                              MonoObject *state, gpointer data);
 363
 364 MonoWaitHandle *
 365 mono_wait_handle_new        (MonoDomain *domain, HANDLE handle);
 366
 367 void
 368 mono_message_init           (MonoDomain *domain, MonoMethodMessage *this_obj,
 369                              MonoReflectionMethod *method, MonoArray *out_args);
 370
 371 MonoObject *
 372 mono_remoting_invoke        (MonoObject *real_proxy, MonoMethodMessage *msg,
 373                              MonoObject **exc, MonoArray **out_args);
 374
 375 MonoObject *
 376 mono_message_invoke         (MonoObject *target, MonoMethodMessage *msg,
 377                              MonoObject **exc, MonoArray **out_args);
 378
 379 MonoMethodMessage *
 380 mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke,
 381                               MonoDelegate **cb, MonoObject **state);
 382
 383 void
 384 mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args);
 385
 386 void
 387 mono_delegate_ctor          (MonoObject *this_obj, MonoObject *target, gpointer addr);
 388
 389 void
 390 mono_runtime_free_method    (MonoDomain *domain, MonoMethod *method);
 391
 392 /* runtime initialization functions */
 393 typedef void (*MonoExceptionFunc) (MonoException *ex);
 394
 395 void
 396 mono_install_handler        (MonoExceptionFunc func);
 397
 398 void
 399 mono_install_runtime_invoke (MonoInvokeFunc func);
 400
 401 void
 402 mono_install_compile_method (MonoCompileFunc func);
 403
 404 void
 405 mono_install_free_method    (MonoFreeMethodFunc func);
 406
 407 void
 408 mono_type_initialization_init (void);
 409
 410 /* Reflection and Reflection.Emit support */
 411
 412 /*
 413  * The following structure must match the C# implementation in our corlib.
 414  */
 415
 416 struct _MonoReflectionMethod {
 417         MonoObject object;
 418         MonoMethod *method;
 419         MonoString *name;
 420         MonoReflectionType *reftype;
 421 };
 422
 423 struct _MonoDelegate {
 424         MonoObject object;
 425         MonoObject *target_type;
 426         MonoObject *target;
 427         MonoString *method_name;
 428         gpointer method_ptr;
 429         gpointer delegate_trampoline;
 430         MonoReflectionMethod *method_info;
 431 };
 432
 433 typedef struct _MonoMulticastDelegate MonoMulticastDelegate;
 434 struct _MonoMulticastDelegate {
 435         MonoDelegate delegate;
 436         MonoMulticastDelegate *prev;
 437 };
 438
 439 struct _MonoReflectionField {
 440         MonoObject object;
 441         MonoClass *klass;
 442         MonoClassField *field;
 443         MonoString *name;
 444         MonoReflectionType *type;
 445         guint32 attrs;
 446 };
 447
 448 struct _MonoReflectionProperty {
 449         MonoObject object;
 450         MonoClass *klass;
 451         MonoProperty *property;
 452 };
 453
 454 struct _MonoReflectionEvent {
 455         MonoObject object;
 456         MonoClass *klass;
 457         MonoEvent *event;
 458 };
 459
 460 typedef struct {
 461         MonoObject object;
 462         MonoReflectionType *ClassImpl;
 463         MonoObject *DefaultValueImpl;
 464         MonoObject *MemberImpl;
 465         MonoString *NameImpl;
 466         gint32 PositionImpl;
 467         guint32 AttrsImpl;
 468         MonoObject *MarshalAsImpl;
 469 } MonoReflectionParameter;
 470
 471 struct _MonoReflectionMethodBody {
 472         MonoObject object;
 473         MonoArray *clauses;
 474         MonoArray *locals;
 475         MonoArray *il;
 476         MonoBoolean init_locals;
 477         guint32 sig_token;
 478         guint32 max_stack;
 479 };
 480
 481 struct _MonoReflectionAssembly {
 482         MonoObject object;
 483         MonoAssembly *assembly;
 484         MonoObject *resolve_event_holder;
 485         /* CAS related */
 486         MonoObject *evidence;   /* Evidence */
 487         MonoObject *minimum;    /* PermissionSet - for SecurityAction.RequestMinimum */
 488         MonoObject *optional;   /* PermissionSet - for SecurityAction.RequestOptional */
 489         MonoObject *refuse;     /* PermissionSet - for SecurityAction.RequestRefuse */
 490         MonoObject *granted;    /* PermissionSet - for the resolved assembly granted permissions */
 491         MonoObject *denied;     /* PermissionSet - for the resolved assembly denied permissions */
 492 };
 493
 494 typedef struct {
 495         MonoReflectionType *utype;
 496         MonoArray *values;
 497         MonoArray *names;
 498 } MonoEnumInfo;
 499
 500 typedef struct {
 501         MonoReflectionType *parent;
 502         MonoReflectionType *ret;
 503         guint32 attrs;
 504         guint32 implattrs;
 505         guint32 callconv;
 506 } MonoMethodInfo;
 507
 508 typedef struct {
 509         MonoReflectionType *parent;
 510         MonoString *name;
 511         MonoReflectionMethod *get;
 512         MonoReflectionMethod *set;
 513         guint32 attrs;
 514 } MonoPropertyInfo;
 515
 516 typedef struct {
 517         MonoReflectionType *declaring_type;
 518         MonoReflectionType *reflected_type;
 519         MonoString *name;
 520         MonoReflectionMethod *add_method;
 521         MonoReflectionMethod *remove_method;
 522         MonoReflectionMethod *raise_method;
 523         guint32 attrs;
 524         MonoArray *other_methods;
 525 } MonoEventInfo;
 526
 527 typedef struct {
 528         MonoString *name;
 529         MonoString *name_space;
 530         MonoReflectionType *etype;
 531         MonoReflectionType *nested_in;
 532         MonoReflectionAssembly *assembly;
 533         guint32 rank;
 534         MonoBoolean isprimitive;
 535 } MonoTypeInfo;
 536
 537 typedef struct {
 538         MonoObject *member;
 539         gint32 code_pos;
 540 } MonoReflectionILTokenInfo;
 541
 542 typedef struct {
 543         MonoObject object;
 544         MonoArray *code;
 545         gint32 code_len;
 546         gint32 max_stack;
 547         gint32 cur_stack;
 548         MonoArray *locals;
 549         MonoArray *ex_handlers;
 550         gint32 num_token_fixups;
 551         MonoArray *token_fixups;
 552 } MonoReflectionILGen;
 553
 554 typedef struct {
 555         MonoArray *handlers;
 556         gint32 start;
 557         gint32 len;
 558         gint32 label;
 559 } MonoILExceptionInfo;
 560
 561 typedef struct {
 562         MonoReflectionType *extype;
 563         gint32 type;
 564         gint32 start;
 565         gint32 len;
 566         gint32 filter_offset;
 567 } MonoILExceptionBlock;
 568
 569 typedef struct {
 570         MonoObject object;
 571         MonoReflectionType *local_type;
 572         MonoBoolean is_pinned;
 573         int local_index;
 574 } MonoReflectionLocalVariableInfo;
 575
 576 typedef struct {
 577         /*
 578          * Must have the same layout as MonoReflectionLocalVariableInfo, since
 579          * LocalBuilder inherits from it under net 2.0.
 580          */
 581         MonoObject object;
 582         MonoReflectionType *type;
 583         MonoBoolean is_pinned;
 584         guint16 local_index;
 585         MonoString *name;
 586 } MonoReflectionLocalBuilder;
 587
 588 typedef struct {
 589         MonoObject object;
 590         gint32 count;
 591         gint32 type;
 592         gint32 eltype;
 593         MonoString *guid;
 594         MonoString *mcookie;
 595         MonoString *marshaltype;
 596         MonoReflectionType *marshaltyperef;
 597 } MonoReflectionMarshal;
 598
 599 typedef struct {
 600         MonoObject object;
 601         MonoObject* methodb;
 602         MonoString *name;
 603         MonoArray *cattrs;
 604         MonoReflectionMarshal *marshal_info;
 605         guint32 attrs;
 606         int position;
 607         guint32 table_idx;
 608         MonoObject *def_value;
 609 } MonoReflectionParamBuilder;
 610
 611 typedef struct {
 612         MonoObject object;
 613         MonoMethod *mhandle;
 614         MonoReflectionILGen *ilgen;
 615         MonoArray *parameters;
 616         guint32 attrs;
 617         guint32 iattrs;
 618         guint32 table_idx;
 619         guint32 call_conv;
 620         MonoObject *type;
 621         MonoArray *pinfo;
 622         MonoArray *cattrs;
 623         MonoBoolean init_locals;
 624         MonoArray *param_modreq;
 625         MonoArray *param_modopt;
 626         MonoArray *permissions;
 627 } MonoReflectionCtorBuilder;
 628
 629 typedef struct {
 630         MonoObject object;
 631         MonoMethod *mhandle;
 632         MonoReflectionType *rtype;
 633         MonoArray *parameters;
 634         guint32 attrs;
 635         guint32 iattrs;
 636         MonoString *name;
 637         guint32 table_idx;
 638         MonoArray *code;
 639         MonoReflectionILGen *ilgen;
 640         MonoObject *type;
 641         MonoArray *pinfo;
 642         MonoArray *cattrs;
 643         MonoReflectionMethod *override_method;
 644         MonoString *dll;
 645         MonoString *dllentry;
 646         guint32 charset;
 647         guint32 native_cc;
 648         guint32 call_conv;
 649         MonoBoolean init_locals;
 650         MonoGenericContainer *generic_container;
 651         MonoArray *generic_params;
 652         MonoArray *return_modreq;
 653         MonoArray *return_modopt;
 654         MonoArray *param_modreq;
 655         MonoArray *param_modopt;
 656         MonoArray *permissions;
 657 } MonoReflectionMethodBuilder;
 658
 659 typedef struct {
 660         MonoObject object;
 661         MonoMethod *mhandle;
 662         MonoReflectionType *parent;
 663         MonoReflectionType *ret;
 664         MonoArray *parameters;
 665         MonoString *name;
 666         guint32 table_idx;
 667         guint32 call_conv;
 668 } MonoReflectionArrayMethod;
 669
 670 typedef struct {
 671         MonoArray *data;
 672         MonoString *name;
 673         MonoString *filename;
 674         guint32 attrs;
 675         guint32 offset;
 676 } MonoReflectionResource;
 677
 678 typedef struct {
 679         guint32 res_type;
 680         guint32 res_id;
 681         guint32 lang_id;
 682         MonoArray *res_data;
 683 } MonoReflectionWin32Resource;
 684
 685 typedef struct {
 686         guint32 action;
 687         MonoString *pset;
 688 } MonoReflectionPermissionSet;
 689
 690 typedef struct {
 691         MonoReflectionAssembly assembly;
 692         MonoDynamicAssembly *dynamic_assembly;
 693         MonoReflectionMethod *entry_point;
 694         MonoArray *modules;
 695         MonoString *name;
 696         MonoString *dir;
 697         MonoArray *cattrs;
 698         MonoArray *resources;
 699         MonoArray *public_key;
 700         MonoString *version;
 701         MonoString *culture;
 702         guint32 algid;
 703         guint32 flags;
 704         guint32 pekind;
 705         MonoBoolean delay_sign;
 706         guint32 access;
 707         MonoArray *loaded_modules;
 708         MonoArray *win32_resources;
 709         /* CAS related */
 710         MonoArray *permissions_minimum;
 711         MonoArray *permissions_optional;
 712         MonoArray *permissions_refused;
 713         gint32 pe_kind;
 714         gint32 machine;
 715 } MonoReflectionAssemblyBuilder;
 716
 717 typedef struct {
 718         MonoObject object;
 719         guint32 attrs;
 720         MonoReflectionType *type;
 721         MonoString *name;
 722         MonoObject *def_value;
 723         gint32 offset;
 724         gint32 table_idx;
 725         MonoReflectionType *typeb;
 726         MonoArray *rva_data;
 727         MonoArray *cattrs;
 728         MonoReflectionMarshal *marshal_info;
 729         MonoClassField *handle;
 730         MonoArray *modreq;
 731         MonoArray *modopt;
 732 } MonoReflectionFieldBuilder;
 733
 734 typedef struct {
 735         MonoObject object;
 736         guint32 attrs;
 737         MonoString *name;
 738         MonoReflectionType *type;
 739         MonoArray *parameters;
 740         MonoArray *cattrs;
 741         MonoObject *def_value;
 742         MonoReflectionMethodBuilder *set_method;
 743         MonoReflectionMethodBuilder *get_method;
 744         gint32 table_idx;
 745 } MonoReflectionPropertyBuilder;
 746
 747 struct _MonoReflectionModule {
 748         MonoObject      obj;
 749         MonoImage  *image;
 750         MonoReflectionAssembly *assembly;
 751         MonoString *fqname;
 752         MonoString *name;
 753         MonoString *scopename;
 754         MonoBoolean is_resource;
 755         guint32 token;
 756 };
 757
 758 typedef struct {
 759         MonoReflectionModule module;
 760         MonoDynamicImage *dynamic_image;
 761         gint32     num_types;
 762         MonoArray *types;
 763         MonoArray *cattrs;
 764         MonoArray *guid;
 765         guint32    table_idx;
 766         MonoReflectionAssemblyBuilder *assemblyb;
 767         MonoArray *global_methods;
 768         MonoArray *global_fields;
 769         gboolean is_main;
 770         MonoArray *resources;
 771 } MonoReflectionModuleBuilder;
 772
 773 typedef struct {
 774         MonoReflectionType type;
 775         MonoString *name;
 776         MonoString *nspace;
 777         MonoReflectionType *parent;
 778         MonoReflectionType *nesting_type;
 779         MonoArray *interfaces;
 780         gint32     num_methods;
 781         MonoArray *methods;
 782         MonoArray *ctors;
 783         MonoArray *properties;
 784         gint32     num_fields;
 785         MonoArray *fields;
 786         MonoArray *events;
 787         MonoArray *cattrs;
 788         MonoArray *subtypes;
 789         guint32 attrs;
 790         guint32 table_idx;
 791         MonoReflectionModuleBuilder *module;
 792         gint32 class_size;
 793         gint32 packing_size;
 794         MonoGenericContainer *generic_container;
 795         MonoArray *generic_params;
 796         MonoArray *permissions;
 797         MonoReflectionType *created;
 798 } MonoReflectionTypeBuilder;
 799
 800 typedef struct {
 801         MonoReflectionType type;
 802         MonoReflectionTypeBuilder *tbuilder;
 803         MonoReflectionMethodBuilder *mbuilder;
 804         MonoString *name;
 805         guint32 index;
 806         MonoReflectionType *base_type;
 807         MonoArray *iface_constraints;
 808         guint32 attrs;
 809 } MonoReflectionGenericParam;
 810
 811 typedef struct _MonoReflectionGenericClass MonoReflectionGenericClass;
 812 struct _MonoReflectionGenericClass {
 813         MonoReflectionType type;
 814         MonoReflectionType *generic_type;
 815         guint32 initialized;
 816 };
 817
 818 typedef struct {
 819         MonoObject  obj;
 820         MonoString *name;
 821         MonoString *codebase;
 822         gint32 major, minor, build, revision;
 823         /* FIXME: add missing stuff */
 824 /*      CultureInfo cultureinfo;
 825         AssemblyNameFlags flags;
 826         AssemblyHashAlgorithm hashalg;
 827         StrongNameKeyPair keypair;
 828         AssemblyVersionCompatibility versioncompat;*/
 829         MonoObject  *cultureInfo;
 830         guint32     flags;
 831         guint32     hashalg;
 832         MonoObject  *keypair;
 833         MonoArray   *publicKey;
 834         MonoArray   *keyToken;
 835         MonoObject  *versioncompat;
 836 } MonoReflectionAssemblyName;
 837
 838 typedef struct {
 839         MonoObject  obj;
 840         MonoString *name;
 841         MonoReflectionType *type;
 842         MonoReflectionTypeBuilder *typeb;
 843         MonoArray *cattrs;
 844         MonoReflectionMethodBuilder *add_method;
 845         MonoReflectionMethodBuilder *remove_method;
 846         MonoReflectionMethodBuilder *raise_method;
 847         MonoArray *other_methods;
 848         guint32 attrs;
 849         guint32 table_idx;
 850 } MonoReflectionEventBuilder;
 851
 852 typedef struct {
 853         MonoObject  obj;
 854         MonoReflectionMethod *ctor;
 855         MonoArray *data;
 856 } MonoReflectionCustomAttr;
 857
 858 typedef struct {
 859         MonoObject object;
 860         gint32 call_conv;
 861         gint32 charset;
 862         MonoString *dll;
 863         MonoString *entry_point;
 864         MonoBoolean exact_spelling;
 865         MonoBoolean preserve_sig;
 866         MonoBoolean set_last_error;
 867         MonoBoolean best_fit_mapping;
 868         MonoBoolean throw_on_unmappable;
 869 } MonoReflectionDllImportAttribute;
 870
 871 typedef struct {
 872         MonoObject object;
 873         MonoMethod *mhandle;
 874         MonoString *name;
 875         MonoReflectionType *rtype;
 876         MonoArray *parameters;
 877         guint32 attrs;
 878         guint32 call_conv;
 879         MonoReflectionModule *module;
 880         MonoBoolean skip_visibility;
 881         MonoBoolean init_locals;
 882         MonoReflectionILGen *ilgen;
 883         gint32 nrefs;
 884         MonoArray *refs;
 885 } MonoReflectionDynamicMethod;
 886
 887 typedef struct {
 888         MonoObject object;
 889         MonoReflectionModuleBuilder *module;
 890         MonoArray *arguments;
 891         guint32 type;
 892         MonoReflectionType *return_type;
 893         guint32 call_conv;
 894         guint32 unmanaged_call_conv;
 895 } MonoReflectionSigHelper;
 896
 897 enum {
 898         RESOURCE_LOCATION_EMBEDDED = 1,
 899         RESOURCE_LOCATION_ANOTHER_ASSEMBLY = 2,
 900         RESOURCE_LOCATION_IN_MANIFEST = 4
 901 };
 902
 903 typedef struct {
 904         MonoObject object;
 905         MonoReflectionAssembly *assembly;
 906         MonoString *filename;
 907         guint32 location;
 908 } MonoManifestResourceInfo;
 909
 910 /* Keep in sync with System.GenericParameterAttributes */
 911 typedef enum {
 912         GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT         = 0,
 913         GENERIC_PARAMETER_ATTRIBUTE_COVARIANT           = 1,
 914         GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT       = 2,
 915         GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK       = 3,
 916
 917         GENERIC_PARAMETER_ATTRIBUTE_NO_SPECIAL_CONSTRAINT       = 0,
 918         GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT   = 4,
 919         GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT       = 8,
 920         GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT      = 16,
 921         GENREIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINTS_MASK    = 28
 922 } GenericParameterAttributes;
 923
 924 void          mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file);
 925 void          mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly);
 926 MonoReflectionModule * mono_image_load_module (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name);
 927 guint32       mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str);
 928 guint32       mono_image_create_token  (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec);
 929 guint32       mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types);
 930 void          mono_image_module_basic_init (MonoReflectionModuleBuilder *module);
 931
 932 void        mono_reflection_setup_internal_class  (MonoReflectionTypeBuilder *tb);
 933
 934 void        mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb);
 935
 936 void        mono_reflection_setup_generic_class   (MonoReflectionTypeBuilder *tb);
 937
 938 void        mono_reflection_create_generic_class  (MonoReflectionTypeBuilder *tb);
 939
 940 MonoReflectionType* mono_reflection_create_runtime_class  (MonoReflectionTypeBuilder *tb);
 941
 942 void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m);
 943
 944 void        mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam);
 945
 946 MonoType*
 947 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types);
 948 MonoReflectionMethod*
 949 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types);
 950 void
 951 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods, MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events);
 952 MonoReflectionEvent *
 953 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb);
 954
 955 MonoArray  *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig);
 956
 957 MonoArray  *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig);
 958
 959 MonoReflectionMarshal* mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec);
 960
 961 gpointer
 962 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token);
 963
 964 void
 965 mono_image_build_metadata (MonoReflectionModuleBuilder *module);
 966
 967 int
 968 mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value);
 969
 970 void
 971 mono_release_type_locks (MonoThread *thread);
 972
 973 MonoArray*
 974 mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array);
 975
 976 void
 977 mono_array_full_copy (MonoArray *src, MonoArray *dest);
 978
 979 gpointer
 980 mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy);
 981
 982 #endif /* __MONO_OBJECT_INTERNALS_H__ */
 983