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