?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-05-22 Miguel de Icaza <miguel@novell.com>
[mono/afaerber.git] / mono / metadata / icall.c
blob77d001d8db1dde84366f96b391b5758e2f7bdcfe
1 /*
2 * icall.c:
3 *
4 * Authors:
5 * Dietmar Maurer (dietmar@ximian.com)
6 * Paolo Molaro (lupus@ximian.com)
7 * Patrik Torstensson (patrik.torstensson@labs2.com)
8 *
9 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
10 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
11 */
12
13 #include <config.h>
14 #include <glib.h>
15 #include <stdarg.h>
16 #include <string.h>
17 #include <ctype.h>
18 #ifdef HAVE_ALLOCA_H
19 #include <alloca.h>
20 #endif
21 #ifdef HAVE_SYS_TIME_H
22 #include <sys/time.h>
23 #endif
24 #ifdef HAVE_UNISTD_H
25 #include <unistd.h>
26 #endif
27 #if defined (PLATFORM_WIN32)
28 #include <stdlib.h>
29 #endif
30
31 #include "mono/utils/mono-membar.h"
32 #include <mono/metadata/object.h>
33 #include <mono/metadata/threads.h>
34 #include <mono/metadata/threads-types.h>
35 #include <mono/metadata/threadpool.h>
36 #include <mono/metadata/monitor.h>
37 #include <mono/metadata/reflection.h>
38 #include <mono/metadata/assembly.h>
39 #include <mono/metadata/tabledefs.h>
40 #include <mono/metadata/exception.h>
41 #include <mono/metadata/file-io.h>
42 #include <mono/metadata/console-io.h>
43 #include <mono/metadata/socket-io.h>
44 #include <mono/metadata/mono-endian.h>
45 #include <mono/metadata/tokentype.h>
46 #include <mono/metadata/domain-internals.h>
47 #include <mono/metadata/metadata-internals.h>
48 #include <mono/metadata/class-internals.h>
49 #include <mono/metadata/marshal.h>
50 #include <mono/metadata/gc-internal.h>
51 #include <mono/metadata/mono-gc.h>
52 #include <mono/metadata/rand.h>
53 #include <mono/metadata/sysmath.h>
54 #include <mono/metadata/string-icalls.h>
55 #include <mono/metadata/debug-helpers.h>
56 #include <mono/metadata/process.h>
57 #include <mono/metadata/environment.h>
58 #include <mono/metadata/profiler-private.h>
59 #include <mono/metadata/locales.h>
60 #include <mono/metadata/filewatcher.h>
61 #include <mono/metadata/char-conversions.h>
62 #include <mono/metadata/security.h>
63 #include <mono/metadata/mono-config.h>
64 #include <mono/metadata/cil-coff.h>
65 #include <mono/metadata/number-formatter.h>
66 #include <mono/metadata/security-manager.h>
67 #include <mono/metadata/security-core-clr.h>
68 #include <mono/metadata/mono-perfcounters.h>
69 #include <mono/metadata/mono-debug.h>
70 #include <mono/io-layer/io-layer.h>
71 #include <mono/utils/strtod.h>
72 #include <mono/utils/monobitset.h>
73 #include <mono/utils/mono-time.h>
74 #include <mono/utils/mono-proclib.h>
75
76 #if defined (PLATFORM_WIN32)
77 #include <windows.h>
78 #include <shlobj.h>
79 #endif
80 #include "decimal.h"
81
82 static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
83
84 static MonoArray*
85 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional);
86
87 /* This is an implementation of a growable pointer array that avoids doing memory allocations for small sizes.
88 * It works by allocating an initial small array on stack and only going to malloc'd memory if needed.
89 */
90 typedef struct {
91 void **data;
92 int size;
93 int capacity;
94 } MonoPtrArray;
95
96 #define MONO_PTR_ARRAY_MAX_ON_STACK (16)
97
98 #define mono_ptr_array_init(ARRAY, INITIAL_SIZE) do {\
99 (ARRAY).size = 0; \
100 (ARRAY).capacity = MAX (INITIAL_SIZE, MONO_PTR_ARRAY_MAX_ON_STACK); \
101 (ARRAY).data = INITIAL_SIZE > MONO_PTR_ARRAY_MAX_ON_STACK ? mono_gc_alloc_fixed (sizeof (void*) * INITIAL_SIZE, NULL) : g_newa (void*, MONO_PTR_ARRAY_MAX_ON_STACK); \
102 } while (0)
103
104 #define mono_ptr_array_destroy(ARRAY) do {\
105 if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK) \
106 mono_gc_free_fixed ((ARRAY).data); \
107 } while (0)
108
109 #define mono_ptr_array_append(ARRAY, VALUE) do { \
110 if ((ARRAY).size >= (ARRAY).capacity) {\
111 void *__tmp = mono_gc_alloc_fixed (sizeof (void*) * (ARRAY).capacity * 2, NULL); \
112 memcpy (__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void*)); \
113 (ARRAY).data = __tmp; \
114 (ARRAY).capacity *= 2;\
115 }\
116 ((ARRAY).data [(ARRAY).size++] = VALUE); \
117 } while (0)
118
119 #define mono_ptr_array_set(ARRAY, IDX, VALUE) do { \
120 ((ARRAY).data [(IDX)] = VALUE); \
121 } while (0)
122
123 #define mono_ptr_array_get(ARRAY, IDX) ((ARRAY).data [(IDX)])
124
125 #define mono_ptr_array_size(ARRAY) ((ARRAY).size)
126
127
128 static inline MonoBoolean
129 is_generic_parameter (MonoType *type)
130 {
131 return !type->byref && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR);
132 }
133
134 /*
135 * We expect a pointer to a char, not a string
136 */
137 static gboolean
138 mono_double_ParseImpl (char *ptr, double *result)
139 {
140 gchar *endptr = NULL;
141 *result = 0.0;
142
143 MONO_ARCH_SAVE_REGS;
144
145 #ifdef __arm__
146 if (*ptr)
147 *result = strtod (ptr, &endptr);
148 #else
149 if (*ptr){
150 #ifdef _EGLIB_MAJOR
151 /* Need to lock here because EGLIB (#464316) has locking defined as no-ops, and that breaks mono_strtod */
152 EnterCriticalSection (&mono_strtod_mutex);
153 *result = mono_strtod (ptr, &endptr);
154 LeaveCriticalSection (&mono_strtod_mutex);
155 #else
156 *result = mono_strtod (ptr, &endptr);
157 #endif
158 }
159 #endif
160
161 if (!*ptr || (endptr && *endptr))
162 return FALSE;
163
164 return TRUE;
165 }
166
167 static MonoObject *
168 ves_icall_System_Array_GetValueImpl (MonoObject *this, guint32 pos)
169 {
170 MonoClass *ac;
171 MonoArray *ao;
172 gint32 esize;
173 gpointer *ea;
174
175 MONO_ARCH_SAVE_REGS;
176
177 ao = (MonoArray *)this;
178 ac = (MonoClass *)ao->obj.vtable->klass;
179
180 esize = mono_array_element_size (ac);
181 ea = (gpointer*)((char*)ao->vector + (pos * esize));
182
183 if (ac->element_class->valuetype)
184 return mono_value_box (this->vtable->domain, ac->element_class, ea);
185 else
186 return *ea;
187 }
188
189 static MonoObject *
190 ves_icall_System_Array_GetValue (MonoObject *this, MonoObject *idxs)
191 {
192 MonoClass *ac, *ic;
193 MonoArray *ao, *io;
194 gint32 i, pos, *ind;
195
196 MONO_ARCH_SAVE_REGS;
197
198 MONO_CHECK_ARG_NULL (idxs);
199
200 io = (MonoArray *)idxs;
201 ic = (MonoClass *)io->obj.vtable->klass;
202
203 ao = (MonoArray *)this;
204 ac = (MonoClass *)ao->obj.vtable->klass;
205
206 g_assert (ic->rank == 1);
207 if (io->bounds != NULL || io->max_length != ac->rank)
208 mono_raise_exception (mono_get_exception_argument (NULL, NULL));
209
210 ind = (gint32 *)io->vector;
211
212 if (ao->bounds == NULL) {
213 if (*ind < 0 || *ind >= ao->max_length)
214 mono_raise_exception (mono_get_exception_index_out_of_range ());
215
216 return ves_icall_System_Array_GetValueImpl (this, *ind);
217 }
218
219 for (i = 0; i < ac->rank; i++)
220 if ((ind [i] < ao->bounds [i].lower_bound) ||
221 (ind [i] >= (mono_array_lower_bound_t)ao->bounds [i].length + ao->bounds [i].lower_bound))
222 mono_raise_exception (mono_get_exception_index_out_of_range ());
223
224 pos = ind [0] - ao->bounds [0].lower_bound;
225 for (i = 1; i < ac->rank; i++)
226 pos = pos*ao->bounds [i].length + ind [i] -
227 ao->bounds [i].lower_bound;
228
229 return ves_icall_System_Array_GetValueImpl (this, pos);
230 }
231
232 static void
233 ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 pos)
234 {
235 MonoClass *ac, *vc, *ec;
236 gint32 esize, vsize;
237 gpointer *ea, *va;
238 int et, vt;
239
240 guint64 u64 = 0;
241 gint64 i64 = 0;
242 gdouble r64 = 0;
243
244 MONO_ARCH_SAVE_REGS;
245
246 if (value)
247 vc = value->vtable->klass;
248 else
249 vc = NULL;
250
251 ac = this->obj.vtable->klass;
252 ec = ac->element_class;
253
254 esize = mono_array_element_size (ac);
255 ea = (gpointer*)((char*)this->vector + (pos * esize));
256 va = (gpointer*)((char*)value + sizeof (MonoObject));
257
258 if (!value) {
259 memset (ea, 0, esize);
260 return;
261 }
262
263 #define NO_WIDENING_CONVERSION G_STMT_START{\
264 mono_raise_exception (mono_get_exception_argument ( \
265 "value", "not a widening conversion")); \
266 }G_STMT_END
267
268 #define CHECK_WIDENING_CONVERSION(extra) G_STMT_START{\
269 if (esize < vsize + (extra)) \
270 mono_raise_exception (mono_get_exception_argument ( \
271 "value", "not a widening conversion")); \
272 }G_STMT_END
273
274 #define INVALID_CAST G_STMT_START{\
275 mono_raise_exception (mono_get_exception_invalid_cast ()); \
276 }G_STMT_END
277
278 /* Check element (destination) type. */
279 switch (ec->byval_arg.type) {
280 case MONO_TYPE_STRING:
281 switch (vc->byval_arg.type) {
282 case MONO_TYPE_STRING:
283 break;
284 default:
285 INVALID_CAST;
286 }
287 break;
288 case MONO_TYPE_BOOLEAN:
289 switch (vc->byval_arg.type) {
290 case MONO_TYPE_BOOLEAN:
291 break;
292 case MONO_TYPE_CHAR:
293 case MONO_TYPE_U1:
294 case MONO_TYPE_U2:
295 case MONO_TYPE_U4:
296 case MONO_TYPE_U8:
297 case MONO_TYPE_I1:
298 case MONO_TYPE_I2:
299 case MONO_TYPE_I4:
300 case MONO_TYPE_I8:
301 case MONO_TYPE_R4:
302 case MONO_TYPE_R8:
303 NO_WIDENING_CONVERSION;
304 default:
305 INVALID_CAST;
306 }
307 break;
308 }
309
310 if (!ec->valuetype) {
311 if (!mono_object_isinst (value, ec))
312 INVALID_CAST;
313 mono_gc_wbarrier_set_arrayref (this, ea, (MonoObject*)value);
314 return;
315 }
316
317 if (mono_object_isinst (value, ec)) {
318 if (ec->has_references)
319 mono_value_copy (ea, (char*)value + sizeof (MonoObject), ec);
320 else
321 memcpy (ea, (char *)value + sizeof (MonoObject), esize);
322 return;
323 }
324
325 if (!vc->valuetype)
326 INVALID_CAST;
327
328 vsize = mono_class_instance_size (vc) - sizeof (MonoObject);
329
330 et = ec->byval_arg.type;
331 if (et == MONO_TYPE_VALUETYPE && ec->byval_arg.data.klass->enumtype)
332 et = mono_class_enum_basetype (ec->byval_arg.data.klass)->type;
333
334 vt = vc->byval_arg.type;
335 if (vt == MONO_TYPE_VALUETYPE && vc->byval_arg.data.klass->enumtype)
336 vt = mono_class_enum_basetype (vc->byval_arg.data.klass)->type;
337
338 #define ASSIGN_UNSIGNED(etype) G_STMT_START{\
339 switch (vt) { \
340 case MONO_TYPE_U1: \
341 case MONO_TYPE_U2: \
342 case MONO_TYPE_U4: \
343 case MONO_TYPE_U8: \
344 case MONO_TYPE_CHAR: \
345 CHECK_WIDENING_CONVERSION(0); \
346 *(etype *) ea = (etype) u64; \
347 return; \
348 /* You can't assign a signed value to an unsigned array. */ \
349 case MONO_TYPE_I1: \
350 case MONO_TYPE_I2: \
351 case MONO_TYPE_I4: \
352 case MONO_TYPE_I8: \
353 /* You can't assign a floating point number to an integer array. */ \
354 case MONO_TYPE_R4: \
355 case MONO_TYPE_R8: \
356 NO_WIDENING_CONVERSION; \
357 } \
358 }G_STMT_END
359
360 #define ASSIGN_SIGNED(etype) G_STMT_START{\
361 switch (vt) { \
362 case MONO_TYPE_I1: \
363 case MONO_TYPE_I2: \
364 case MONO_TYPE_I4: \
365 case MONO_TYPE_I8: \
366 CHECK_WIDENING_CONVERSION(0); \
367 *(etype *) ea = (etype) i64; \
368 return; \
369 /* You can assign an unsigned value to a signed array if the array's */ \
370 /* element size is larger than the value size. */ \
371 case MONO_TYPE_U1: \
372 case MONO_TYPE_U2: \
373 case MONO_TYPE_U4: \
374 case MONO_TYPE_U8: \
375 case MONO_TYPE_CHAR: \
376 CHECK_WIDENING_CONVERSION(1); \
377 *(etype *) ea = (etype) u64; \
378 return; \
379 /* You can't assign a floating point number to an integer array. */ \
380 case MONO_TYPE_R4: \
381 case MONO_TYPE_R8: \
382 NO_WIDENING_CONVERSION; \
383 } \
384 }G_STMT_END
385
386 #define ASSIGN_REAL(etype) G_STMT_START{\
387 switch (vt) { \
388 case MONO_TYPE_R4: \
389 case MONO_TYPE_R8: \
390 CHECK_WIDENING_CONVERSION(0); \
391 *(etype *) ea = (etype) r64; \
392 return; \
393 /* All integer values fit into a floating point array, so we don't */ \
394 /* need to CHECK_WIDENING_CONVERSION here. */ \
395 case MONO_TYPE_I1: \
396 case MONO_TYPE_I2: \
397 case MONO_TYPE_I4: \
398 case MONO_TYPE_I8: \
399 *(etype *) ea = (etype) i64; \
400 return; \
401 case MONO_TYPE_U1: \
402 case MONO_TYPE_U2: \
403 case MONO_TYPE_U4: \
404 case MONO_TYPE_U8: \
405 case MONO_TYPE_CHAR: \
406 *(etype *) ea = (etype) u64; \
407 return; \
408 } \
409 }G_STMT_END
410
411 switch (vt) {
412 case MONO_TYPE_U1:
413 u64 = *(guint8 *) va;
414 break;
415 case MONO_TYPE_U2:
416 u64 = *(guint16 *) va;
417 break;
418 case MONO_TYPE_U4:
419 u64 = *(guint32 *) va;
420 break;
421 case MONO_TYPE_U8:
422 u64 = *(guint64 *) va;
423 break;
424 case MONO_TYPE_I1:
425 i64 = *(gint8 *) va;
426 break;
427 case MONO_TYPE_I2:
428 i64 = *(gint16 *) va;
429 break;
430 case MONO_TYPE_I4:
431 i64 = *(gint32 *) va;
432 break;
433 case MONO_TYPE_I8:
434 i64 = *(gint64 *) va;
435 break;
436 case MONO_TYPE_R4:
437 r64 = *(gfloat *) va;
438 break;
439 case MONO_TYPE_R8:
440 r64 = *(gdouble *) va;
441 break;
442 case MONO_TYPE_CHAR:
443 u64 = *(guint16 *) va;
444 break;
445 case MONO_TYPE_BOOLEAN:
446 /* Boolean is only compatible with itself. */
447 switch (et) {
448 case MONO_TYPE_CHAR:
449 case MONO_TYPE_U1:
450 case MONO_TYPE_U2:
451 case MONO_TYPE_U4:
452 case MONO_TYPE_U8:
453 case MONO_TYPE_I1:
454 case MONO_TYPE_I2:
455 case MONO_TYPE_I4:
456 case MONO_TYPE_I8:
457 case MONO_TYPE_R4:
458 case MONO_TYPE_R8:
459 NO_WIDENING_CONVERSION;
460 default:
461 INVALID_CAST;
462 }
463 break;
464 }
465
466 /* If we can't do a direct copy, let's try a widening conversion. */
467 switch (et) {
468 case MONO_TYPE_CHAR:
469 ASSIGN_UNSIGNED (guint16);
470 case MONO_TYPE_U1:
471 ASSIGN_UNSIGNED (guint8);
472 case MONO_TYPE_U2:
473 ASSIGN_UNSIGNED (guint16);
474 case MONO_TYPE_U4:
475 ASSIGN_UNSIGNED (guint32);
476 case MONO_TYPE_U8:
477 ASSIGN_UNSIGNED (guint64);
478 case MONO_TYPE_I1:
479 ASSIGN_SIGNED (gint8);
480 case MONO_TYPE_I2:
481 ASSIGN_SIGNED (gint16);
482 case MONO_TYPE_I4:
483 ASSIGN_SIGNED (gint32);
484 case MONO_TYPE_I8:
485 ASSIGN_SIGNED (gint64);
486 case MONO_TYPE_R4:
487 ASSIGN_REAL (gfloat);
488 case MONO_TYPE_R8:
489 ASSIGN_REAL (gdouble);
490 }
491
492 INVALID_CAST;
493 /* Not reached, INVALID_CAST does not return. Just to avoid a compiler warning ... */
494 return;
495
496 #undef INVALID_CAST
497 #undef NO_WIDENING_CONVERSION
498 #undef CHECK_WIDENING_CONVERSION
499 #undef ASSIGN_UNSIGNED
500 #undef ASSIGN_SIGNED
501 #undef ASSIGN_REAL
502 }
503
504 static void
505 ves_icall_System_Array_SetValue (MonoArray *this, MonoObject *value,
506 MonoArray *idxs)
507 {
508 MonoClass *ac, *ic;
509 gint32 i, pos, *ind;
510
511 MONO_ARCH_SAVE_REGS;
512
513 MONO_CHECK_ARG_NULL (idxs);
514
515 ic = idxs->obj.vtable->klass;
516 ac = this->obj.vtable->klass;
517
518 g_assert (ic->rank == 1);
519 if (idxs->bounds != NULL || idxs->max_length != ac->rank)
520 mono_raise_exception (mono_get_exception_argument (NULL, NULL));
521
522 ind = (gint32 *)idxs->vector;
523
524 if (this->bounds == NULL) {
525 if (*ind < 0 || *ind >= this->max_length)
526 mono_raise_exception (mono_get_exception_index_out_of_range ());
527
528 ves_icall_System_Array_SetValueImpl (this, value, *ind);
529 return;
530 }
531
532 for (i = 0; i < ac->rank; i++)
533 if ((ind [i] < this->bounds [i].lower_bound) ||
534 (ind [i] >= (mono_array_lower_bound_t)this->bounds [i].length + this->bounds [i].lower_bound))
535 mono_raise_exception (mono_get_exception_index_out_of_range ());
536
537 pos = ind [0] - this->bounds [0].lower_bound;
538 for (i = 1; i < ac->rank; i++)
539 pos = pos * this->bounds [i].length + ind [i] -
540 this->bounds [i].lower_bound;
541
542 ves_icall_System_Array_SetValueImpl (this, value, pos);
543 }
544
545 static MonoArray *
546 ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
547 {
548 MonoClass *aklass;
549 MonoArray *array;
550 mono_array_size_t *sizes, i;
551 gboolean bounded = FALSE;
552
553 MONO_ARCH_SAVE_REGS;
554
555 MONO_CHECK_ARG_NULL (type);
556 MONO_CHECK_ARG_NULL (lengths);
557
558 MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0);
559 if (bounds)
560 MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds));
561
562 for (i = 0; i < mono_array_length (lengths); i++)
563 if (mono_array_get (lengths, gint32, i) < 0)
564 mono_raise_exception (mono_get_exception_argument_out_of_range (NULL));
565
566 if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0))
567 /* vectors are not the same as one dimensional arrays with no-zero bounds */
568 bounded = TRUE;
569 else
570 bounded = FALSE;
571
572 aklass = mono_bounded_array_class_get (mono_class_from_mono_type (type->type), mono_array_length (lengths), bounded);
573
574 sizes = alloca (aklass->rank * sizeof(mono_array_size_t) * 2);
575 for (i = 0; i < aklass->rank; ++i) {
576 sizes [i] = mono_array_get (lengths, guint32, i);
577 if (bounds)
578 sizes [i + aklass->rank] = mono_array_get (bounds, guint32, i);
579 else
580 sizes [i + aklass->rank] = 0;
581 }
582
583 array = mono_array_new_full (mono_object_domain (type), aklass, sizes, sizes + aklass->rank);
584
585 return array;
586 }
587
588 static MonoArray *
589 ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
590 {
591 MonoClass *aklass;
592 MonoArray *array;
593 mono_array_size_t *sizes, i;
594 gboolean bounded = FALSE;
595
596 MONO_ARCH_SAVE_REGS;
597
598 MONO_CHECK_ARG_NULL (type);
599 MONO_CHECK_ARG_NULL (lengths);
600
601 MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0);
602 if (bounds)
603 MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds));
604
605 for (i = 0; i < mono_array_length (lengths); i++)
606 if ((mono_array_get (lengths, gint64, i) < 0) ||
607 (mono_array_get (lengths, gint64, i) > MONO_ARRAY_MAX_INDEX))
608 mono_raise_exception (mono_get_exception_argument_out_of_range (NULL));
609
610 if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint64, 0) != 0))
611 /* vectors are not the same as one dimensional arrays with no-zero bounds */
612 bounded = TRUE;
613 else
614 bounded = FALSE;
615
616 aklass = mono_bounded_array_class_get (mono_class_from_mono_type (type->type), mono_array_length (lengths), bounded);
617
618 sizes = alloca (aklass->rank * sizeof(mono_array_size_t) * 2);
619 for (i = 0; i < aklass->rank; ++i) {
620 sizes [i] = mono_array_get (lengths, guint64, i);
621 if (bounds)
622 sizes [i + aklass->rank] = (mono_array_size_t) mono_array_get (bounds, guint64, i);
623 else
624 sizes [i + aklass->rank] = 0;
625 }
626
627 array = mono_array_new_full (mono_object_domain (type), aklass, sizes, sizes + aklass->rank);
628
629 return array;
630 }
631
632 static gint32
633 ves_icall_System_Array_GetRank (MonoObject *this)
634 {
635 MONO_ARCH_SAVE_REGS;
636
637 return this->vtable->klass->rank;
638 }
639
640 static gint32
641 ves_icall_System_Array_GetLength (MonoArray *this, gint32 dimension)
642 {
643 gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
644 mono_array_size_t length;
645
646 MONO_ARCH_SAVE_REGS;
647
648 if ((dimension < 0) || (dimension >= rank))
649 mono_raise_exception (mono_get_exception_index_out_of_range ());
650
651 if (this->bounds == NULL)
652 length = this->max_length;
653 else
654 length = this->bounds [dimension].length;
655
656 #ifdef MONO_BIG_ARRAYS
657 if (length > G_MAXINT32)
658 mono_raise_exception (mono_get_exception_overflow ());
659 #endif
660 return length;
661 }
662
663 static gint64
664 ves_icall_System_Array_GetLongLength (MonoArray *this, gint32 dimension)
665 {
666 gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
667
668 MONO_ARCH_SAVE_REGS;
669
670 if ((dimension < 0) || (dimension >= rank))
671 mono_raise_exception (mono_get_exception_index_out_of_range ());
672
673 if (this->bounds == NULL)
674 return this->max_length;
675
676 return this->bounds [dimension].length;
677 }
678
679 static gint32
680 ves_icall_System_Array_GetLowerBound (MonoArray *this, gint32 dimension)
681 {
682 gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
683
684 MONO_ARCH_SAVE_REGS;
685
686 if ((dimension < 0) || (dimension >= rank))
687 mono_raise_exception (mono_get_exception_index_out_of_range ());
688
689 if (this->bounds == NULL)
690 return 0;
691
692 return this->bounds [dimension].lower_bound;
693 }
694
695 static void
696 ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
697 {
698 int sz = mono_array_element_size (mono_object_class (arr));
699 memset (mono_array_addr_with_size (arr, sz, idx), 0, length * sz);
700 }
701
702 static gboolean
703 ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
704 {
705 int element_size;
706 void * dest_addr;
707 void * source_addr;
708 MonoClass *src_class;
709 MonoClass *dest_class;
710 int i;
711
712 MONO_ARCH_SAVE_REGS;
713
714 if (source->obj.vtable->klass->rank != dest->obj.vtable->klass->rank)
715 return FALSE;
716
717 if (source->bounds || dest->bounds)
718 return FALSE;
719
720 if ((dest_idx + length > mono_array_length (dest)) ||
721 (source_idx + length > mono_array_length (source)))
722 return FALSE;
723
724 src_class = source->obj.vtable->klass->element_class;
725 dest_class = dest->obj.vtable->klass->element_class;
726
727 /*
728 * Handle common cases.
729 */
730
731 /* Case1: object[] -> valuetype[] (ArrayList::ToArray) */
732 if (src_class == mono_defaults.object_class && dest_class->valuetype) {
733 int has_refs = dest_class->has_references;
734 for (i = source_idx; i < source_idx + length; ++i) {
735 MonoObject *elem = mono_array_get (source, MonoObject*, i);
736 if (elem && !mono_object_isinst (elem, dest_class))
737 return FALSE;
738 }
739
740 element_size = mono_array_element_size (dest->obj.vtable->klass);
741 memset (mono_array_addr_with_size (dest, element_size, dest_idx), 0, element_size * length);
742 for (i = 0; i < length; ++i) {
743 MonoObject *elem = mono_array_get (source, MonoObject*, source_idx + i);
744 void *addr = mono_array_addr_with_size (dest, element_size, dest_idx + i);
745 if (!elem)
746 continue;
747 if (has_refs)
748 mono_value_copy (addr, (char *)elem + sizeof (MonoObject), dest_class);
749 else
750 memcpy (addr, (char *)elem + sizeof (MonoObject), element_size);
751 }
752 return TRUE;
753 }
754
755 /* Check if we're copying a char[] <==> (u)short[] */
756 if (src_class != dest_class) {
757 if (dest_class->valuetype || dest_class->enumtype || src_class->valuetype || src_class->enumtype)
758 return FALSE;
759
760 if (mono_class_is_subclass_of (src_class, dest_class, FALSE))
761 ;
762 /* Case2: object[] -> reftype[] (ArrayList::ToArray) */
763 else if (mono_class_is_subclass_of (dest_class, src_class, FALSE))
764 for (i = source_idx; i < source_idx + length; ++i) {
765 MonoObject *elem = mono_array_get (source, MonoObject*, i);
766 if (elem && !mono_object_isinst (elem, dest_class))
767 return FALSE;
768 }
769 else
770 return FALSE;
771 }
772
773 if (dest_class->valuetype) {
774 element_size = mono_array_element_size (source->obj.vtable->klass);
775 source_addr = mono_array_addr_with_size (source, element_size, source_idx);
776 if (dest_class->has_references) {
777 mono_value_copy_array (dest, dest_idx, source_addr, length);
778 } else {
779 dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx);
780 memmove (dest_addr, source_addr, element_size * length);
781 }
782 } else {
783 mono_array_memcpy_refs (dest, dest_idx, source, source_idx, length);
784 }
785
786 return TRUE;
787 }
788
789 static void
790 ves_icall_System_Array_GetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
791 {
792 MonoClass *ac;
793 MonoArray *ao;
794 gint32 esize;
795 gpointer *ea;
796
797 MONO_ARCH_SAVE_REGS;
798
799 ao = (MonoArray *)this;
800 ac = (MonoClass *)ao->obj.vtable->klass;
801
802 esize = mono_array_element_size (ac);
803 ea = (gpointer*)((char*)ao->vector + (pos * esize));
804
805 memcpy (value, ea, esize);
806 }
807
808 static void
809 ves_icall_System_Array_SetGenericValueImpl (MonoObject *this, guint32 pos, gpointer value)
810 {
811 MonoClass *ac;
812 MonoArray *ao;
813 gint32 esize;
814 gpointer *ea;
815
816 MONO_ARCH_SAVE_REGS;
817
818 ao = (MonoArray *)this;
819 ac = (MonoClass *)ao->obj.vtable->klass;
820
821 esize = mono_array_element_size (ac);
822 ea = (gpointer*)((char*)ao->vector + (pos * esize));
823
824 memcpy (ea, value, esize);
825 }
826
827 static void
828 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
829 {
830 MonoClass *klass = array->obj.vtable->klass;
831 guint32 size = mono_array_element_size (klass);
832 MonoType *type = mono_type_get_underlying_type (&klass->element_class->byval_arg);
833 int align;
834 const char *field_data;
835
836 if (MONO_TYPE_IS_REFERENCE (type) ||
837 (type->type == MONO_TYPE_VALUETYPE &&
838 (!mono_type_get_class (type) ||
839 mono_type_get_class (type)->has_references))) {
840 MonoException *exc = mono_get_exception_argument("array",
841 "Cannot initialize array containing references");
842 mono_raise_exception (exc);
843 }
844
845 if (!(field_handle->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) {
846 MonoException *exc = mono_get_exception_argument("field_handle",
847 "Field doesn't have an RVA");
848 mono_raise_exception (exc);
849 }
850
851 size *= array->max_length;
852 field_data = mono_field_get_data (field_handle);
853
854 if (size > mono_type_size (field_handle->type, &align)) {
855 MonoException *exc = mono_get_exception_argument("field_handle",
856 "Field not large enough to fill array");
857 mono_raise_exception (exc);
858 }
859
860 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
861 #define SWAP(n) {\
862 guint ## n *data = (guint ## n *) mono_array_addr (array, char, 0); \
863 guint ## n *src = (guint ## n *) field_data; \
864 guint ## n *end = (guint ## n *)((char*)src + size); \
865 \
866 for (; src < end; data++, src++) { \
867 *data = read ## n (src); \
868 } \
869 }
870
871 /* printf ("Initialize array with elements of %s type\n", klass->element_class->name); */
872
873 switch (type->type) {
874 case MONO_TYPE_CHAR:
875 case MONO_TYPE_I2:
876 case MONO_TYPE_U2:
877 SWAP (16);
878 break;
879 case MONO_TYPE_I4:
880 case MONO_TYPE_U4:
881 case MONO_TYPE_R4:
882 SWAP (32);
883 break;
884 case MONO_TYPE_I8:
885 case MONO_TYPE_U8:
886 case MONO_TYPE_R8:
887 SWAP (64);
888 break;
889 default:
890 memcpy (mono_array_addr (array, char, 0), field_data, size);
891 break;
892 }
893 #else
894 memcpy (mono_array_addr (array, char, 0), field_data, size);
895 #ifdef ARM_FPU_FPA
896 if (klass->element_class->byval_arg.type == MONO_TYPE_R8) {
897 gint i;
898 double tmp;
899 double *data = (double*)mono_array_addr (array, double, 0);
900
901 for (i = 0; i < size; i++, data++) {
902 readr8 (data, &tmp);
903 *data = tmp;
904 }
905 }
906 #endif
907 #endif
908 }
909
910 static gint
911 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
912 {
913 MONO_ARCH_SAVE_REGS;
914
915 return offsetof (MonoString, chars);
916 }
917
918 static MonoObject *
919 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
920 {
921 MONO_ARCH_SAVE_REGS;
922
923 if ((obj == NULL) || (! (obj->vtable->klass->valuetype)))
924 return obj;
925 else
926 return mono_object_clone (obj);
927 }
928
929 static void
930 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
931 {
932 MonoClass *klass;
933
934 MONO_ARCH_SAVE_REGS;
935
936 MONO_CHECK_ARG_NULL (handle);
937
938 klass = mono_class_from_mono_type (handle);
939 MONO_CHECK_ARG (handle, klass);
940
941 /* This will call the type constructor */
942 mono_runtime_class_init (mono_class_vtable (mono_domain_get (), klass));
943 }
944
945 static void
946 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage *image)
947 {
948 MONO_ARCH_SAVE_REGS;
949
950 mono_image_check_for_module_cctor (image);
951 if (image->has_module_cctor) {
952 MonoClass *module_klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | 1);
953 mono_runtime_class_init (mono_class_vtable (mono_domain_get (), module_klass));
954 }
955 }
956
957 static MonoObject *
958 ves_icall_System_Object_MemberwiseClone (MonoObject *this)
959 {
960 MONO_ARCH_SAVE_REGS;
961
962 return mono_object_clone (this);
963 }
964
965 static gint32
966 ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this, MonoArray **fields)
967 {
968 MonoClass *klass;
969 MonoObject **values = NULL;
970 MonoObject *o;
971 int count = 0;
972 gint32 result = 0;
973 MonoClassField* field;
974 gpointer iter;
975
976 MONO_ARCH_SAVE_REGS;
977
978 klass = mono_object_class (this);
979
980 if (mono_class_num_fields (klass) == 0)
981 return mono_object_hash (this);
982
983 /*
984 * Compute the starting value of the hashcode for fields of primitive
985 * types, and return the remaining fields in an array to the managed side.
986 * This way, we can avoid costly reflection operations in managed code.
987 */
988 iter = NULL;
989 while ((field = mono_class_get_fields (klass, &iter))) {
990 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
991 continue;
992 if (mono_field_is_deleted (field))
993 continue;
994 /* FIXME: Add more types */
995 switch (field->type->type) {
996 case MONO_TYPE_I4:
997 result ^= *(gint32*)((guint8*)this + field->offset);
998 break;
999 case MONO_TYPE_STRING: {
1000 MonoString *s;
1001 s = *(MonoString**)((guint8*)this + field->offset);
1002 if (s != NULL)
1003 result ^= mono_string_hash (s);
1004 break;
1005 }
1006 default:
1007 if (!values)
1008 values = g_newa (MonoObject*, mono_class_num_fields (klass));
1009 o = mono_field_get_value_object (mono_object_domain (this), field, this);
1010 values [count++] = o;
1011 }
1012 }
1013
1014 if (values) {
1015 int i;
1016 *fields = mono_array_new (mono_domain_get (), mono_defaults.object_class, count);
1017 for (i = 0; i < count; ++i)
1018 mono_array_setref (*fields, i, values [i]);
1019 } else {
1020 *fields = NULL;
1021 }
1022 return result;
1023 }
1024
1025 static MonoBoolean
1026 ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that, MonoArray **fields)
1027 {
1028 MonoClass *klass;
1029 MonoObject **values = NULL;
1030 MonoObject *o;
1031 MonoClassField* field;
1032 gpointer iter;
1033 int count = 0;
1034
1035 MONO_ARCH_SAVE_REGS;
1036
1037 MONO_CHECK_ARG_NULL (that);
1038
1039 if (this->vtable != that->vtable)
1040 return FALSE;
1041
1042 klass = mono_object_class (this);
1043
1044 if (klass->enumtype && mono_class_enum_basetype (klass) && mono_class_enum_basetype (klass)->type == MONO_TYPE_I4)
1045 return (*(gint32*)((guint8*)this + sizeof (MonoObject)) == *(gint32*)((guint8*)that + sizeof (MonoObject)));
1046
1047 /*
1048 * Do the comparison for fields of primitive type and return a result if
1049 * possible. Otherwise, return the remaining fields in an array to the
1050 * managed side. This way, we can avoid costly reflection operations in
1051 * managed code.
1052 */
1053 *fields = NULL;
1054 iter = NULL;
1055 while ((field = mono_class_get_fields (klass, &iter))) {
1056 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1057 continue;
1058 if (mono_field_is_deleted (field))
1059 continue;
1060 /* FIXME: Add more types */
1061 switch (field->type->type) {
1062 case MONO_TYPE_U1:
1063 case MONO_TYPE_I1:
1064 case MONO_TYPE_BOOLEAN:
1065 if (*((guint8*)this + field->offset) != *((guint8*)that + field->offset))
1066 return FALSE;
1067 break;
1068 case MONO_TYPE_U2:
1069 case MONO_TYPE_I2:
1070 case MONO_TYPE_CHAR:
1071 if (*(gint16*)((guint8*)this + field->offset) != *(gint16*)((guint8*)that + field->offset))
1072 return FALSE;
1073 break;
1074 case MONO_TYPE_U4:
1075 case MONO_TYPE_I4:
1076 if (*(gint32*)((guint8*)this + field->offset) != *(gint32*)((guint8*)that + field->offset))
1077 return FALSE;
1078 break;
1079 case MONO_TYPE_U8:
1080 case MONO_TYPE_I8:
1081 if (*(gint64*)((guint8*)this + field->offset) != *(gint64*)((guint8*)that + field->offset))
1082 return FALSE;
1083 break;
1084 case MONO_TYPE_R4:
1085 if (*(float*)((guint8*)this + field->offset) != *(float*)((guint8*)that + field->offset))
1086 return FALSE;
1087 break;
1088 case MONO_TYPE_R8:
1089 if (*(double*)((guint8*)this + field->offset) != *(double*)((guint8*)that + field->offset))
1090 return FALSE;
1091 break;
1092
1093
1094 case MONO_TYPE_STRING: {
1095 MonoString *s1, *s2;
1096 guint32 s1len, s2len;
1097 s1 = *(MonoString**)((guint8*)this + field->offset);
1098 s2 = *(MonoString**)((guint8*)that + field->offset);
1099 if (s1 == s2)
1100 break;
1101 if ((s1 == NULL) || (s2 == NULL))
1102 return FALSE;
1103 s1len = mono_string_length (s1);
1104 s2len = mono_string_length (s2);
1105 if (s1len != s2len)
1106 return FALSE;
1107
1108 if (memcmp (mono_string_chars (s1), mono_string_chars (s2), s1len * sizeof (gunichar2)) != 0)
1109 return FALSE;
1110 break;
1111 }
1112 default:
1113 if (!values)
1114 values = g_newa (MonoObject*, mono_class_num_fields (klass) * 2);
1115 o = mono_field_get_value_object (mono_object_domain (this), field, this);
1116 values [count++] = o;
1117 o = mono_field_get_value_object (mono_object_domain (this), field, that);
1118 values [count++] = o;
1119 }
1120
1121 if (klass->enumtype)
1122 /* enums only have one non-static field */
1123 break;
1124 }
1125
1126 if (values) {
1127 int i;
1128 *fields = mono_array_new (mono_domain_get (), mono_defaults.object_class, count);
1129 for (i = 0; i < count; ++i)
1130 mono_array_setref (*fields, i, values [i]);
1131 return FALSE;
1132 } else {
1133 return TRUE;
1134 }
1135 }
1136
1137 static MonoReflectionType *
1138 ves_icall_System_Object_GetType (MonoObject *obj)
1139 {
1140 MONO_ARCH_SAVE_REGS;
1141
1142 if (obj->vtable->klass != mono_defaults.transparent_proxy_class)
1143 return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
1144 else
1145 return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
1146 }
1147
1148 static void
1149 mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
1150 {
1151 MONO_ARCH_SAVE_REGS;
1152
1153 mtype->type = &obj->vtable->klass->byval_arg;
1154 g_assert (mtype->type->type);
1155 }
1156
1157 static gint32
1158 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj)
1159 {
1160 MONO_ARCH_SAVE_REGS;
1161
1162 MONO_CHECK_ARG_NULL (obj);
1163
1164 return mono_image_create_token (mb->dynamic_image, obj, TRUE, TRUE);
1165 }
1166
1167 static gint32
1168 ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb,
1169 MonoReflectionMethod *method,
1170 MonoArray *opt_param_types)
1171 {
1172 MONO_ARCH_SAVE_REGS;
1173
1174 MONO_CHECK_ARG_NULL (method);
1175
1176 return mono_image_create_method_token (
1177 mb->dynamic_image, (MonoObject *) method, opt_param_types);
1178 }
1179
1180 static void
1181 ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
1182 {
1183 MONO_ARCH_SAVE_REGS;
1184
1185 mono_image_create_pefile (mb, file);
1186 }
1187
1188 static void
1189 ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
1190 {
1191 MONO_ARCH_SAVE_REGS;
1192
1193 mono_image_build_metadata (mb);
1194 }
1195
1196 static void
1197 ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token)
1198 {
1199 MONO_ARCH_SAVE_REGS;
1200
1201 mono_image_register_token (mb->dynamic_image, token, obj);
1202 }
1203
1204 static gboolean
1205 get_caller (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1206 {
1207 MonoMethod **dest = data;
1208
1209 /* skip unmanaged frames */
1210 if (!managed)
1211 return FALSE;
1212
1213 if (m == *dest) {
1214 *dest = NULL;
1215 return FALSE;
1216 }
1217 if (!(*dest)) {
1218 *dest = m;
1219 return TRUE;
1220 }
1221 return FALSE;
1222 }
1223
1224 static gboolean
1225 get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1226 {
1227 MonoMethod **dest = data;
1228
1229 /* skip unmanaged frames */
1230 if (!managed)
1231 return FALSE;
1232
1233 if (!(*dest)) {
1234 if (!strcmp (m->klass->name_space, "System.Reflection"))
1235 return FALSE;
1236 *dest = m;
1237 return TRUE;
1238 }
1239 return FALSE;
1240 }
1241
1242 static gboolean
1243 get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1244 {
1245 MonoMethod **dest = data;
1246
1247 /* skip unmanaged frames */
1248 if (!managed)
1249 return FALSE;
1250
1251 if (m->wrapper_type != MONO_WRAPPER_NONE)
1252 return FALSE;
1253
1254 if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection"))
1255 return FALSE;
1256
1257 if (m == *dest) {
1258 *dest = NULL;
1259 return FALSE;
1260 }
1261 if (!(*dest)) {
1262 *dest = m;
1263 return TRUE;
1264 }
1265 return FALSE;
1266 }
1267
1268 static MonoReflectionType *
1269 type_from_name (const char *str, MonoBoolean ignoreCase)
1270 {
1271 MonoType *type = NULL;
1272 MonoAssembly *assembly = NULL;
1273 MonoTypeNameParse info;
1274 char *temp_str = g_strdup (str);
1275 gboolean type_resolve = FALSE;
1276
1277 MONO_ARCH_SAVE_REGS;
1278
1279 /* mono_reflection_parse_type() mangles the string */
1280 if (!mono_reflection_parse_type (temp_str, &info)) {
1281 mono_reflection_free_type_info (&info);
1282 g_free (temp_str);
1283 return NULL;
1284 }
1285
1286 if (info.assembly.name) {
1287 assembly = mono_assembly_load (&info.assembly, NULL, NULL);
1288 } else {
1289 MonoMethod *m = mono_method_get_last_managed ();
1290 MonoMethod *dest = m;
1291
1292 mono_stack_walk_no_il (get_caller_no_reflection, &dest);
1293 if (!dest)
1294 dest = m;
1295
1296 /*
1297 * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus
1298 * causing ves_icall_System_Reflection_Assembly_GetCallingAssembly()
1299 * to crash. This only seems to happen in some strange remoting
1300 * scenarios and I was unable to figure out what's happening there.
1301 * Dec 10, 2005 - Martin.
1302 */
1303
1304 if (dest)
1305 assembly = dest->klass->image->assembly;
1306 else {
1307 g_warning (G_STRLOC);
1308 }
1309 }
1310
1311 if (assembly)
1312 type = mono_reflection_get_type (assembly->image, &info, ignoreCase, &type_resolve);
1313
1314 if (!info.assembly.name && !type) /* try mscorlib */
1315 type = mono_reflection_get_type (NULL, &info, ignoreCase, &type_resolve);
1316
1317 mono_reflection_free_type_info (&info);
1318 g_free (temp_str);
1319
1320 if (!type)
1321 return NULL;
1322
1323 return mono_type_get_object (mono_domain_get (), type);
1324 }
1325
1326 #ifdef UNUSED
1327 MonoReflectionType *
1328 mono_type_get (const char *str)
1329 {
1330 char *copy = g_strdup (str);
1331 MonoReflectionType *type = type_from_name (copy, FALSE);
1332
1333 g_free (copy);
1334 return type;
1335 }
1336 #endif
1337
1338 static MonoReflectionType*
1339 ves_icall_type_from_name (MonoString *name,
1340 MonoBoolean throwOnError,
1341 MonoBoolean ignoreCase)
1342 {
1343 char *str = mono_string_to_utf8 (name);
1344 MonoReflectionType *type;
1345
1346 type = type_from_name (str, ignoreCase);
1347 g_free (str);
1348 if (type == NULL){
1349 MonoException *e = NULL;
1350
1351 if (throwOnError)
1352 e = mono_get_exception_type_load (name, NULL);
1353
1354 mono_loader_clear_error ();
1355 if (e != NULL)
1356 mono_raise_exception (e);
1357 }
1358
1359 return type;
1360 }
1361
1362
1363 static MonoReflectionType*
1364 ves_icall_type_from_handle (MonoType *handle)
1365 {
1366 MonoDomain *domain = mono_domain_get ();
1367 MonoClass *klass = mono_class_from_mono_type (handle);
1368
1369 MONO_ARCH_SAVE_REGS;
1370
1371 mono_class_init (klass);
1372 return mono_type_get_object (domain, handle);
1373 }
1374
1375 static MonoBoolean
1376 ves_icall_System_Type_EqualsInternal (MonoReflectionType *type, MonoReflectionType *c)
1377 {
1378 MONO_ARCH_SAVE_REGS;
1379
1380 if (c && type->type && c->type)
1381 return mono_metadata_type_equal (type->type, c->type);
1382 else
1383 return (type == c) ? TRUE : FALSE;
1384 }
1385
1386 /* System.TypeCode */
1387 typedef enum {
1388 TYPECODE_EMPTY,
1389 TYPECODE_OBJECT,
1390 TYPECODE_DBNULL,
1391 TYPECODE_BOOLEAN,
1392 TYPECODE_CHAR,
1393 TYPECODE_SBYTE,
1394 TYPECODE_BYTE,
1395 TYPECODE_INT16,
1396 TYPECODE_UINT16,
1397 TYPECODE_INT32,
1398 TYPECODE_UINT32,
1399 TYPECODE_INT64,
1400 TYPECODE_UINT64,
1401 TYPECODE_SINGLE,
1402 TYPECODE_DOUBLE,
1403 TYPECODE_DECIMAL,
1404 TYPECODE_DATETIME,
1405 TYPECODE_STRING = 18
1406 } TypeCode;
1407
1408 static guint32
1409 ves_icall_type_GetTypeCodeInternal (MonoReflectionType *type)
1410 {
1411 int t = type->type->type;
1412
1413 MONO_ARCH_SAVE_REGS;
1414
1415 if (type->type->byref)
1416 return TYPECODE_OBJECT;
1417
1418 handle_enum:
1419 switch (t) {
1420 case MONO_TYPE_VOID:
1421 return TYPECODE_OBJECT;
1422 case MONO_TYPE_BOOLEAN:
1423 return TYPECODE_BOOLEAN;
1424 case MONO_TYPE_U1:
1425 return TYPECODE_BYTE;
1426 case MONO_TYPE_I1:
1427 return TYPECODE_SBYTE;
1428 case MONO_TYPE_U2:
1429 return TYPECODE_UINT16;
1430 case MONO_TYPE_I2:
1431 return TYPECODE_INT16;
1432 case MONO_TYPE_CHAR:
1433 return TYPECODE_CHAR;
1434 case MONO_TYPE_PTR:
1435 case MONO_TYPE_U:
1436 case MONO_TYPE_I:
1437 return TYPECODE_OBJECT;
1438 case MONO_TYPE_U4:
1439 return TYPECODE_UINT32;
1440 case MONO_TYPE_I4:
1441 return TYPECODE_INT32;
1442 case MONO_TYPE_U8:
1443 return TYPECODE_UINT64;
1444 case MONO_TYPE_I8:
1445 return TYPECODE_INT64;
1446 case MONO_TYPE_R4:
1447 return TYPECODE_SINGLE;
1448 case MONO_TYPE_R8:
1449 return TYPECODE_DOUBLE;
1450 case MONO_TYPE_VALUETYPE:
1451 if (type->type->data.klass->enumtype) {
1452 t = mono_class_enum_basetype (type->type->data.klass)->type;
1453 goto handle_enum;
1454 } else {
1455 MonoClass *k = type->type->data.klass;
1456 if (strcmp (k->name_space, "System") == 0) {
1457 if (strcmp (k->name, "Decimal") == 0)
1458 return TYPECODE_DECIMAL;
1459 else if (strcmp (k->name, "DateTime") == 0)
1460 return TYPECODE_DATETIME;
1461 }
1462 }
1463 return TYPECODE_OBJECT;
1464 case MONO_TYPE_STRING:
1465 return TYPECODE_STRING;
1466 case MONO_TYPE_SZARRAY:
1467 case MONO_TYPE_ARRAY:
1468 case MONO_TYPE_OBJECT:
1469 case MONO_TYPE_VAR:
1470 case MONO_TYPE_MVAR:
1471 case MONO_TYPE_TYPEDBYREF:
1472 return TYPECODE_OBJECT;
1473 case MONO_TYPE_CLASS:
1474 {
1475 MonoClass *k = type->type->data.klass;
1476 if (strcmp (k->name_space, "System") == 0) {
1477 if (strcmp (k->name, "DBNull") == 0)
1478 return TYPECODE_DBNULL;
1479 }
1480 }
1481 return TYPECODE_OBJECT;
1482 case MONO_TYPE_GENERICINST:
1483 return TYPECODE_OBJECT;
1484 default:
1485 g_error ("type 0x%02x not handled in GetTypeCode()", t);
1486 }
1487 return 0;
1488 }
1489
1490 static guint32
1491 ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces)
1492 {
1493 MonoDomain *domain;
1494 MonoClass *klass;
1495 MonoClass *klassc;
1496
1497 MONO_ARCH_SAVE_REGS;
1498
1499 g_assert (type != NULL);
1500
1501 domain = ((MonoObject *)type)->vtable->domain;
1502
1503 if (!c) /* FIXME: dont know what do do here */
1504 return 0;
1505
1506 klass = mono_class_from_mono_type (type->type);
1507 klassc = mono_class_from_mono_type (c->type);
1508
1509 if (type->type->byref)
1510 return klassc == mono_defaults.object_class;
1511
1512 return mono_class_is_subclass_of (klass, klassc, check_interfaces);
1513 }
1514
1515 static guint32
1516 ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
1517 {
1518 MonoDomain *domain;
1519 MonoClass *klass;
1520 MonoClass *klassc;
1521
1522 MONO_ARCH_SAVE_REGS;
1523
1524 g_assert (type != NULL);
1525
1526 domain = ((MonoObject *)type)->vtable->domain;
1527
1528 klass = mono_class_from_mono_type (type->type);
1529 klassc = mono_class_from_mono_type (c->type);
1530
1531 if (type->type->byref && !c->type->byref)
1532 return FALSE;
1533
1534 return mono_class_is_assignable_from (klass, klassc);
1535 }
1536
1537 static guint32
1538 ves_icall_type_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
1539 {
1540 MonoClass *klass = mono_class_from_mono_type (type->type);
1541 return mono_object_isinst (obj, klass) != NULL;
1542 }
1543
1544 static guint32
1545 ves_icall_get_attributes (MonoReflectionType *type)
1546 {
1547 MonoClass *klass = mono_class_from_mono_type (type->type);
1548
1549 MONO_ARCH_SAVE_REGS;
1550
1551 return klass->flags;
1552 }
1553
1554 static MonoReflectionMarshal*
1555 ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField *field)
1556 {
1557 MonoClass *klass = field->field->parent;
1558 MonoMarshalType *info;
1559 int i;
1560
1561 if (klass->generic_container ||
1562 (klass->generic_class && klass->generic_class->context.class_inst->is_open))
1563 return NULL;
1564
1565 info = mono_marshal_load_type_info (klass);
1566
1567 for (i = 0; i < info->num_fields; ++i) {
1568 if (info->fields [i].field == field->field) {
1569 if (!info->fields [i].mspec)
1570 return NULL;
1571 else
1572 return mono_reflection_marshal_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec);
1573 }
1574 }
1575
1576 return NULL;
1577 }
1578
1579 static MonoReflectionField*
1580 ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoClass *klass)
1581 {
1582 g_assert (handle);
1583
1584 if (!klass)
1585 klass = handle->parent;
1586
1587 /* FIXME: check that handle is a field of klass or of a parent: return null
1588 * and throw the exception in managed code.
1589 */
1590 return mono_field_get_object (mono_domain_get (), klass, handle);
1591 }
1592
1593 static MonoReflectionField*
1594 ves_icall_System_Reflection_FieldInfo_internal_from_handle (MonoClassField *handle)
1595 {
1596 MONO_ARCH_SAVE_REGS;
1597
1598 g_assert (handle);
1599
1600 return mono_field_get_object (mono_domain_get (), handle->parent, handle);
1601 }
1602
1603 static MonoArray*
1604 ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
1605 {
1606 MonoType *type = field->field->type;
1607
1608 return type_array_from_modifiers (field->field->parent->image, type, optional);
1609 }
1610
1611 static void
1612 ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
1613 {
1614 MonoDomain *domain = mono_domain_get ();
1615 MonoMethodSignature* sig;
1616 MONO_ARCH_SAVE_REGS;
1617
1618 sig = mono_method_signature (method);
1619 if (!sig) {
1620 g_assert (mono_loader_get_last_error ());
1621 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
1622 }
1623
1624 info->parent = mono_type_get_object (domain, &method->klass->byval_arg);
1625 info->ret = mono_type_get_object (domain, sig->ret);
1626 info->attrs = method->flags;
1627 info->implattrs = method->iflags;
1628 if (sig->call_convention == MONO_CALL_DEFAULT)
1629 info->callconv = sig->sentinelpos >= 0 ? 2 : 1;
1630 else {
1631 if (sig->call_convention == MONO_CALL_VARARG || sig->sentinelpos >= 0)
1632 info->callconv = 2;
1633 else
1634 info->callconv = 1;
1635 }
1636 info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
1637 }
1638
1639 static MonoArray*
1640 ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
1641 {
1642 MonoDomain *domain = mono_domain_get ();
1643
1644 return mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL);
1645 }
1646
1647 static MonoReflectionMarshal*
1648 ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
1649 {
1650 MonoDomain *domain = mono_domain_get ();
1651 MonoReflectionMarshal* res = NULL;
1652 MonoMarshalSpec **mspecs;
1653 int i;
1654
1655 mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
1656 mono_method_get_marshal_info (method, mspecs);
1657
1658 if (mspecs [0])
1659 res = mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [0]);
1660
1661 for (i = mono_method_signature (method)->param_count; i >= 0; i--)
1662 if (mspecs [i])
1663 mono_metadata_free_marshal_spec (mspecs [i]);
1664 g_free (mspecs);
1665
1666 return res;
1667 }
1668
1669 static gint32
1670 ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
1671 {
1672 return field->field->offset - sizeof (MonoObject);
1673 }
1674
1675 static MonoReflectionType*
1676 ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
1677 {
1678 MonoClass *parent;
1679 MONO_ARCH_SAVE_REGS;
1680
1681 parent = declaring? field->field->parent: field->klass;
1682
1683 return mono_type_get_object (mono_object_domain (field), &parent->byval_arg);
1684 }
1685
1686 static MonoObject *
1687 ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
1688 {
1689 MonoObject *o;
1690 MonoClassField *cf = field->field;
1691 MonoClass *klass;
1692 MonoVTable *vtable;
1693 MonoType *t;
1694 MonoDomain *domain = mono_object_domain (field);
1695 gchar *v;
1696 gboolean is_static = FALSE;
1697 gboolean is_ref = FALSE;
1698
1699 MONO_ARCH_SAVE_REGS;
1700
1701 if (field->klass->image->assembly->ref_only)
1702 mono_raise_exception (mono_get_exception_invalid_operation (
1703 "It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods."));
1704
1705 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
1706 mono_security_core_clr_ensure_reflection_access_field (cf);
1707
1708 mono_class_init (field->klass);
1709
1710 if (cf->type->attrs & FIELD_ATTRIBUTE_STATIC)
1711 is_static = TRUE;
1712
1713 if (obj && !is_static) {
1714 /* Check that the field belongs to the object */
1715 gboolean found = FALSE;
1716 MonoClass *k;
1717
1718 for (k = obj->vtable->klass; k; k = k->parent) {
1719 if (k == cf->parent) {
1720 found = TRUE;
1721 break;
1722 }
1723 }
1724
1725 if (!found) {
1726 char *msg = g_strdup_printf ("Field '%s' defined on type '%s' is not a field on the target object which is of type '%s'.", mono_field_get_name (cf), cf->parent->name, obj->vtable->klass->name);
1727 MonoException *ex = mono_get_exception_argument (NULL, msg);
1728 g_free (msg);
1729 mono_raise_exception (ex);
1730 }
1731 }
1732
1733 t = mono_type_get_underlying_type (cf->type);
1734 switch (t->type) {
1735 case MONO_TYPE_STRING:
1736 case MONO_TYPE_OBJECT:
1737 case MONO_TYPE_CLASS:
1738 case MONO_TYPE_ARRAY:
1739 case MONO_TYPE_SZARRAY:
1740 is_ref = TRUE;
1741 break;
1742 case MONO_TYPE_U1:
1743 case MONO_TYPE_I1:
1744 case MONO_TYPE_BOOLEAN:
1745 case MONO_TYPE_U2:
1746 case MONO_TYPE_I2:
1747 case MONO_TYPE_CHAR:
1748 case MONO_TYPE_U:
1749 case MONO_TYPE_I:
1750 case MONO_TYPE_U4:
1751 case MONO_TYPE_I4:
1752 case MONO_TYPE_R4:
1753 case MONO_TYPE_U8:
1754 case MONO_TYPE_I8:
1755 case MONO_TYPE_R8:
1756 case MONO_TYPE_VALUETYPE:
1757 is_ref = t->byref;
1758 break;
1759 case MONO_TYPE_GENERICINST:
1760 if (mono_type_generic_inst_is_valuetype (t)) {
1761 is_ref = t->byref;
1762 } else {
1763 is_ref = TRUE;
1764 }
1765 break;
1766 default:
1767 g_error ("type 0x%x not handled in "
1768 "ves_icall_Monofield_GetValue", t->type);
1769 return NULL;
1770 }
1771
1772 vtable = NULL;
1773 if (is_static) {
1774 vtable = mono_class_vtable (domain, cf->parent);
1775 if (!vtable->initialized && !(cf->type->attrs & FIELD_ATTRIBUTE_LITERAL))
1776 mono_runtime_class_init (vtable);
1777 }
1778
1779 if (is_ref) {
1780 if (is_static) {
1781 mono_field_static_get_value (vtable, cf, &o);
1782 } else {
1783 mono_field_get_value (obj, cf, &o);
1784 }
1785 return o;
1786 }
1787
1788 if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) {
1789 MonoClass *nklass = mono_class_from_mono_type (cf->type);
1790 guint8 *buf;
1791
1792 /* Convert the Nullable structure into a boxed vtype */
1793 if (is_static)
1794 buf = (guint8*)vtable->data + cf->offset;
1795 else
1796 buf = (guint8*)obj + cf->offset;
1797
1798 return mono_nullable_box (buf, nklass);
1799 }
1800
1801 /* boxed value type */
1802 klass = mono_class_from_mono_type (cf->type);
1803 o = mono_object_new (domain, klass);
1804 v = ((gchar *) o) + sizeof (MonoObject);
1805 if (is_static) {
1806 mono_field_static_get_value (vtable, cf, v);
1807 } else {
1808 mono_field_get_value (obj, cf, v);
1809 }
1810
1811 return o;
1812 }
1813
1814 static void
1815 ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *obj, MonoObject *value)
1816 {
1817 MonoClassField *cf = field->field;
1818 gchar *v;
1819
1820 MONO_ARCH_SAVE_REGS;
1821
1822 if (field->klass->image->assembly->ref_only)
1823 mono_raise_exception (mono_get_exception_invalid_operation (
1824 "It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods."));
1825
1826 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
1827 mono_security_core_clr_ensure_reflection_access_field (cf);
1828
1829 v = (gchar *) value;
1830 if (!cf->type->byref) {
1831 switch (cf->type->type) {
1832 case MONO_TYPE_U1:
1833 case MONO_TYPE_I1:
1834 case MONO_TYPE_BOOLEAN:
1835 case MONO_TYPE_U2:
1836 case MONO_TYPE_I2:
1837 case MONO_TYPE_CHAR:
1838 case MONO_TYPE_U:
1839 case MONO_TYPE_I:
1840 case MONO_TYPE_U4:
1841 case MONO_TYPE_I4:
1842 case MONO_TYPE_R4:
1843 case MONO_TYPE_U8:
1844 case MONO_TYPE_I8:
1845 case MONO_TYPE_R8:
1846 case MONO_TYPE_VALUETYPE:
1847 if (v != NULL)
1848 v += sizeof (MonoObject);
1849 break;
1850 case MONO_TYPE_STRING:
1851 case MONO_TYPE_OBJECT:
1852 case MONO_TYPE_CLASS:
1853 case MONO_TYPE_ARRAY:
1854 case MONO_TYPE_SZARRAY:
1855 /* Do nothing */
1856 break;
1857 case MONO_TYPE_GENERICINST: {
1858 MonoGenericClass *gclass = cf->type->data.generic_class;
1859 g_assert (!gclass->context.class_inst->is_open);
1860
1861 if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) {
1862 MonoClass *nklass = mono_class_from_mono_type (cf->type);
1863 MonoObject *nullable;
1864
1865 /*
1866 * Convert the boxed vtype into a Nullable structure.
1867 * This is complicated by the fact that Nullables have
1868 * a variable structure.
1869 */
1870 nullable = mono_object_new (mono_domain_get (), nklass);
1871
1872 mono_nullable_init (mono_object_unbox (nullable), value, nklass);
1873
1874 v = mono_object_unbox (nullable);
1875 }
1876 else
1877 if (gclass->container_class->valuetype && (v != NULL))
1878 v += sizeof (MonoObject);
1879 break;
1880 }
1881 default:
1882 g_error ("type 0x%x not handled in "
1883 "ves_icall_FieldInfo_SetValueInternal", cf->type->type);
1884 return;
1885 }
1886 }
1887
1888 if (cf->type->attrs & FIELD_ATTRIBUTE_STATIC) {
1889 MonoVTable *vtable = mono_class_vtable (mono_object_domain (field), cf->parent);
1890 if (!vtable->initialized)
1891 mono_runtime_class_init (vtable);
1892 mono_field_static_set_value (vtable, cf, v);
1893 } else {
1894 mono_field_set_value (obj, cf, v);
1895 }
1896 }
1897
1898 static MonoObject *
1899 ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *this)
1900 {
1901 MonoObject *o = NULL;
1902 MonoClassField *field = this->field;
1903 MonoClass *klass;
1904 MonoDomain *domain = mono_object_domain (this);
1905 gchar *v;
1906 MonoTypeEnum def_type;
1907 const char *def_value;
1908
1909 MONO_ARCH_SAVE_REGS;
1910
1911 mono_class_init (field->parent);
1912
1913 if (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT))
1914 mono_raise_exception (mono_get_exception_invalid_operation (NULL));
1915
1916 if (field->parent->image->dynamic) {
1917 /* FIXME: */
1918 g_assert_not_reached ();
1919 }
1920
1921 def_value = mono_class_get_field_default_value (field, &def_type);
1922
1923 switch (def_type) {
1924 case MONO_TYPE_U1:
1925 case MONO_TYPE_I1:
1926 case MONO_TYPE_BOOLEAN:
1927 case MONO_TYPE_U2:
1928 case MONO_TYPE_I2:
1929 case MONO_TYPE_CHAR:
1930 case MONO_TYPE_U:
1931 case MONO_TYPE_I:
1932 case MONO_TYPE_U4:
1933 case MONO_TYPE_I4:
1934 case MONO_TYPE_R4:
1935 case MONO_TYPE_U8:
1936 case MONO_TYPE_I8:
1937 case MONO_TYPE_R8: {
1938 MonoType *t;
1939
1940 /* boxed value type */
1941 t = g_new0 (MonoType, 1);
1942 t->type = def_type;
1943 klass = mono_class_from_mono_type (t);
1944 g_free (t);
1945 o = mono_object_new (domain, klass);
1946 v = ((gchar *) o) + sizeof (MonoObject);
1947 mono_get_constant_value_from_blob (domain, def_type, def_value, v);
1948 break;
1949 }
1950 case MONO_TYPE_STRING:
1951 case MONO_TYPE_CLASS:
1952 mono_get_constant_value_from_blob (domain, def_type, def_value, &o);
1953 break;
1954 default:
1955 g_assert_not_reached ();
1956 }
1957
1958 return o;
1959 }
1960
1961 static MonoReflectionType*
1962 ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod *rmethod)
1963 {
1964 MonoMethod *method = rmethod->method.method;
1965
1966 return mono_type_get_object (mono_object_domain (rmethod), &method->klass->byval_arg);
1967 }
1968
1969 /* From MonoProperty.cs */
1970 typedef enum {
1971 PInfo_Attributes = 1,
1972 PInfo_GetMethod = 1 << 1,
1973 PInfo_SetMethod = 1 << 2,
1974 PInfo_ReflectedType = 1 << 3,
1975 PInfo_DeclaringType = 1 << 4,
1976 PInfo_Name = 1 << 5
1977 } PInfo;
1978
1979 static void
1980 ves_icall_get_property_info (MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
1981 {
1982 MonoDomain *domain = mono_object_domain (property);
1983
1984 MONO_ARCH_SAVE_REGS;
1985
1986 if ((req_info & PInfo_ReflectedType) != 0)
1987 MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg));
1988 else if ((req_info & PInfo_DeclaringType) != 0)
1989 MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->property->parent->byval_arg));
1990
1991 if ((req_info & PInfo_Name) != 0)
1992 MONO_STRUCT_SETREF (info, name, mono_string_new (domain, property->property->name));
1993
1994 if ((req_info & PInfo_Attributes) != 0)
1995 info->attrs = property->property->attrs;
1996
1997 if ((req_info & PInfo_GetMethod) != 0)
1998 MONO_STRUCT_SETREF (info, get, property->property->get ?
1999 mono_method_get_object (domain, property->property->get, property->klass): NULL);
2000
2001 if ((req_info & PInfo_SetMethod) != 0)
2002 MONO_STRUCT_SETREF (info, set, property->property->set ?
2003 mono_method_get_object (domain, property->property->set, property->klass): NULL);
2004 /*
2005 * There may be other methods defined for properties, though, it seems they are not exposed
2006 * in the reflection API
2007 */
2008 }
2009
2010 static void
2011 ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
2012 {
2013 MonoDomain *domain = mono_object_domain (event);
2014
2015 MONO_ARCH_SAVE_REGS;
2016
2017 info->reflected_type = mono_type_get_object (domain, &event->klass->byval_arg);
2018 info->declaring_type = mono_type_get_object (domain, &event->event->parent->byval_arg);
2019
2020 info->name = mono_string_new (domain, event->event->name);
2021 info->attrs = event->event->attrs;
2022 info->add_method = event->event->add ? mono_method_get_object (domain, event->event->add, NULL): NULL;
2023 info->remove_method = event->event->remove ? mono_method_get_object (domain, event->event->remove, NULL): NULL;
2024 info->raise_method = event->event->raise ? mono_method_get_object (domain, event->event->raise, NULL): NULL;
2025
2026 if (event->event->other) {
2027 int i, n = 0;
2028 while (event->event->other [n])
2029 n++;
2030 info->other_methods = mono_array_new (domain, mono_defaults.method_info_class, n);
2031
2032 for (i = 0; i < n; i++)
2033 mono_array_setref (info->other_methods, i, mono_method_get_object (domain, event->event->other [i], NULL));
2034 }
2035 }
2036
2037 static MonoArray*
2038 ves_icall_Type_GetInterfaces (MonoReflectionType* type)
2039 {
2040 MonoDomain *domain = mono_object_domain (type);
2041 MonoArray *intf;
2042 GPtrArray *ifaces = NULL;
2043 int i;
2044 MonoClass *class = mono_class_from_mono_type (type->type);
2045 MonoClass *parent;
2046 MonoBitSet *slots;
2047 MonoGenericContext *context = NULL;
2048
2049 MONO_ARCH_SAVE_REGS;
2050
2051 if (class->generic_class && class->generic_class->context.class_inst->is_open) {
2052 context = mono_class_get_context (class);
2053 class = class->generic_class->container_class;
2054 }
2055
2056 mono_class_setup_vtable (class);
2057
2058 slots = mono_bitset_new (class->max_interface_id + 1, 0);
2059
2060 for (parent = class; parent; parent = parent->parent) {
2061 GPtrArray *tmp_ifaces = mono_class_get_implemented_interfaces (parent);
2062 if (tmp_ifaces) {
2063 for (i = 0; i < tmp_ifaces->len; ++i) {
2064 MonoClass *ic = g_ptr_array_index (tmp_ifaces, i);
2065
2066 if (mono_bitset_test (slots, ic->interface_id))
2067 continue;
2068
2069 mono_bitset_set (slots, ic->interface_id);
2070 if (ifaces == NULL)
2071 ifaces = g_ptr_array_new ();
2072 g_ptr_array_add (ifaces, ic);
2073 }
2074 g_ptr_array_free (tmp_ifaces, TRUE);
2075 }
2076 }
2077 mono_bitset_free (slots);
2078
2079 if (!ifaces)
2080 return mono_array_new_cached (domain, mono_defaults.monotype_class, 0);
2081
2082 intf = mono_array_new_cached (domain, mono_defaults.monotype_class, ifaces->len);
2083 for (i = 0; i < ifaces->len; ++i) {
2084 MonoClass *ic = g_ptr_array_index (ifaces, i);
2085 MonoType *ret = &ic->byval_arg, *inflated = NULL;
2086 if (context && ic->generic_class && ic->generic_class->context.class_inst->is_open)
2087 inflated = ret = mono_class_inflate_generic_type (ret, context);
2088
2089 mono_array_setref (intf, i, mono_type_get_object (domain, ret));
2090 if (inflated)
2091 mono_metadata_free_type (inflated);
2092 }
2093 g_ptr_array_free (ifaces, TRUE);
2094
2095 return intf;
2096 }
2097
2098 static void
2099 ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
2100 {
2101 MonoClass *class = mono_class_from_mono_type (type->type);
2102 MonoClass *iclass = mono_class_from_mono_type (iface->type);
2103 MonoReflectionMethod *member;
2104 MonoMethod* method;
2105 gpointer iter;
2106 int i = 0, len, ioffset;
2107 MonoDomain *domain;
2108
2109 MONO_ARCH_SAVE_REGS;
2110
2111 mono_class_setup_vtable (class);
2112
2113 /* type doesn't implement iface: the exception is thrown in managed code */
2114 if (! MONO_CLASS_IMPLEMENTS_INTERFACE (class, iclass->interface_id))
2115 return;
2116
2117 len = mono_class_num_methods (iclass);
2118 ioffset = mono_class_interface_offset (class, iclass);
2119 domain = mono_object_domain (type);
2120 *targets = mono_array_new (domain, mono_defaults.method_info_class, len);
2121 *methods = mono_array_new (domain, mono_defaults.method_info_class, len);
2122 iter = NULL;
2123 iter = NULL;
2124 while ((method = mono_class_get_methods (iclass, &iter))) {
2125 member = mono_method_get_object (domain, method, iclass);
2126 mono_array_setref (*methods, i, member);
2127 member = mono_method_get_object (domain, class->vtable [i + ioffset], class);
2128 mono_array_setref (*targets, i, member);
2129
2130 i ++;
2131 }
2132 }
2133
2134 static void
2135 ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
2136 {
2137 MonoClass *klass = mono_class_from_mono_type (type->type);
2138
2139 if (klass->image->dynamic) {
2140 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)type;
2141 *packing = tb->packing_size;
2142 *size = tb->class_size;
2143 } else {
2144 mono_metadata_packing_from_typedef (klass->image, klass->type_token, packing, size);
2145 }
2146 }
2147
2148 static MonoReflectionType*
2149 ves_icall_MonoType_GetElementType (MonoReflectionType *type)
2150 {
2151 MonoClass *class;
2152
2153 MONO_ARCH_SAVE_REGS;
2154
2155 if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY)
2156 return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg);
2157
2158 class = mono_class_from_mono_type (type->type);
2159
2160 // GetElementType should only return a type for:
2161 // Array Pointer PassedByRef
2162 if (type->type->byref)
2163 return mono_type_get_object (mono_object_domain (type), &class->byval_arg);
2164 else if (class->element_class && MONO_CLASS_IS_ARRAY (class))
2165 return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
2166 else if (class->element_class && type->type->type == MONO_TYPE_PTR)
2167 return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg);
2168 else
2169 return NULL;
2170 }
2171
2172 static MonoReflectionType*
2173 ves_icall_get_type_parent (MonoReflectionType *type)
2174 {
2175 MonoClass *class = mono_class_from_mono_type (type->type);
2176
2177 MONO_ARCH_SAVE_REGS;
2178
2179 return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL;
2180 }
2181
2182 static MonoBoolean
2183 ves_icall_type_ispointer (MonoReflectionType *type)
2184 {
2185 MONO_ARCH_SAVE_REGS;
2186
2187 return type->type->type == MONO_TYPE_PTR;
2188 }
2189
2190 static MonoBoolean
2191 ves_icall_type_isprimitive (MonoReflectionType *type)
2192 {
2193 MONO_ARCH_SAVE_REGS;
2194
2195 return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
2196 }
2197
2198 static MonoBoolean
2199 ves_icall_type_isbyref (MonoReflectionType *type)
2200 {
2201 MONO_ARCH_SAVE_REGS;
2202
2203 return type->type->byref;
2204 }
2205
2206 static MonoBoolean
2207 ves_icall_type_iscomobject (MonoReflectionType *type)
2208 {
2209 MonoClass *klass = mono_class_from_mono_type (type->type);
2210 MONO_ARCH_SAVE_REGS;
2211
2212 return (klass && klass->is_com_object);
2213 }
2214
2215 static MonoReflectionModule*
2216 ves_icall_MonoType_get_Module (MonoReflectionType *type)
2217 {
2218 MonoClass *class = mono_class_from_mono_type (type->type);
2219
2220 MONO_ARCH_SAVE_REGS;
2221
2222 return mono_module_get_object (mono_object_domain (type), class->image);
2223 }
2224
2225 static MonoReflectionAssembly*
2226 ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
2227 {
2228 MonoDomain *domain = mono_domain_get ();
2229 MonoClass *class = mono_class_from_mono_type (type->type);
2230
2231 MONO_ARCH_SAVE_REGS;
2232
2233 return mono_assembly_get_object (domain, class->image->assembly);
2234 }
2235
2236 static MonoReflectionType*
2237 ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
2238 {
2239 MonoDomain *domain = mono_domain_get ();
2240 MonoClass *class;
2241
2242 MONO_ARCH_SAVE_REGS;
2243
2244 if (type->type->byref)
2245 return NULL;
2246 if (type->type->type == MONO_TYPE_VAR)
2247 class = mono_type_get_generic_param_owner (type->type)->owner.klass;
2248 else if (type->type->type == MONO_TYPE_MVAR)
2249 class = mono_type_get_generic_param_owner (type->type)->owner.method->klass;
2250 else
2251 class = mono_class_from_mono_type (type->type)->nested_in;
2252
2253 return class ? mono_type_get_object (domain, &class->byval_arg) : NULL;
2254 }
2255
2256 static MonoReflectionType*
2257 ves_icall_MonoType_get_UnderlyingSystemType (MonoReflectionType *type)
2258 {
2259 MonoDomain *domain = mono_domain_get ();
2260 MonoClass *class = mono_class_from_mono_type (type->type);
2261
2262 MONO_ARCH_SAVE_REGS;
2263
2264 if (class->enumtype && mono_class_enum_basetype (class)) /* types that are modified typebuilders may not have enum_basetype set */
2265 return mono_type_get_object (domain, mono_class_enum_basetype (class));
2266 else if (class->element_class)
2267 return mono_type_get_object (domain, &class->element_class->byval_arg);
2268 else
2269 return NULL;
2270 }
2271
2272 static MonoString*
2273 ves_icall_MonoType_get_Name (MonoReflectionType *type)
2274 {
2275 MonoDomain *domain = mono_domain_get ();
2276 MonoClass *class = mono_class_from_mono_type (type->type);
2277
2278 MONO_ARCH_SAVE_REGS;
2279
2280 if (type->type->byref) {
2281 char *n = g_strdup_printf ("%s&", class->name);
2282 MonoString *res = mono_string_new (domain, n);
2283
2284 g_free (n);
2285
2286 return res;
2287 } else {
2288 return mono_string_new (domain, class->name);
2289 }
2290 }
2291
2292 static MonoString*
2293 ves_icall_MonoType_get_Namespace (MonoReflectionType *type)
2294 {
2295 MonoDomain *domain = mono_domain_get ();
2296 MonoClass *class = mono_class_from_mono_type (type->type);
2297
2298 MONO_ARCH_SAVE_REGS;
2299
2300 while (class->nested_in)
2301 class = class->nested_in;
2302
2303 if (class->name_space [0] == '\0')
2304 return NULL;
2305 else
2306 return mono_string_new (domain, class->name_space);
2307 }
2308
2309 static gint32
2310 ves_icall_MonoType_GetArrayRank (MonoReflectionType *type)
2311 {
2312 MonoClass *class = mono_class_from_mono_type (type->type);
2313
2314 MONO_ARCH_SAVE_REGS;
2315
2316 return class->rank;
2317 }
2318
2319 static MonoArray*
2320 ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type)
2321 {
2322 MonoArray *res;
2323 MonoClass *klass, *pklass;
2324 MonoDomain *domain = mono_object_domain (type);
2325 MonoVTable *array_vtable = mono_class_vtable (domain, mono_array_class_get_cached (mono_defaults.systemtype_class, 1));
2326 int i;
2327 MONO_ARCH_SAVE_REGS;
2328
2329 klass = mono_class_from_mono_type (type->type);
2330
2331 if (klass->generic_container) {
2332 MonoGenericContainer *container = klass->generic_container;
2333 res = mono_array_new_specific (array_vtable, container->type_argc);
2334 for (i = 0; i < container->type_argc; ++i) {
2335 pklass = mono_class_from_generic_parameter (mono_generic_container_get_param (container, i), klass->image, FALSE);
2336 mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg));
2337 }
2338 } else if (klass->generic_class) {
2339 MonoGenericInst *inst = klass->generic_class->context.class_inst;
2340 res = mono_array_new_specific (array_vtable, inst->type_argc);
2341 for (i = 0; i < inst->type_argc; ++i)
2342 mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
2343 } else {
2344 res = mono_array_new_specific (array_vtable, 0);
2345 }
2346 return res;
2347 }
2348
2349 static gboolean
2350 ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
2351 {
2352 MonoClass *klass;
2353 MONO_ARCH_SAVE_REGS;
2354
2355 if (!IS_MONOTYPE (type))
2356 return FALSE;
2357
2358 if (type->type->byref)
2359 return FALSE;
2360
2361 klass = mono_class_from_mono_type (type->type);
2362
2363 return klass->generic_container != NULL;
2364 }
2365
2366 static MonoReflectionType*
2367 ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
2368 {
2369 MonoClass *klass;
2370 MONO_ARCH_SAVE_REGS;
2371
2372 if (type->type->byref)
2373 return NULL;
2374
2375 klass = mono_class_from_mono_type (type->type);
2376 if (klass->generic_container) {
2377 return type; /* check this one */
2378 }
2379 if (klass->generic_class) {
2380 MonoClass *generic_class = klass->generic_class->container_class;
2381
2382 if (generic_class->wastypebuilder && generic_class->reflection_info)
2383 return generic_class->reflection_info;
2384 else
2385 return mono_type_get_object (mono_object_domain (type), &generic_class->byval_arg);
2386 }
2387 return NULL;
2388 }
2389
2390 static MonoReflectionType*
2391 ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
2392 {
2393 MonoType *geninst, **types;
2394 int i, count;
2395
2396 MONO_ARCH_SAVE_REGS;
2397
2398 count = mono_array_length (type_array);
2399 types = g_new0 (MonoType *, count);
2400
2401 for (i = 0; i < count; i++) {
2402 MonoReflectionType *t = mono_array_get (type_array, gpointer, i);
2403 types [i] = t->type;
2404 }
2405
2406 geninst = mono_reflection_bind_generic_parameters (type, count, types);
2407 g_free (types);
2408 if (!geninst)
2409 return NULL;
2410
2411 return mono_type_get_object (mono_object_domain (type), geninst);
2412 }
2413
2414 static gboolean
2415 ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type)
2416 {
2417 MonoClass *klass;
2418 MONO_ARCH_SAVE_REGS;
2419
2420 if (type->type->byref)
2421 return FALSE;
2422
2423 klass = mono_class_from_mono_type (type->type);
2424 return klass->generic_class != NULL;
2425 }
2426
2427 static gboolean
2428 ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
2429 {
2430 MonoClass *klass;
2431 MONO_ARCH_SAVE_REGS;
2432
2433 if (!IS_MONOTYPE (type))
2434 return FALSE;
2435
2436 if (type->type->byref)
2437 return FALSE;
2438
2439 klass = mono_class_from_mono_type (type->type);
2440 return klass->generic_class != NULL || klass->generic_container != NULL;
2441 }
2442
2443 static gint32
2444 ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
2445 {
2446 MONO_ARCH_SAVE_REGS;
2447
2448 if (!IS_MONOTYPE (type))
2449 return -1;
2450
2451 if (is_generic_parameter (type->type))
2452 return mono_type_get_generic_param_num (type->type);
2453 return -1;
2454 }
2455
2456 static GenericParameterAttributes
2457 ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
2458 {
2459 MONO_ARCH_SAVE_REGS;
2460
2461 g_assert (IS_MONOTYPE (type));
2462 g_assert (is_generic_parameter (type->type));
2463 return mono_generic_param_info (type->type->data.generic_param)->flags;
2464 }
2465
2466 static MonoArray *
2467 ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
2468 {
2469 MonoGenericParamInfo *param_info;
2470 MonoDomain *domain;
2471 MonoClass **ptr;
2472 MonoArray *res;
2473 int i, count;
2474
2475 MONO_ARCH_SAVE_REGS;
2476
2477 g_assert (IS_MONOTYPE (type));
2478
2479 domain = mono_object_domain (type);
2480 param_info = mono_generic_param_info (type->type->data.generic_param);
2481 for (count = 0, ptr = param_info->constraints; ptr && *ptr; ptr++, count++)
2482 ;
2483
2484 res = mono_array_new (domain, mono_defaults.monotype_class, count);
2485 for (i = 0; i < count; i++)
2486 mono_array_setref (res, i, mono_type_get_object (domain, &param_info->constraints [i]->byval_arg));
2487
2488
2489 return res;
2490 }
2491
2492 static MonoBoolean
2493 ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
2494 {
2495 MONO_ARCH_SAVE_REGS;
2496 return is_generic_parameter (type->type);
2497 }
2498
2499 static MonoBoolean
2500 ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb)
2501 {
2502 MONO_ARCH_SAVE_REGS;
2503 return is_generic_parameter (tb->type.type);
2504 }
2505
2506 static void
2507 ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
2508 MonoReflectionType *t)
2509 {
2510 enumtype->type = t->type;
2511 }
2512
2513 static MonoReflectionType*
2514 ves_icall_MonoGenericClass_GetParentType (MonoReflectionGenericClass *type)
2515 {
2516 MonoDynamicGenericClass *gclass;
2517 MonoReflectionType *parent = NULL, *res;
2518 MonoDomain *domain;
2519 MonoType *inflated;
2520 MonoClass *klass;
2521
2522
2523 MONO_ARCH_SAVE_REGS;
2524
2525 g_assert (type->type.type->data.generic_class->is_dynamic);
2526 gclass = (MonoDynamicGenericClass *) type->type.type->data.generic_class;
2527
2528 domain = mono_object_domain (type);
2529 klass = mono_class_from_mono_type (type->generic_type->type.type);
2530
2531 if (!klass->generic_class && !klass->generic_container)
2532 return NULL;
2533
2534 parent = monotype_cast (type->generic_type->parent);
2535
2536 if (!parent || (parent->type->type != MONO_TYPE_GENERICINST))
2537 return NULL;
2538
2539 inflated = mono_class_inflate_generic_type (
2540 parent->type, mono_generic_class_get_context ((MonoGenericClass *) gclass));
2541
2542 res = mono_type_get_object (domain, inflated);
2543 mono_metadata_free_type (inflated);
2544 return res;
2545 }
2546
2547 static MonoArray*
2548 ves_icall_MonoGenericClass_GetInterfaces (MonoReflectionGenericClass *type)
2549 {
2550 static MonoClass *System_Reflection_MonoGenericClass;
2551 MonoGenericClass *gclass;
2552 MonoReflectionTypeBuilder *tb = NULL;
2553 MonoClass *klass = NULL;
2554 MonoDomain *domain;
2555 MonoArray *res;
2556 int icount, i;
2557
2558 MONO_ARCH_SAVE_REGS;
2559
2560 if (!System_Reflection_MonoGenericClass) {
2561 System_Reflection_MonoGenericClass = mono_class_from_name (
2562 mono_defaults.corlib, "System.Reflection", "MonoGenericClass");
2563 g_assert (System_Reflection_MonoGenericClass);
2564 }
2565
2566 domain = mono_object_domain (type);
2567
2568 gclass = type->type.type->data.generic_class;
2569 g_assert (gclass->is_dynamic);
2570
2571 tb = type->generic_type;
2572 icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0;
2573
2574 res = mono_array_new (domain, System_Reflection_MonoGenericClass, icount);
2575
2576 for (i = 0; i < icount; i++) {
2577 MonoReflectionType *iface;
2578 MonoType *it;
2579
2580 if (tb) {
2581 iface = mono_array_get (tb->interfaces, MonoReflectionType *, i);
2582 it = iface->type;
2583 } else
2584 it = &klass->interfaces [i]->byval_arg;
2585
2586 it = mono_class_inflate_generic_type (it, mono_generic_class_get_context (gclass));
2587
2588 iface = mono_type_get_object (domain, it);
2589 mono_array_setref (res, i, iface);
2590 mono_metadata_free_type (it);
2591 }
2592
2593 return res;
2594 }
2595
2596 static MonoReflectionMethod*
2597 ves_icall_MonoGenericClass_GetCorrespondingInflatedMethod (MonoReflectionGenericClass *type,
2598 MonoReflectionMethod* generic)
2599 {
2600 MonoGenericClass *gclass;
2601 MonoDynamicGenericClass *dgclass;
2602 MonoDomain *domain;
2603 int i;
2604
2605 MONO_ARCH_SAVE_REGS;
2606
2607 gclass = type->type.type->data.generic_class;
2608 g_assert (gclass->is_dynamic);
2609
2610 dgclass = (MonoDynamicGenericClass *) gclass;
2611
2612 domain = mono_object_domain (type);
2613
2614 for (i = 0; i < dgclass->count_methods; i++)
2615 if (generic->method->token == dgclass->methods [i]->token)
2616 return mono_method_get_object (domain, dgclass->methods [i], NULL);
2617
2618 return NULL;
2619 }
2620
2621 static MonoReflectionMethod*
2622 ves_icall_MonoGenericClass_GetCorrespondingInflatedConstructor (MonoReflectionGenericClass *type,
2623 MonoReflectionMethod* generic)
2624 {
2625 MonoGenericClass *gclass;
2626 MonoDynamicGenericClass *dgclass;
2627 MonoDomain *domain;
2628 int i;
2629
2630 MONO_ARCH_SAVE_REGS;
2631
2632 gclass = type->type.type->data.generic_class;
2633 g_assert (gclass->is_dynamic);
2634
2635 dgclass = (MonoDynamicGenericClass *) gclass;
2636
2637 domain = mono_object_domain (type);
2638
2639 for (i = 0; i < dgclass->count_ctors; i++)
2640 if (generic->method->token == dgclass->ctors [i]->token)
2641 return mono_method_get_object (domain, dgclass->ctors [i], NULL);
2642
2643 return NULL;
2644 }
2645
2646
2647 static MonoReflectionField*
2648 ves_icall_MonoGenericClass_GetCorrespondingInflatedField (MonoReflectionGenericClass *type,
2649 MonoString* generic_name)
2650 {
2651 MonoGenericClass *gclass;
2652 MonoDynamicGenericClass *dgclass;
2653 MonoDomain *domain;
2654 MonoClass *refclass;
2655 char *utf8_name = mono_string_to_utf8 (generic_name);
2656 int i;
2657
2658 MONO_ARCH_SAVE_REGS;
2659
2660 gclass = type->type.type->data.generic_class;
2661 g_assert (gclass->is_dynamic);
2662
2663 dgclass = (MonoDynamicGenericClass *) gclass;
2664
2665 refclass = mono_class_from_mono_type (type->type.type);
2666
2667 domain = mono_object_domain (type);
2668
2669 for (i = 0; i < dgclass->count_fields; i++)
2670 if (strcmp (utf8_name, mono_field_get_name (&dgclass->fields [i])) == 0) {
2671 g_free (utf8_name);
2672 return mono_field_get_object (domain, refclass, &dgclass->fields [i]);
2673 }
2674
2675 g_free (utf8_name);
2676
2677 return NULL;
2678 }
2679
2680
2681 static MonoReflectionMethod*
2682 ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
2683 MonoReflectionMethod* generic)
2684 {
2685 MonoDomain *domain;
2686 MonoClass *klass;
2687 MonoMethod *method;
2688 gpointer iter;
2689
2690 MONO_ARCH_SAVE_REGS;
2691
2692 domain = ((MonoObject *)type)->vtable->domain;
2693
2694 klass = mono_class_from_mono_type (type->type);
2695
2696 iter = NULL;
2697 while ((method = mono_class_get_methods (klass, &iter))) {
2698 if (method->token == generic->method->token)
2699 return mono_method_get_object (domain, method, klass);
2700 }
2701
2702 return NULL;
2703 }
2704
2705 static MonoArray*
2706 ves_icall_MonoGenericClass_GetMethods (MonoReflectionGenericClass *type,
2707 MonoReflectionType *reflected_type)
2708 {
2709 MonoGenericClass *gclass;
2710 MonoDynamicGenericClass *dgclass;
2711 MonoDomain *domain;
2712 MonoClass *refclass;
2713 MonoArray *res;
2714 int i;
2715
2716 MONO_ARCH_SAVE_REGS;
2717
2718 gclass = type->type.type->data.generic_class;
2719 g_assert (gclass->is_dynamic);
2720 dgclass = (MonoDynamicGenericClass *) gclass;
2721
2722 refclass = mono_class_from_mono_type (reflected_type->type);
2723
2724 domain = mono_object_domain (type);
2725 res = mono_array_new (domain, mono_defaults.method_info_class, dgclass->count_methods);
2726
2727 for (i = 0; i < dgclass->count_methods; i++)
2728 mono_array_setref (res, i, mono_method_get_object (domain, dgclass->methods [i], refclass));
2729
2730 return res;
2731 }
2732
2733 static MonoArray*
2734 ves_icall_MonoGenericClass_GetConstructors (MonoReflectionGenericClass *type,
2735 MonoReflectionType *reflected_type)
2736 {
2737 static MonoClass *System_Reflection_ConstructorInfo;
2738 MonoGenericClass *gclass;
2739 MonoDynamicGenericClass *dgclass;
2740 MonoDomain *domain;
2741 MonoClass *refclass;
2742 MonoArray *res;
2743 int i;
2744
2745 MONO_ARCH_SAVE_REGS;
2746
2747 if (!System_Reflection_ConstructorInfo)
2748 System_Reflection_ConstructorInfo = mono_class_from_name (
2749 mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
2750
2751 gclass = type->type.type->data.generic_class;
2752 g_assert (gclass->is_dynamic);
2753 dgclass = (MonoDynamicGenericClass *) gclass;
2754
2755 refclass = mono_class_from_mono_type (reflected_type->type);
2756
2757 domain = mono_object_domain (type);
2758 res = mono_array_new_cached (domain, System_Reflection_ConstructorInfo, dgclass->count_ctors);
2759
2760 for (i = 0; i < dgclass->count_ctors; i++)
2761 mono_array_setref (res, i, mono_method_get_object (domain, dgclass->ctors [i], refclass));
2762
2763 return res;
2764 }
2765
2766 static MonoArray*
2767 ves_icall_MonoGenericClass_GetFields (MonoReflectionGenericClass *type,
2768 MonoReflectionType *reflected_type)
2769 {
2770 MonoGenericClass *gclass;
2771 MonoDynamicGenericClass *dgclass;
2772 MonoDomain *domain;
2773 MonoClass *refclass;
2774 MonoArray *res;
2775 int i;
2776
2777 MONO_ARCH_SAVE_REGS;
2778
2779 gclass = type->type.type->data.generic_class;
2780 g_assert (gclass->is_dynamic);
2781 dgclass = (MonoDynamicGenericClass *) gclass;
2782
2783 refclass = mono_class_from_mono_type (reflected_type->type);
2784
2785 domain = mono_object_domain (type);
2786 res = mono_array_new (domain, mono_defaults.field_info_class, dgclass->count_fields);
2787
2788 for (i = 0; i < dgclass->count_fields; i++)
2789 mono_array_setref (res, i, mono_field_get_object (domain, refclass, &dgclass->fields [i]));
2790
2791 return res;
2792 }
2793
2794 static MonoArray*
2795 ves_icall_MonoGenericClass_GetProperties (MonoReflectionGenericClass *type,
2796 MonoReflectionType *reflected_type)
2797 {
2798 static MonoClass *System_Reflection_PropertyInfo;
2799 MonoGenericClass *gclass;
2800 MonoDynamicGenericClass *dgclass;
2801 MonoDomain *domain;
2802 MonoClass *refclass;
2803 MonoArray *res;
2804 int i;
2805
2806 MONO_ARCH_SAVE_REGS;
2807
2808 if (!System_Reflection_PropertyInfo)
2809 System_Reflection_PropertyInfo = mono_class_from_name (
2810 mono_defaults.corlib, "System.Reflection", "PropertyInfo");
2811
2812 gclass = type->type.type->data.generic_class;
2813 g_assert (gclass->is_dynamic);
2814 dgclass = (MonoDynamicGenericClass *) gclass;
2815
2816 refclass = mono_class_from_mono_type (reflected_type->type);
2817
2818 domain = mono_object_domain (type);
2819 res = mono_array_new (domain, System_Reflection_PropertyInfo, dgclass->count_properties);
2820
2821 for (i = 0; i < dgclass->count_properties; i++)
2822 mono_array_setref (res, i, mono_property_get_object (domain, refclass, &dgclass->properties [i]));
2823
2824 return res;
2825 }
2826
2827 static MonoArray*
2828 ves_icall_MonoGenericClass_GetEvents (MonoReflectionGenericClass *type,
2829 MonoReflectionType *reflected_type)
2830 {
2831 static MonoClass *System_Reflection_EventInfo;
2832 MonoGenericClass *gclass;
2833 MonoDynamicGenericClass *dgclass;
2834 MonoDomain *domain;
2835 MonoClass *refclass;
2836 MonoArray *res;
2837 int i;
2838
2839 MONO_ARCH_SAVE_REGS;
2840
2841 if (!System_Reflection_EventInfo)
2842 System_Reflection_EventInfo = mono_class_from_name (
2843 mono_defaults.corlib, "System.Reflection", "EventInfo");
2844
2845 gclass = type->type.type->data.generic_class;
2846 g_assert (gclass->is_dynamic);
2847 dgclass = (MonoDynamicGenericClass *) gclass;
2848
2849 refclass = mono_class_from_mono_type (reflected_type->type);
2850
2851 domain = mono_object_domain (type);
2852 res = mono_array_new (domain, System_Reflection_EventInfo, dgclass->count_events);
2853
2854 for (i = 0; i < dgclass->count_events; i++)
2855 mono_array_setref (res, i, mono_event_get_object (domain, refclass, &dgclass->events [i]));
2856
2857 return res;
2858 }
2859
2860 static MonoReflectionType*
2861 ves_icall_MonoGenericClass_InflateType (MonoReflectionGenericClass *type,
2862 MonoReflectionType *target)
2863 {
2864 MonoType *res_type;
2865 MonoClass *gklass;
2866 MonoReflectionType *res;
2867
2868 MONO_ARCH_SAVE_REGS;
2869
2870 gklass = mono_class_from_mono_type (type->type.type);
2871 res_type = mono_class_inflate_generic_type (target->type, mono_class_get_context (gklass));
2872 res = mono_type_get_object (mono_object_domain (type), res_type);
2873 mono_metadata_free_type (res_type);
2874 return res;
2875 }
2876
2877 static MonoReflectionMethod *
2878 ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *type)
2879 {
2880 MonoMethod *method;
2881 MonoClass *klass;
2882
2883 MONO_ARCH_SAVE_REGS;
2884
2885 if (type->type->byref || type->type->type != MONO_TYPE_MVAR)
2886 return NULL;
2887
2888 method = mono_type_get_generic_param_owner (type->type)->owner.method;
2889 g_assert (method);
2890 klass = mono_class_from_mono_type (type->type);
2891 return mono_method_get_object (mono_object_domain (type), method, klass);
2892 }
2893
2894 static MonoReflectionDllImportAttribute*
2895 ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod *method)
2896 {
2897 static MonoClass *DllImportAttributeClass = NULL;
2898 MonoDomain *domain = mono_domain_get ();
2899 MonoReflectionDllImportAttribute *attr;
2900 MonoImage *image = method->klass->image;
2901 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method;
2902 MonoTableInfo *tables = image->tables;
2903 MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
2904 MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
2905 guint32 im_cols [MONO_IMPLMAP_SIZE];
2906 guint32 scope_token;
2907 const char *import = NULL;
2908 const char *scope = NULL;
2909 guint32 flags;
2910
2911 if (!method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)
2912 return NULL;
2913
2914 if (!DllImportAttributeClass) {
2915 DllImportAttributeClass =
2916 mono_class_from_name (mono_defaults.corlib,
2917 "System.Runtime.InteropServices", "DllImportAttribute");
2918 g_assert (DllImportAttributeClass);
2919 }
2920
2921 if (method->klass->image->dynamic) {
2922 MonoReflectionMethodAux *method_aux =
2923 g_hash_table_lookup (
2924 ((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
2925 if (method_aux) {
2926 import = method_aux->dllentry;
2927 scope = method_aux->dll;
2928 }
2929 }
2930 else {
2931 if (piinfo->implmap_idx) {
2932 mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
2933
2934 piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
2935 import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
2936 scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
2937 scope = mono_metadata_string_heap (image, scope_token);
2938 }
2939 }
2940 flags = piinfo->piflags;
2941
2942 attr = (MonoReflectionDllImportAttribute*)mono_object_new (domain, DllImportAttributeClass);
2943
2944 MONO_OBJECT_SETREF (attr, dll, mono_string_new (domain, scope));
2945 MONO_OBJECT_SETREF (attr, entry_point, mono_string_new (domain, import));
2946 attr->call_conv = (flags & 0x700) >> 8;
2947 attr->charset = ((flags & 0x6) >> 1) + 1;
2948 if (attr->charset == 1)
2949 attr->charset = 2;
2950 attr->exact_spelling = (flags & 0x1) != 0;
2951 attr->set_last_error = (flags & 0x40) != 0;
2952 attr->best_fit_mapping = (flags & 0x30) == 0x10;
2953 attr->throw_on_unmappable = (flags & 0x3000) == 0x1000;
2954 attr->preserve_sig = FALSE;
2955
2956 return attr;
2957 }
2958
2959 static MonoReflectionMethod *
2960 ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
2961 {
2962 MonoMethodInflated *imethod;
2963 MonoMethod *result;
2964
2965 MONO_ARCH_SAVE_REGS;
2966
2967 if (method->method->is_generic)
2968 return method;
2969
2970 if (!method->method->is_inflated)
2971 return NULL;
2972
2973 imethod = (MonoMethodInflated *) method->method;
2974
2975 result = imethod->declaring;
2976 /* Not a generic method. */
2977 if (!result->is_generic)
2978 return NULL;
2979
2980 if (method->method->klass->image->dynamic) {
2981 MonoDynamicImage *image = (MonoDynamicImage*)method->method->klass->image;
2982 MonoReflectionMethod *res;
2983
2984 /*
2985 * FIXME: Why is this stuff needed at all ? Why can't the code below work for
2986 * the dynamic case as well ?
2987 */
2988 mono_loader_lock ();
2989 res = mono_g_hash_table_lookup (image->generic_def_objects, imethod);
2990 mono_loader_unlock ();
2991
2992 if (res)
2993 return res;
2994 }
2995
2996 if (imethod->context.class_inst) {
2997 MonoClass *klass = ((MonoMethod *) imethod)->klass;
2998 result = mono_class_inflate_generic_method_full (result, klass, mono_class_get_context (klass));
2999 }
3000
3001 return mono_method_get_object (mono_object_domain (method), result, NULL);
3002 }
3003
3004 static gboolean
3005 ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
3006 {
3007 MONO_ARCH_SAVE_REGS;
3008
3009 return mono_method_signature (method->method)->generic_param_count != 0;
3010 }
3011
3012 static gboolean
3013 ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
3014 {
3015 MONO_ARCH_SAVE_REGS;
3016
3017 return method->method->is_generic;
3018 }
3019
3020 static MonoArray*
3021 ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
3022 {
3023 MonoArray *res;
3024 MonoDomain *domain;
3025 int count, i;
3026 MONO_ARCH_SAVE_REGS;
3027
3028 domain = mono_object_domain (method);
3029
3030 if (method->method->is_inflated) {
3031 MonoGenericInst *inst = mono_method_get_context (method->method)->method_inst;
3032
3033 if (inst) {
3034 count = inst->type_argc;
3035 res = mono_array_new (domain, mono_defaults.systemtype_class, count);
3036
3037 for (i = 0; i < count; i++)
3038 mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
3039
3040 return res;
3041 }
3042 }
3043
3044 count = mono_method_signature (method->method)->generic_param_count;
3045 res = mono_array_new (domain, mono_defaults.systemtype_class, count);
3046
3047 for (i = 0; i < count; i++) {
3048 MonoGenericContainer *container = mono_method_get_generic_container (method->method);
3049 MonoGenericParam *param = mono_generic_container_get_param (container, i);
3050 MonoClass *pklass = mono_class_from_generic_parameter (
3051 param, method->method->klass->image, TRUE);
3052 mono_array_setref (res, i,
3053 mono_type_get_object (domain, &pklass->byval_arg));
3054 }
3055
3056 return res;
3057 }
3058
3059 static MonoObject *
3060 ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoException **exc)
3061 {
3062 /*
3063 * Invoke from reflection is supposed to always be a virtual call (the API
3064 * is stupid), mono_runtime_invoke_*() calls the provided method, allowing
3065 * greater flexibility.
3066 */
3067 MonoMethod *m = method->method;
3068 int pcount;
3069 void *obj = this;
3070
3071 MONO_ARCH_SAVE_REGS;
3072
3073 *exc = NULL;
3074
3075 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
3076 mono_security_core_clr_ensure_reflection_access_method (m);
3077
3078 if (!(m->flags & METHOD_ATTRIBUTE_STATIC)) {
3079 if (this) {
3080 if (!mono_object_isinst (this, m->klass)) {
3081 *exc = mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Object does not match target type.");
3082 return NULL;
3083 }
3084 m = mono_object_get_virtual_method (this, m);
3085 /* must pass the pointer to the value for valuetype methods */
3086 if (m->klass->valuetype)
3087 obj = mono_object_unbox (this);
3088 } else if (strcmp (m->name, ".ctor") && !m->wrapper_type) {
3089 *exc = mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Non-static method requires a target.");
3090 return NULL;
3091 }
3092 }
3093
3094 pcount = params? mono_array_length (params): 0;
3095 if (pcount != mono_method_signature (m)->param_count) {
3096 *exc = mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException");
3097 return NULL;
3098 }
3099
3100 if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this) {
3101 *exc = mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.");
3102 return NULL;
3103 }
3104
3105 if (m->klass->image->assembly->ref_only) {
3106 *exc = mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api.");
3107 return NULL;
3108 }
3109
3110 if (m->klass->rank && !strcmp (m->name, ".ctor")) {
3111 int i;
3112 mono_array_size_t *lengths;
3113 mono_array_size_t *lower_bounds;
3114 pcount = mono_array_length (params);
3115 lengths = alloca (sizeof (mono_array_size_t) * pcount);
3116 for (i = 0; i < pcount; ++i)
3117 lengths [i] = *(mono_array_size_t*) ((char*)mono_array_get (params, gpointer, i) + sizeof (MonoObject));
3118
3119 if (m->klass->rank == pcount) {
3120 /* Only lengths provided. */
3121 lower_bounds = NULL;
3122 } else {
3123 g_assert (pcount == (m->klass->rank * 2));
3124 /* lower bounds are first. */
3125 lower_bounds = lengths;
3126 lengths += m->klass->rank;
3127 }
3128
3129 return (MonoObject*)mono_array_new_full (mono_object_domain (params), m->klass, lengths, lower_bounds);
3130 }
3131 return mono_runtime_invoke_array (m, obj, params, NULL);
3132 }
3133
3134 static MonoObject *
3135 ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoArray **outArgs)
3136 {
3137 MonoDomain *domain = mono_object_domain (method);
3138 MonoMethod *m = method->method;
3139 MonoMethodSignature *sig = mono_method_signature (m);
3140 MonoArray *out_args;
3141 MonoObject *result;
3142 int i, j, outarg_count = 0;
3143
3144 MONO_ARCH_SAVE_REGS;
3145
3146 if (m->klass == mono_defaults.object_class) {
3147
3148 if (!strcmp (m->name, "FieldGetter")) {
3149 MonoClass *k = this->vtable->klass;
3150 MonoString *name;
3151 char *str;
3152
3153 /* If this is a proxy, then it must be a CBO */
3154 if (k == mono_defaults.transparent_proxy_class) {
3155 MonoTransparentProxy *tp = (MonoTransparentProxy*) this;
3156 this = tp->rp->unwrapped_server;
3157 g_assert (this);
3158 k = this->vtable->klass;
3159 }
3160
3161 name = mono_array_get (params, MonoString *, 1);
3162 str = mono_string_to_utf8 (name);
3163
3164 do {
3165 MonoClassField* field = mono_class_get_field_from_name (k, str);
3166 if (field) {
3167 MonoClass *field_klass = mono_class_from_mono_type (field->type);
3168 if (field_klass->valuetype)
3169 result = mono_value_box (domain, field_klass, (char *)this + field->offset);
3170 else
3171 result = *((gpointer *)((char *)this + field->offset));
3172
3173 out_args = mono_array_new (domain, mono_defaults.object_class, 1);
3174 *outArgs = out_args;
3175 mono_array_setref (out_args, 0, result);
3176 g_free (str);
3177 return NULL;
3178 }
3179 k = k->parent;
3180 } while (k);
3181
3182 g_free (str);
3183 g_assert_not_reached ();
3184
3185 } else if (!strcmp (m->name, "FieldSetter")) {
3186 MonoClass *k = this->vtable->klass;
3187 MonoString *name;
3188 guint32 size;
3189 gint32 align;
3190 char *str;
3191
3192 /* If this is a proxy, then it must be a CBO */
3193 if (k == mono_defaults.transparent_proxy_class) {
3194 MonoTransparentProxy *tp = (MonoTransparentProxy*) this;
3195 this = tp->rp->unwrapped_server;
3196 g_assert (this);
3197 k = this->vtable->klass;
3198 }
3199
3200 name = mono_array_get (params, MonoString *, 1);
3201 str = mono_string_to_utf8 (name);
3202
3203 do {
3204 MonoClassField* field = mono_class_get_field_from_name (k, str);
3205 if (field) {
3206 MonoClass *field_klass = mono_class_from_mono_type (field->type);
3207 MonoObject *val = mono_array_get (params, gpointer, 2);
3208
3209 if (field_klass->valuetype) {
3210 size = mono_type_size (field->type, &align);
3211 #ifdef HAVE_SGEN_GC
3212 mono_gc_wbarrier_value_copy ((char *)this + field->offset, (char*)val + sizeof (MonoObject), 1, field_klass);
3213 #endif
3214 memcpy ((char *)this + field->offset,
3215 ((char *)val) + sizeof (MonoObject), size);
3216 } else {
3217 mono_gc_wbarrier_set_field (this, (char*)this + field->offset, val);
3218 }
3219
3220 out_args = mono_array_new (domain, mono_defaults.object_class, 0);
3221 *outArgs = out_args;
3222
3223 g_free (str);
3224 return NULL;
3225 }
3226
3227 k = k->parent;
3228 } while (k);
3229
3230 g_free (str);
3231 g_assert_not_reached ();
3232
3233 }
3234 }
3235
3236 for (i = 0; i < mono_array_length (params); i++) {
3237 if (sig->params [i]->byref)
3238 outarg_count++;
3239 }
3240
3241 out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count);
3242
3243 /* handle constructors only for objects already allocated */
3244 if (!strcmp (method->method->name, ".ctor"))
3245 g_assert (this);
3246
3247 /* This can be called only on MBR objects, so no need to unbox for valuetypes. */
3248 g_assert (!method->method->klass->valuetype);
3249 result = mono_runtime_invoke_array (method->method, this, params, NULL);
3250
3251 for (i = 0, j = 0; i < mono_array_length (params); i++) {
3252 if (sig->params [i]->byref) {
3253 gpointer arg;
3254 arg = mono_array_get (params, gpointer, i);
3255 mono_array_setref (out_args, j, arg);
3256 j++;
3257 }
3258 }
3259
3260 *outArgs = out_args;
3261
3262 return result;
3263 }
3264
3265 static guint64
3266 read_enum_value (char *mem, int type)
3267 {
3268 switch (type) {
3269 case MONO_TYPE_U1:
3270 return *(guint8*)mem;
3271 case MONO_TYPE_I1:
3272 return *(gint8*)mem;
3273 case MONO_TYPE_U2:
3274 return *(guint16*)mem;
3275 case MONO_TYPE_I2:
3276 return *(gint16*)mem;
3277 case MONO_TYPE_U4:
3278 return *(guint32*)mem;
3279 case MONO_TYPE_I4:
3280 return *(gint32*)mem;
3281 case MONO_TYPE_U8:
3282 return *(guint64*)mem;
3283 case MONO_TYPE_I8:
3284 return *(gint64*)mem;
3285 default:
3286 g_assert_not_reached ();
3287 }
3288 return 0;
3289 }
3290
3291 static void
3292 write_enum_value (char *mem, int type, guint64 value)
3293 {
3294 switch (type) {
3295 case MONO_TYPE_U1:
3296 case MONO_TYPE_I1: {
3297 guint8 *p = (guint8*)mem;
3298 *p = value;
3299 break;
3300 }
3301 case MONO_TYPE_U2:
3302 case MONO_TYPE_I2: {
3303 guint16 *p = (void*)mem;
3304 *p = value;
3305 break;
3306 }
3307 case MONO_TYPE_U4:
3308 case MONO_TYPE_I4: {
3309 guint32 *p = (void*)mem;
3310 *p = value;
3311 break;
3312 }
3313 case MONO_TYPE_U8:
3314 case MONO_TYPE_I8: {
3315 guint64 *p = (void*)mem;
3316 *p = value;
3317 break;
3318 }
3319 default:
3320 g_assert_not_reached ();
3321 }
3322 return;
3323 }
3324
3325 static MonoObject *
3326 ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, MonoObject *value)
3327 {
3328 MonoDomain *domain;
3329 MonoClass *enumc, *objc;
3330 MonoObject *res;
3331 guint64 val;
3332
3333 MONO_ARCH_SAVE_REGS;
3334
3335 MONO_CHECK_ARG_NULL (enumType);
3336 MONO_CHECK_ARG_NULL (value);
3337
3338 domain = mono_object_domain (enumType);
3339 enumc = mono_class_from_mono_type (enumType->type);
3340 objc = value->vtable->klass;
3341
3342 if (!enumc->enumtype)
3343 mono_raise_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
3344 if (!((objc->enumtype) || (objc->byval_arg.type >= MONO_TYPE_I1 && objc->byval_arg.type <= MONO_TYPE_U8)))
3345 mono_raise_exception (mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32."));
3346
3347 res = mono_object_new (domain, enumc);
3348 val = read_enum_value ((char *)value + sizeof (MonoObject), objc->enumtype? mono_class_enum_basetype (objc)->type: objc->byval_arg.type);
3349 write_enum_value ((char *)res + sizeof (MonoObject), mono_class_enum_basetype (enumc)->type, val);
3350
3351 return res;
3352 }
3353
3354 static MonoObject *
3355 ves_icall_System_Enum_get_value (MonoObject *this)
3356 {
3357 MonoObject *res;
3358 MonoClass *enumc;
3359 gpointer dst;
3360 gpointer src;
3361 int size;
3362
3363 MONO_ARCH_SAVE_REGS;
3364
3365 if (!this)
3366 return NULL;
3367
3368 g_assert (this->vtable->klass->enumtype);
3369
3370 enumc = mono_class_from_mono_type (mono_class_enum_basetype (this->vtable->klass));
3371 res = mono_object_new (mono_object_domain (this), enumc);
3372 dst = (char *)res + sizeof (MonoObject);
3373 src = (char *)this + sizeof (MonoObject);
3374 size = mono_class_value_size (enumc, NULL);
3375
3376 memcpy (dst, src, size);
3377
3378 return res;
3379 }
3380
3381 static MonoReflectionType *
3382 ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
3383 {
3384 MONO_ARCH_SAVE_REGS;
3385
3386 return mono_type_get_object (mono_object_domain (type), mono_class_enum_basetype (mono_class_from_mono_type (type->type)));
3387 }
3388
3389 static int
3390 ves_icall_System_Enum_compare_value_to (MonoObject *this, MonoObject *other)
3391 {
3392 gpointer tdata = (char *)this + sizeof (MonoObject);
3393 gpointer odata = (char *)other + sizeof (MonoObject);
3394 MonoType *basetype = mono_class_enum_basetype (this->vtable->klass);
3395 g_assert (basetype);
3396
3397 #define COMPARE_ENUM_VALUES(ENUM_TYPE) do { \
3398 ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
3399 ENUM_TYPE other = *((ENUM_TYPE*)odata); \
3400 if (me == other) \
3401 return 0; \
3402 return me > other ? 1 : -1; \
3403 } while (0)
3404
3405 #define COMPARE_ENUM_VALUES_RANGE(ENUM_TYPE) do { \
3406 ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
3407 ENUM_TYPE other = *((ENUM_TYPE*)odata); \
3408 if (me == other) \
3409 return 0; \
3410 return me - other; \
3411 } while (0)
3412
3413 switch (basetype->type) {
3414 case MONO_TYPE_U1:
3415 COMPARE_ENUM_VALUES (guint8);
3416 case MONO_TYPE_I1:
3417 COMPARE_ENUM_VALUES (gint8);
3418 case MONO_TYPE_CHAR:
3419 case MONO_TYPE_U2:
3420 COMPARE_ENUM_VALUES_RANGE (guint16);
3421 case MONO_TYPE_I2:
3422 COMPARE_ENUM_VALUES (gint16);
3423 case MONO_TYPE_U4:
3424 COMPARE_ENUM_VALUES (guint32);
3425 case MONO_TYPE_I4:
3426 COMPARE_ENUM_VALUES (gint32);
3427 case MONO_TYPE_U8:
3428 COMPARE_ENUM_VALUES (guint64);
3429 case MONO_TYPE_I8:
3430 COMPARE_ENUM_VALUES (gint64);
3431 default:
3432 g_error ("Implement type 0x%02x in get_hashcode", basetype->type);
3433 }
3434 #undef COMPARE_ENUM_VALUES_RANGE
3435 #undef COMPARE_ENUM_VALUES
3436 return 0;
3437 }
3438
3439 static int
3440 ves_icall_System_Enum_get_hashcode (MonoObject *this)
3441 {
3442 gpointer data = (char *)this + sizeof (MonoObject);
3443 MonoType *basetype = mono_class_enum_basetype (this->vtable->klass);
3444 g_assert (basetype);
3445
3446 switch (basetype->type) {
3447 case MONO_TYPE_I1:
3448 return *((gint8*)data);
3449 case MONO_TYPE_U1:
3450 return *((guint8*)data);
3451 case MONO_TYPE_CHAR:
3452 case MONO_TYPE_U2:
3453 return *((guint16*)data);
3454
3455 case MONO_TYPE_I2:
3456 return *((gint16*)data);
3457 case MONO_TYPE_U4:
3458 return *((guint32*)data);
3459 case MONO_TYPE_I4:
3460 return *((gint32*)data);
3461 case MONO_TYPE_U8:
3462 case MONO_TYPE_I8: {
3463 gint64 value = *((gint64*)data);
3464 return (gint)(value & 0xffffffff) ^ (int)(value >> 32);
3465 }
3466 default:
3467 g_error ("Implement type 0x%02x in get_hashcode", basetype->type);
3468 }
3469 return 0;
3470 }
3471
3472 static void
3473 ves_icall_get_enum_info (MonoReflectionType *type, MonoEnumInfo *info)
3474 {
3475 MonoDomain *domain = mono_object_domain (type);
3476 MonoClass *enumc = mono_class_from_mono_type (type->type);
3477 guint j = 0, nvalues, crow;
3478 gpointer iter;
3479 MonoClassField *field;
3480
3481 MONO_ARCH_SAVE_REGS;
3482
3483 info->utype = mono_type_get_object (domain, mono_class_enum_basetype (enumc));
3484 nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0;
3485 info->names = mono_array_new (domain, mono_defaults.string_class, nvalues);
3486 info->values = mono_array_new (domain, enumc, nvalues);
3487
3488 crow = -1;
3489 iter = NULL;
3490 while ((field = mono_class_get_fields (enumc, &iter))) {
3491 const char *p;
3492 int len;
3493 MonoTypeEnum def_type;
3494
3495 if (strcmp ("value__", mono_field_get_name (field)) == 0)
3496 continue;
3497 if (mono_field_is_deleted (field))
3498 continue;
3499 mono_array_setref (info->names, j, mono_string_new (domain, mono_field_get_name (field)));
3500
3501 p = mono_class_get_field_default_value (field, &def_type);
3502 len = mono_metadata_decode_blob_size (p, &p);
3503 switch (mono_class_enum_basetype (enumc)->type) {
3504 case MONO_TYPE_U1:
3505 case MONO_TYPE_I1:
3506 mono_array_set (info->values, gchar, j, *p);
3507 break;
3508 case MONO_TYPE_CHAR:
3509 case MONO_TYPE_U2:
3510 case MONO_TYPE_I2:
3511 mono_array_set (info->values, gint16, j, read16 (p));
3512 break;
3513 case MONO_TYPE_U4:
3514 case MONO_TYPE_I4:
3515 mono_array_set (info->values, gint32, j, read32 (p));
3516 break;
3517 case MONO_TYPE_U8:
3518 case MONO_TYPE_I8:
3519 mono_array_set (info->values, gint64, j, read64 (p));
3520 break;
3521 default:
3522 g_error ("Implement type 0x%02x in get_enum_info", mono_class_enum_basetype (enumc)->type);
3523 }
3524 ++j;
3525 }
3526 }
3527
3528 enum {
3529 BFLAGS_IgnoreCase = 1,
3530 BFLAGS_DeclaredOnly = 2,
3531 BFLAGS_Instance = 4,
3532 BFLAGS_Static = 8,
3533 BFLAGS_Public = 0x10,
3534 BFLAGS_NonPublic = 0x20,
3535 BFLAGS_FlattenHierarchy = 0x40,
3536 BFLAGS_InvokeMethod = 0x100,
3537 BFLAGS_CreateInstance = 0x200,
3538 BFLAGS_GetField = 0x400,
3539 BFLAGS_SetField = 0x800,
3540 BFLAGS_GetProperty = 0x1000,
3541 BFLAGS_SetProperty = 0x2000,
3542 BFLAGS_ExactBinding = 0x10000,
3543 BFLAGS_SuppressChangeType = 0x20000,
3544 BFLAGS_OptionalParamBinding = 0x40000
3545 };
3546
3547 static MonoReflectionField *
3548 ves_icall_Type_GetField (MonoReflectionType *type, MonoString *name, guint32 bflags)
3549 {
3550 MonoDomain *domain;
3551 MonoClass *startklass, *klass;
3552 int match;
3553 MonoClassField *field;
3554 gpointer iter;
3555 char *utf8_name;
3556 int (*compare_func) (const char *s1, const char *s2) = NULL;
3557 domain = ((MonoObject *)type)->vtable->domain;
3558 klass = startklass = mono_class_from_mono_type (type->type);
3559
3560 MONO_ARCH_SAVE_REGS;
3561
3562 if (!name)
3563 mono_raise_exception (mono_get_exception_argument_null ("name"));
3564 if (type->type->byref)
3565 return NULL;
3566
3567 compare_func = (bflags & BFLAGS_IgnoreCase) ? g_strcasecmp : strcmp;
3568
3569 handle_parent:
3570 if (klass->exception_type != MONO_EXCEPTION_NONE)
3571 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3572
3573 iter = NULL;
3574 while ((field = mono_class_get_fields (klass, &iter))) {
3575 match = 0;
3576
3577 if (field->type == NULL)
3578 continue;
3579 if (mono_field_is_deleted (field))
3580 continue;
3581 if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) {
3582 if (bflags & BFLAGS_Public)
3583 match++;
3584 } else if ((klass == startklass) || (field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) {
3585 if (bflags & BFLAGS_NonPublic) {
3586 match++;
3587 }
3588 }
3589 if (!match)
3590 continue;
3591 match = 0;
3592 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
3593 if (bflags & BFLAGS_Static)
3594 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3595 match++;
3596 } else {
3597 if (bflags & BFLAGS_Instance)
3598 match++;
3599 }
3600
3601 if (!match)
3602 continue;
3603
3604 utf8_name = mono_string_to_utf8 (name);
3605
3606 if (compare_func (mono_field_get_name (field), utf8_name)) {
3607 g_free (utf8_name);
3608 continue;
3609 }
3610 g_free (utf8_name);
3611
3612 return mono_field_get_object (domain, klass, field);
3613 }
3614 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3615 goto handle_parent;
3616
3617 return NULL;
3618 }
3619
3620 static MonoArray*
3621 ves_icall_Type_GetFields_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
3622 {
3623 MonoDomain *domain;
3624 MonoClass *startklass, *klass, *refklass;
3625 MonoArray *res;
3626 MonoObject *member;
3627 int i, match;
3628 gpointer iter;
3629 MonoClassField *field;
3630 MonoPtrArray tmp_array;
3631
3632 MONO_ARCH_SAVE_REGS;
3633
3634 domain = ((MonoObject *)type)->vtable->domain;
3635 if (type->type->byref)
3636 return mono_array_new (domain, mono_defaults.field_info_class, 0);
3637 klass = startklass = mono_class_from_mono_type (type->type);
3638 refklass = mono_class_from_mono_type (reftype->type);
3639
3640 mono_ptr_array_init (tmp_array, 2);
3641
3642 handle_parent:
3643 if (klass->exception_type != MONO_EXCEPTION_NONE)
3644 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3645
3646 iter = NULL;
3647 while ((field = mono_class_get_fields (klass, &iter))) {
3648 match = 0;
3649 if (mono_field_is_deleted (field))
3650 continue;
3651 if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) {
3652 if (bflags & BFLAGS_Public)
3653 match++;
3654 } else if ((klass == startklass) || (field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) {
3655 if (bflags & BFLAGS_NonPublic) {
3656 match++;
3657 }
3658 }
3659 if (!match)
3660 continue;
3661 match = 0;
3662 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
3663 if (bflags & BFLAGS_Static)
3664 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3665 match++;
3666 } else {
3667 if (bflags & BFLAGS_Instance)
3668 match++;
3669 }
3670
3671 if (!match)
3672 continue;
3673 member = (MonoObject*)mono_field_get_object (domain, refklass, field);
3674 mono_ptr_array_append (tmp_array, member);
3675 }
3676 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3677 goto handle_parent;
3678
3679 res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array));
3680
3681 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3682 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3683
3684 mono_ptr_array_destroy (tmp_array);
3685
3686 return res;
3687 }
3688
3689 static gboolean
3690 method_nonpublic (MonoMethod* method, gboolean start_klass)
3691 {
3692 switch (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) {
3693 case METHOD_ATTRIBUTE_ASSEM:
3694 return (start_klass || mono_defaults.generic_ilist_class);
3695 case METHOD_ATTRIBUTE_PRIVATE:
3696 return start_klass;
3697 case METHOD_ATTRIBUTE_PUBLIC:
3698 return FALSE;
3699 default:
3700 return TRUE;
3701 }
3702 }
3703
3704 static MonoArray*
3705 ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
3706 {
3707 static MonoClass *MethodInfo_array;
3708 MonoDomain *domain;
3709 MonoClass *startklass, *klass, *refklass;
3710 MonoArray *res;
3711 MonoMethod *method;
3712 gpointer iter;
3713 MonoObject *member;
3714 int i, len, match, nslots;
3715 guint32 method_slots_default [8];
3716 guint32 *method_slots;
3717 gchar *mname = NULL;
3718 int (*compare_func) (const char *s1, const char *s2) = NULL;
3719 MonoVTable *array_vtable;
3720 MonoPtrArray tmp_array;
3721
3722 MONO_ARCH_SAVE_REGS;
3723
3724 mono_ptr_array_init (tmp_array, 4);
3725
3726 if (!MethodInfo_array) {
3727 MonoClass *klass = mono_array_class_get (mono_defaults.method_info_class, 1);
3728 mono_memory_barrier ();
3729 MethodInfo_array = klass;
3730 }
3731
3732 domain = ((MonoObject *)type)->vtable->domain;
3733 array_vtable = mono_class_vtable (domain, MethodInfo_array);
3734 if (type->type->byref)
3735 return mono_array_new_specific (array_vtable, 0);
3736 klass = startklass = mono_class_from_mono_type (type->type);
3737 refklass = mono_class_from_mono_type (reftype->type);
3738 len = 0;
3739 if (name != NULL) {
3740 mname = mono_string_to_utf8 (name);
3741 compare_func = (ignore_case) ? g_strcasecmp : strcmp;
3742 }
3743
3744 /* An optimization for calls made from Delegate:CreateDelegate () */
3745 if (klass->delegate && mname && !strcmp (mname, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) {
3746 method = mono_get_delegate_invoke (klass);
3747
3748 member = (MonoObject*)mono_method_get_object (domain, method, refklass);
3749
3750 res = mono_array_new_specific (array_vtable, 1);
3751 mono_array_setref (res, 0, member);
3752 g_free (mname);
3753 return res;
3754 }
3755
3756 mono_class_setup_vtable (klass);
3757
3758 if (is_generic_parameter (type->type))
3759 nslots = klass->parent->vtable_size;
3760 else
3761 nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : klass->vtable_size;
3762 if (nslots >= sizeof (method_slots_default) * 8) {
3763 method_slots = g_new0 (guint32, nslots / 32 + 1);
3764 } else {
3765 method_slots = method_slots_default;
3766 memset (method_slots, 0, sizeof (method_slots_default));
3767 }
3768 handle_parent:
3769 mono_class_setup_vtable (klass);
3770 if (klass->exception_type != MONO_EXCEPTION_NONE)
3771 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3772
3773 iter = NULL;
3774 while ((method = mono_class_get_methods (klass, &iter))) {
3775 match = 0;
3776 if (method->name [0] == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0))
3777 continue;
3778 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3779 if (bflags & BFLAGS_Public)
3780 match++;
3781 } else if ((bflags & BFLAGS_NonPublic) && method_nonpublic (method, (klass == startklass))) {
3782 match++;
3783 }
3784 if (!match)
3785 continue;
3786 match = 0;
3787 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3788 if (bflags & BFLAGS_Static)
3789 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3790 match++;
3791 } else {
3792 if (bflags & BFLAGS_Instance)
3793 match++;
3794 }
3795
3796 if (!match)
3797 continue;
3798
3799 if (name != NULL) {
3800 if (compare_func (mname, method->name))
3801 continue;
3802 }
3803
3804 match = 0;
3805 if (method->slot != -1) {
3806 g_assert (method->slot < nslots);
3807 if (method_slots [method->slot >> 5] & (1 << (method->slot & 0x1f)))
3808 continue;
3809 method_slots [method->slot >> 5] |= 1 << (method->slot & 0x1f);
3810 }
3811
3812 member = (MonoObject*)mono_method_get_object (domain, method, refklass);
3813
3814 mono_ptr_array_append (tmp_array, member);
3815 }
3816 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3817 goto handle_parent;
3818
3819 g_free (mname);
3820 if (method_slots != method_slots_default)
3821 g_free (method_slots);
3822
3823 res = mono_array_new_specific (array_vtable, mono_ptr_array_size (tmp_array));
3824
3825 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3826 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3827
3828 mono_ptr_array_destroy (tmp_array);
3829 return res;
3830 }
3831
3832 static MonoArray*
3833 ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
3834 {
3835 MonoDomain *domain;
3836 static MonoClass *System_Reflection_ConstructorInfo;
3837 MonoClass *startklass, *klass, *refklass;
3838 MonoArray *res;
3839 MonoMethod *method;
3840 MonoObject *member;
3841 int i, match;
3842 gpointer iter = NULL;
3843 MonoPtrArray tmp_array;
3844
3845 MONO_ARCH_SAVE_REGS;
3846
3847 mono_ptr_array_init (tmp_array, 4); /*FIXME, guestimating*/
3848
3849 domain = ((MonoObject *)type)->vtable->domain;
3850 if (type->type->byref)
3851 return mono_array_new_cached (domain, mono_defaults.method_info_class, 0);
3852 klass = startklass = mono_class_from_mono_type (type->type);
3853 refklass = mono_class_from_mono_type (reftype->type);
3854
3855 if (klass->exception_type != MONO_EXCEPTION_NONE)
3856 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3857
3858 if (!System_Reflection_ConstructorInfo)
3859 System_Reflection_ConstructorInfo = mono_class_from_name (
3860 mono_defaults.corlib, "System.Reflection", "ConstructorInfo");
3861
3862 iter = NULL;
3863 while ((method = mono_class_get_methods (klass, &iter))) {
3864 match = 0;
3865 if (strcmp (method->name, ".ctor") && strcmp (method->name, ".cctor"))
3866 continue;
3867 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3868 if (bflags & BFLAGS_Public)
3869 match++;
3870 } else {
3871 if (bflags & BFLAGS_NonPublic)
3872 match++;
3873 }
3874 if (!match)
3875 continue;
3876 match = 0;
3877 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3878 if (bflags & BFLAGS_Static)
3879 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3880 match++;
3881 } else {
3882 if (bflags & BFLAGS_Instance)
3883 match++;
3884 }
3885
3886 if (!match)
3887 continue;
3888 member = (MonoObject*)mono_method_get_object (domain, method, refklass);
3889
3890 mono_ptr_array_append (tmp_array, member);
3891 }
3892
3893 res = mono_array_new_cached (domain, System_Reflection_ConstructorInfo, mono_ptr_array_size (tmp_array));
3894
3895 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3896 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3897
3898 mono_ptr_array_destroy (tmp_array);
3899
3900 return res;
3901 }
3902
3903 static guint
3904 property_hash (gconstpointer data)
3905 {
3906 MonoProperty *prop = (MonoProperty*)data;
3907
3908 return g_str_hash (prop->name);
3909 }
3910
3911 static gboolean
3912 property_equal (MonoProperty *prop1, MonoProperty *prop2)
3913 {
3914 // Properties are hide-by-name-and-signature
3915 if (!g_str_equal (prop1->name, prop2->name))
3916 return FALSE;
3917
3918 if (prop1->get && prop2->get && !mono_metadata_signature_equal (mono_method_signature (prop1->get), mono_method_signature (prop2->get)))
3919 return FALSE;
3920 if (prop1->set && prop2->set && !mono_metadata_signature_equal (mono_method_signature (prop1->set), mono_method_signature (prop2->set)))
3921 return FALSE;
3922 return TRUE;
3923 }
3924
3925 static gboolean
3926 property_accessor_nonpublic (MonoMethod* accessor, gboolean start_klass)
3927 {
3928 if (!accessor)
3929 return FALSE;
3930
3931 return method_nonpublic (accessor, start_klass);
3932 }
3933
3934 static MonoArray*
3935 ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
3936 {
3937 MonoDomain *domain;
3938 static MonoClass *System_Reflection_PropertyInfo;
3939 MonoClass *startklass, *klass;
3940 MonoArray *res;
3941 MonoMethod *method;
3942 MonoProperty *prop;
3943 int i, match;
3944 guint32 flags;
3945 gchar *propname = NULL;
3946 int (*compare_func) (const char *s1, const char *s2) = NULL;
3947 gpointer iter;
3948 GHashTable *properties;
3949 MonoPtrArray tmp_array;
3950
3951 MONO_ARCH_SAVE_REGS;
3952
3953 mono_ptr_array_init (tmp_array, 8); /*This the average for ASP.NET types*/
3954
3955 if (!System_Reflection_PropertyInfo)
3956 System_Reflection_PropertyInfo = mono_class_from_name (
3957 mono_defaults.corlib, "System.Reflection", "PropertyInfo");
3958
3959 domain = ((MonoObject *)type)->vtable->domain;
3960 if (type->type->byref)
3961 return mono_array_new_cached (domain, System_Reflection_PropertyInfo, 0);
3962 klass = startklass = mono_class_from_mono_type (type->type);
3963 if (name != NULL) {
3964 propname = mono_string_to_utf8 (name);
3965 compare_func = (ignore_case) ? g_strcasecmp : strcmp;
3966 }
3967
3968 mono_class_setup_vtable (klass);
3969
3970 properties = g_hash_table_new (property_hash, (GEqualFunc)property_equal);
3971 handle_parent:
3972 mono_class_setup_vtable (klass);
3973 if (klass->exception_type != MONO_EXCEPTION_NONE) {
3974 g_hash_table_destroy (properties);
3975 if (name != NULL)
3976 g_free (propname);
3977 mono_raise_exception (mono_class_get_exception_for_failure (klass));
3978 }
3979
3980 iter = NULL;
3981 while ((prop = mono_class_get_properties (klass, &iter))) {
3982 match = 0;
3983 method = prop->get;
3984 if (!method)
3985 method = prop->set;
3986 if (method)
3987 flags = method->flags;
3988 else
3989 flags = 0;
3990 if ((prop->get && ((prop->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC)) ||
3991 (prop->set && ((prop->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC))) {
3992 if (bflags & BFLAGS_Public)
3993 match++;
3994 } else if (bflags & BFLAGS_NonPublic) {
3995 if (property_accessor_nonpublic(prop->get, startklass == klass) ||
3996 property_accessor_nonpublic(prop->set, startklass == klass)) {
3997 match++;
3998 }
3999 }
4000 if (!match)
4001 continue;
4002 match = 0;
4003 if (flags & METHOD_ATTRIBUTE_STATIC) {
4004 if (bflags & BFLAGS_Static)
4005 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
4006 match++;
4007 } else {
4008 if (bflags & BFLAGS_Instance)
4009 match++;
4010 }
4011
4012 if (!match)
4013 continue;
4014 match = 0;
4015
4016 if (name != NULL) {
4017 if (compare_func (propname, prop->name))
4018 continue;
4019 }
4020
4021 if (g_hash_table_lookup (properties, prop))
4022 continue;
4023
4024 mono_ptr_array_append (tmp_array, mono_property_get_object (domain, startklass, prop));
4025
4026 g_hash_table_insert (properties, prop, prop);
4027 }
4028 if ((!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)))
4029 goto handle_parent;
4030
4031 g_hash_table_destroy (properties);
4032 g_free (propname);
4033
4034 res = mono_array_new_cached (domain, System_Reflection_PropertyInfo, mono_ptr_array_size (tmp_array));
4035 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4036 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4037
4038 mono_ptr_array_destroy (tmp_array);
4039
4040 return res;
4041 }
4042
4043 static MonoReflectionEvent *
4044 ves_icall_MonoType_GetEvent (MonoReflectionType *type, MonoString *name, guint32 bflags)
4045 {
4046 MonoDomain *domain;
4047 MonoClass *klass, *startklass;
4048 gpointer iter;
4049 MonoEvent *event;
4050 MonoMethod *method;
4051 gchar *event_name;
4052
4053 MONO_ARCH_SAVE_REGS;
4054
4055 event_name = mono_string_to_utf8 (name);
4056 if (type->type->byref)
4057 return NULL;
4058 klass = startklass = mono_class_from_mono_type (type->type);
4059 domain = mono_object_domain (type);
4060
4061 handle_parent:
4062 if (klass->exception_type != MONO_EXCEPTION_NONE)
4063 mono_raise_exception (mono_class_get_exception_for_failure (klass));
4064
4065 iter = NULL;
4066 while ((event = mono_class_get_events (klass, &iter))) {
4067 if (strcmp (event->name, event_name))
4068 continue;
4069
4070 method = event->add;
4071 if (!method)
4072 method = event->remove;
4073 if (!method)
4074 method = event->raise;
4075 if (method) {
4076 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
4077 if (!(bflags & BFLAGS_Public))
4078 continue;
4079 } else {
4080 if (!(bflags & BFLAGS_NonPublic))
4081 continue;
4082 if ((klass != startklass) && (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PRIVATE)
4083 continue;
4084 }
4085 }
4086 else
4087 if (!(bflags & BFLAGS_NonPublic))
4088 continue;
4089
4090 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
4091 if (!(bflags & BFLAGS_Static))
4092 continue;
4093 if (!(bflags & BFLAGS_FlattenHierarchy) && (klass != startklass))
4094 continue;
4095 } else {
4096 if (!(bflags & BFLAGS_Instance))
4097 continue;
4098 }
4099
4100 g_free (event_name);
4101 return mono_event_get_object (domain, startklass, event);
4102 }
4103
4104 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
4105 goto handle_parent;
4106
4107 g_free (event_name);
4108 return NULL;
4109 }
4110
4111 static MonoArray*
4112 ves_icall_Type_GetEvents_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
4113 {
4114 MonoDomain *domain;
4115 static MonoClass *System_Reflection_EventInfo;
4116 MonoClass *startklass, *klass;
4117 MonoArray *res;
4118 MonoMethod *method;
4119 MonoEvent *event;
4120 int i, match;
4121 gpointer iter;
4122
4123 MonoPtrArray tmp_array;
4124
4125 MONO_ARCH_SAVE_REGS;
4126
4127 mono_ptr_array_init (tmp_array, 4);
4128
4129 if (!System_Reflection_EventInfo)
4130 System_Reflection_EventInfo = mono_class_from_name (
4131 mono_defaults.corlib, "System.Reflection", "EventInfo");
4132
4133 domain = mono_object_domain (type);
4134 if (type->type->byref)
4135 return mono_array_new_cached (domain, System_Reflection_EventInfo, 0);
4136 klass = startklass = mono_class_from_mono_type (type->type);
4137
4138 handle_parent:
4139 if (klass->exception_type != MONO_EXCEPTION_NONE)
4140 mono_raise_exception (mono_class_get_exception_for_failure (klass));
4141
4142 iter = NULL;
4143 while ((event = mono_class_get_events (klass, &iter))) {
4144 match = 0;
4145 method = event->add;
4146 if (!method)
4147 method = event->remove;
4148 if (!method)
4149 method = event->raise;
4150 if (method) {
4151 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
4152 if (bflags & BFLAGS_Public)
4153 match++;
4154 } else if ((klass == startklass) || (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) {
4155 if (bflags & BFLAGS_NonPublic)
4156 match++;
4157 }
4158 }
4159 else
4160 if (bflags & BFLAGS_NonPublic)
4161 match ++;
4162 if (!match)
4163 continue;
4164 match = 0;
4165 if (method) {
4166 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
4167 if (bflags & BFLAGS_Static)
4168 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
4169 match++;
4170 } else {
4171 if (bflags & BFLAGS_Instance)
4172 match++;
4173 }
4174 }
4175 else
4176 if (bflags & BFLAGS_Instance)
4177 match ++;
4178 if (!match)
4179 continue;
4180 mono_ptr_array_append (tmp_array, mono_event_get_object (domain, startklass, event));
4181 }
4182 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
4183 goto handle_parent;
4184
4185 res = mono_array_new_cached (domain, System_Reflection_EventInfo, mono_ptr_array_size (tmp_array));
4186
4187 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4188 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4189
4190 mono_ptr_array_destroy (tmp_array);
4191
4192 return res;
4193 }
4194
4195 static MonoReflectionType *
4196 ves_icall_Type_GetNestedType (MonoReflectionType *type, MonoString *name, guint32 bflags)
4197 {
4198 MonoDomain *domain;
4199 MonoClass *klass;
4200 MonoClass *nested;
4201 char *str;
4202 gpointer iter;
4203
4204 MONO_ARCH_SAVE_REGS;
4205
4206 domain = ((MonoObject *)type)->vtable->domain;
4207 if (type->type->byref)
4208 return NULL;
4209 klass = mono_class_from_mono_type (type->type);
4210 str = mono_string_to_utf8 (name);
4211
4212 handle_parent:
4213 if (klass->exception_type != MONO_EXCEPTION_NONE)
4214 mono_raise_exception (mono_class_get_exception_for_failure (klass));
4215
4216 /*
4217 * If a nested type is generic, return its generic type definition.
4218 * Note that this means that the return value is essentially a
4219 * nested type of the generic type definition of @klass.
4220 *
4221 * A note in MSDN claims that a generic type definition can have
4222 * nested types that aren't generic. In any case, the container of that
4223 * nested type would be the generic type definition.
4224 */
4225 if (klass->generic_class)
4226 klass = klass->generic_class->container_class;
4227
4228 iter = NULL;
4229 while ((nested = mono_class_get_nested_types (klass, &iter))) {
4230 int match = 0;
4231 if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) {
4232 if (bflags & BFLAGS_Public)
4233 match++;
4234 } else {
4235 if (bflags & BFLAGS_NonPublic)
4236 match++;
4237 }
4238 if (!match)
4239 continue;
4240 if (strcmp (nested->name, str) == 0){
4241 g_free (str);
4242 return mono_type_get_object (domain, &nested->byval_arg);
4243 }
4244 }
4245 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
4246 goto handle_parent;
4247 g_free (str);
4248 return NULL;
4249 }
4250
4251 static MonoArray*
4252 ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags)
4253 {
4254 MonoDomain *domain;
4255 MonoClass *klass;
4256 MonoArray *res;
4257 MonoObject *member;
4258 int i, match;
4259 MonoClass *nested;
4260 gpointer iter;
4261 MonoPtrArray tmp_array;
4262
4263 MONO_ARCH_SAVE_REGS;
4264
4265 domain = ((MonoObject *)type)->vtable->domain;
4266 if (type->type->byref)
4267 return mono_array_new (domain, mono_defaults.monotype_class, 0);
4268 klass = mono_class_from_mono_type (type->type);
4269 if (klass->exception_type != MONO_EXCEPTION_NONE)
4270 mono_raise_exception (mono_class_get_exception_for_failure (klass));
4271
4272 /*
4273 * If a nested type is generic, return its generic type definition.
4274 * Note that this means that the return value is essentially the set
4275 * of nested types of the generic type definition of @klass.
4276 *
4277 * A note in MSDN claims that a generic type definition can have
4278 * nested types that aren't generic. In any case, the container of that
4279 * nested type would be the generic type definition.
4280 */
4281 if (klass->generic_class)
4282 klass = klass->generic_class->container_class;
4283
4284 mono_ptr_array_init (tmp_array, 1);
4285 iter = NULL;
4286 while ((nested = mono_class_get_nested_types (klass, &iter))) {
4287 match = 0;
4288 if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) {
4289 if (bflags & BFLAGS_Public)
4290 match++;
4291 } else {
4292 if (bflags & BFLAGS_NonPublic)
4293 match++;
4294 }
4295 if (!match)
4296 continue;
4297 member = (MonoObject*)mono_type_get_object (domain, &nested->byval_arg);
4298 mono_ptr_array_append (tmp_array, member);
4299 }
4300
4301 res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array));
4302
4303 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4304 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4305
4306 mono_ptr_array_destroy (tmp_array);
4307
4308 return res;
4309 }
4310
4311 static MonoReflectionType*
4312 ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
4313 {
4314 gchar *str;
4315 MonoType *type = NULL;
4316 MonoTypeNameParse info;
4317 gboolean type_resolve;
4318
4319 MONO_ARCH_SAVE_REGS;
4320
4321 /* On MS.NET, this does not fire a TypeResolve event */
4322 type_resolve = TRUE;
4323 str = mono_string_to_utf8 (name);
4324 /*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
4325 if (!mono_reflection_parse_type (str, &info)) {
4326 g_free (str);
4327 mono_reflection_free_type_info (&info);
4328 if (throwOnError) /* uhm: this is a parse error, though... */
4329 mono_raise_exception (mono_get_exception_type_load (name, NULL));
4330 /*g_print ("failed parse\n");*/
4331 return NULL;
4332 }
4333
4334 if (info.assembly.name) {
4335 g_free (str);
4336 mono_reflection_free_type_info (&info);
4337 if (throwOnError) {
4338 /* 1.0 and 2.0 throw different exceptions */
4339 if (mono_defaults.generic_ilist_class)
4340 mono_raise_exception (mono_get_exception_argument (NULL, "Type names passed to Assembly.GetType() must not specify an assembly."));
4341 else
4342 mono_raise_exception (mono_get_exception_type_load (name, NULL));
4343 }
4344 return NULL;
4345 }
4346
4347 if (module != NULL) {
4348 if (module->image)
4349 type = mono_reflection_get_type (module->image, &info, ignoreCase, &type_resolve);
4350 else
4351 type = NULL;
4352 }
4353 else
4354 if (assembly->assembly->dynamic) {
4355 /* Enumerate all modules */
4356 MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)assembly;
4357 int i;
4358
4359 type = NULL;
4360 if (abuilder->modules) {
4361 for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
4362 MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
4363 type = mono_reflection_get_type (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve);
4364 if (type)
4365 break;
4366 }
4367 }
4368
4369 if (!type && abuilder->loaded_modules) {
4370 for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
4371 MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
4372 type = mono_reflection_get_type (mod->image, &info, ignoreCase, &type_resolve);
4373 if (type)
4374 break;
4375 }
4376 }
4377 }
4378 else
4379 type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase, &type_resolve);
4380 g_free (str);
4381 mono_reflection_free_type_info (&info);
4382 if (!type) {
4383 MonoException *e = NULL;
4384
4385 if (throwOnError)
4386 e = mono_get_exception_type_load (name, NULL);
4387
4388 mono_loader_clear_error ();
4389
4390 if (e != NULL)
4391 mono_raise_exception (e);
4392
4393 return NULL;
4394 }
4395
4396 if (type->type == MONO_TYPE_CLASS) {
4397 MonoClass *klass = mono_type_get_class (type);
4398
4399 if (mono_is_security_manager_active () && !klass->exception_type)
4400 /* Some security problems are detected during generic vtable construction */
4401 mono_class_setup_vtable (klass);
4402 /* need to report exceptions ? */
4403 if (throwOnError && klass->exception_type) {
4404 /* report SecurityException (or others) that occured when loading the assembly */
4405 MonoException *exc = mono_class_get_exception_for_failure (klass);
4406 mono_loader_clear_error ();
4407 mono_raise_exception (exc);
4408 } else if (klass->exception_type == MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND) {
4409 return NULL;
4410 }
4411 }
4412
4413 /* g_print ("got it\n"); */
4414 return mono_type_get_object (mono_object_domain (assembly), type);
4415 }
4416
4417 static gboolean
4418 replace_shadow_path (MonoDomain *domain, gchar *dirname, gchar **filename)
4419 {
4420 gchar *content;
4421 gchar *shadow_ini_file;
4422 gsize len;
4423
4424 /* Check for shadow-copied assembly */
4425 if (mono_is_shadow_copy_enabled (domain, dirname)) {
4426 shadow_ini_file = g_build_filename (dirname, "__AssemblyInfo__.ini", NULL);
4427 content = NULL;
4428 if (!g_file_get_contents (shadow_ini_file, &content, &len, NULL) ||
4429 !g_file_test (content, G_FILE_TEST_IS_REGULAR)) {
4430 if (content) {
4431 g_free (content);
4432 content = NULL;
4433 }
4434 }
4435 g_free (shadow_ini_file);
4436 if (content != NULL) {
4437 if (*filename)
4438 g_free (*filename);
4439 *filename = content;
4440 return TRUE;
4441 }
4442 }
4443 return FALSE;
4444 }
4445
4446 static MonoString *
4447 ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly, MonoBoolean escaped)
4448 {
4449 MonoDomain *domain = mono_object_domain (assembly);
4450 MonoAssembly *mass = assembly->assembly;
4451 MonoString *res = NULL;
4452 gchar *uri;
4453 gchar *absolute;
4454 gchar *dirname;
4455
4456 MONO_ARCH_SAVE_REGS;
4457
4458 if (g_path_is_absolute (mass->image->name)) {
4459 absolute = g_strdup (mass->image->name);
4460 dirname = g_path_get_dirname (absolute);
4461 } else {
4462 absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
4463 dirname = g_strdup (mass->basedir);
4464 }
4465
4466 replace_shadow_path (domain, dirname, &absolute);
4467 g_free (dirname);
4468 #if PLATFORM_WIN32
4469 {
4470 gint i;
4471 for (i = strlen (absolute) - 1; i >= 0; i--)
4472 if (absolute [i] == '\\')
4473 absolute [i] = '/';
4474 }
4475 #endif
4476 if (escaped) {
4477 uri = g_filename_to_uri (absolute, NULL, NULL);
4478 } else {
4479 const char *prepend = "file://";
4480 #if PLATFORM_WIN32
4481 if (*absolute == '/' && *(absolute + 1) == '/') {
4482 prepend = "file:";
4483 } else {
4484 prepend = "file:///";
4485 }
4486 #endif
4487 uri = g_strconcat (prepend, absolute, NULL);
4488 }
4489
4490 if (uri) {
4491 res = mono_string_new (domain, uri);
4492 g_free (uri);
4493 }
4494 g_free (absolute);
4495 return res;
4496 }
4497
4498 static MonoBoolean
4499 ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssembly *assembly)
4500 {
4501 MonoAssembly *mass = assembly->assembly;
4502
4503 MONO_ARCH_SAVE_REGS;
4504
4505 return mass->in_gac;
4506 }
4507
4508 static MonoReflectionAssembly*
4509 ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
4510 {
4511 gchar *name;
4512 MonoAssembly *res;
4513 MonoImageOpenStatus status;
4514
4515 MONO_ARCH_SAVE_REGS;
4516
4517 name = mono_string_to_utf8 (mname);
4518 res = mono_assembly_load_with_partial_name (name, &status);
4519
4520 g_free (name);
4521
4522 if (res == NULL)
4523 return NULL;
4524 return mono_assembly_get_object (mono_domain_get (), res);
4525 }
4526
4527 static MonoString *
4528 ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly)
4529 {
4530 MonoDomain *domain = mono_object_domain (assembly);
4531 MonoString *res;
4532
4533 MONO_ARCH_SAVE_REGS;
4534
4535 res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image));
4536
4537 return res;
4538 }
4539
4540 static MonoBoolean
4541 ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly)
4542 {
4543 MONO_ARCH_SAVE_REGS;
4544
4545 return assembly->assembly->ref_only;
4546 }
4547
4548 static MonoString *
4549 ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly *assembly)
4550 {
4551 MonoDomain *domain = mono_object_domain (assembly);
4552
4553 MONO_ARCH_SAVE_REGS;
4554
4555 return mono_string_new (domain, assembly->assembly->image->version);
4556 }
4557
4558 static MonoReflectionMethod*
4559 ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
4560 {
4561 guint32 token = mono_image_get_entry_point (assembly->assembly->image);
4562
4563 MONO_ARCH_SAVE_REGS;
4564
4565 if (!token)
4566 return NULL;
4567 return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL);
4568 }
4569
4570 static MonoReflectionModule*
4571 ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly)
4572 {
4573 return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image);
4574 }
4575
4576 static MonoArray*
4577 ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
4578 {
4579 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4580 MonoArray *result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows);
4581 int i;
4582 const char *val;
4583
4584 MONO_ARCH_SAVE_REGS;
4585
4586 for (i = 0; i < table->rows; ++i) {
4587 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
4588 mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val));
4589 }
4590 return result;
4591 }
4592
4593 static MonoObject*
4594 create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
4595 {
4596 static MonoClass *System_Version = NULL;
4597 static MonoMethod *create_version = NULL;
4598 MonoObject *result;
4599 gpointer args [4];
4600
4601 if (!System_Version) {
4602 System_Version = mono_class_from_name (mono_defaults.corlib, "System", "Version");
4603 g_assert (System_Version);
4604 }
4605
4606 if (!create_version) {
4607 MonoMethodDesc *desc = mono_method_desc_new (":.ctor(int,int,int,int)", FALSE);
4608 create_version = mono_method_desc_search_in_class (desc, System_Version);
4609 g_assert (create_version);
4610 mono_method_desc_free (desc);
4611 }
4612
4613 args [0] = &major;
4614 args [1] = &minor;
4615 args [2] = &build;
4616 args [3] = &revision;
4617 result = mono_object_new (domain, System_Version);
4618 mono_runtime_invoke (create_version, result, args, NULL);
4619
4620 return result;
4621 }
4622
4623 static MonoArray*
4624 ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
4625 {
4626 static MonoClass *System_Reflection_AssemblyName;
4627 MonoArray *result;
4628 MonoDomain *domain = mono_object_domain (assembly);
4629 int i, count = 0;
4630 static MonoMethod *create_culture = NULL;
4631 MonoImage *image = assembly->assembly->image;
4632 MonoTableInfo *t;
4633
4634 MONO_ARCH_SAVE_REGS;
4635
4636 if (!System_Reflection_AssemblyName)
4637 System_Reflection_AssemblyName = mono_class_from_name (
4638 mono_defaults.corlib, "System.Reflection", "AssemblyName");
4639
4640 t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF];
4641 count = t->rows;
4642
4643 result = mono_array_new (domain, System_Reflection_AssemblyName, count);
4644
4645 if (count > 0 && !create_culture) {
4646 MonoMethodDesc *desc = mono_method_desc_new (
4647 "System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE);
4648 create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib);
4649 g_assert (create_culture);
4650 mono_method_desc_free (desc);
4651 }
4652
4653 for (i = 0; i < count; i++) {
4654 MonoReflectionAssemblyName *aname;
4655 guint32 cols [MONO_ASSEMBLYREF_SIZE];
4656
4657 mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
4658
4659 aname = (MonoReflectionAssemblyName *) mono_object_new (
4660 domain, System_Reflection_AssemblyName);
4661
4662 MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
4663
4664 aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
4665 aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
4666 aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER];
4667 aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER];
4668 aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
4669 aname->versioncompat = 1; /* SameMachine (default) */
4670 aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
4671 MONO_OBJECT_SETREF (aname, version, create_version (domain, aname->major, aname->minor, aname->build, aname->revision));
4672
4673 if (create_culture) {
4674 gpointer args [2];
4675 MonoBoolean assembly_ref = 1;
4676 args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]));
4677 args [1] = &assembly_ref;
4678 MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
4679 }
4680
4681 if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
4682 const gchar *pkey_ptr = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]);
4683 guint32 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
4684
4685 if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) {
4686 /* public key token isn't copied - the class library will
4687 automatically generate it from the public key if required */
4688 MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
4689 memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
4690 } else {
4691 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
4692 memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len);
4693 }
4694 } else {
4695 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
4696 }
4697
4698 /* note: this function doesn't return the codebase on purpose (i.e. it can
4699 be used under partial trust as path information isn't present). */
4700
4701 mono_array_setref (result, i, aname);
4702 }
4703 return result;
4704 }
4705
4706 typedef struct {
4707 MonoArray *res;
4708 int idx;
4709 } NameSpaceInfo;
4710
4711 static void
4712 foreach_namespace (const char* key, gconstpointer val, NameSpaceInfo *info)
4713 {
4714 MonoString *name = mono_string_new (mono_object_domain (info->res), key);
4715
4716 mono_array_setref (info->res, info->idx, name);
4717 info->idx++;
4718 }
4719
4720 static MonoArray*
4721 ves_icall_System_Reflection_Assembly_GetNamespaces (MonoReflectionAssembly *assembly)
4722 {
4723 MonoImage *img = assembly->assembly->image;
4724 MonoArray *res;
4725 NameSpaceInfo info;
4726
4727 MONO_ARCH_SAVE_REGS;
4728
4729 if (!img->name_cache)
4730 mono_image_init_name_cache (img);
4731
4732 res = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, g_hash_table_size (img->name_cache));
4733 info.res = res;
4734 info.idx = 0;
4735 g_hash_table_foreach (img->name_cache, (GHFunc)foreach_namespace, &info);
4736
4737 return res;
4738 }
4739
4740 /* move this in some file in mono/util/ */
4741 static char *
4742 g_concat_dir_and_file (const char *dir, const char *file)
4743 {
4744 g_return_val_if_fail (dir != NULL, NULL);
4745 g_return_val_if_fail (file != NULL, NULL);
4746
4747 /*
4748 * If the directory name doesn't have a / on the end, we need
4749 * to add one so we get a proper path to the file
4750 */
4751 if (dir [strlen(dir) - 1] != G_DIR_SEPARATOR)
4752 return g_strconcat (dir, G_DIR_SEPARATOR_S, file, NULL);
4753 else
4754 return g_strconcat (dir, file, NULL);
4755 }
4756
4757 static void *
4758 ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
4759 {
4760 char *n = mono_string_to_utf8 (name);
4761 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4762 guint32 i;
4763 guint32 cols [MONO_MANIFEST_SIZE];
4764 guint32 impl, file_idx;
4765 const char *val;
4766 MonoImage *module;
4767
4768 MONO_ARCH_SAVE_REGS;
4769
4770 for (i = 0; i < table->rows; ++i) {
4771 mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
4772 val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
4773 if (strcmp (val, n) == 0)
4774 break;
4775 }
4776 g_free (n);
4777 if (i == table->rows)
4778 return NULL;
4779 /* FIXME */
4780 impl = cols [MONO_MANIFEST_IMPLEMENTATION];
4781 if (impl) {
4782 /*
4783 * this code should only be called after obtaining the
4784 * ResourceInfo and handling the other cases.
4785 */
4786 g_assert ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE);
4787 file_idx = impl >> MONO_IMPLEMENTATION_BITS;
4788
4789 module = mono_image_load_file_for_image (assembly->assembly->image, file_idx);
4790 if (!module)
4791 return NULL;
4792 }
4793 else
4794 module = assembly->assembly->image;
4795
4796 *ref_module = mono_module_get_object (mono_domain_get (), module);
4797
4798 return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
4799 }
4800
4801 static gboolean
4802 ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info)
4803 {
4804 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4805 int i;
4806 guint32 cols [MONO_MANIFEST_SIZE];
4807 guint32 file_cols [MONO_FILE_SIZE];
4808 const char *val;
4809 char *n;
4810
4811 MONO_ARCH_SAVE_REGS;
4812
4813 n = mono_string_to_utf8 (name);
4814 for (i = 0; i < table->rows; ++i) {
4815 mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
4816 val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
4817 if (strcmp (val, n) == 0)
4818 break;
4819 }
4820 g_free (n);
4821 if (i == table->rows)
4822 return FALSE;
4823
4824 if (!cols [MONO_MANIFEST_IMPLEMENTATION]) {
4825 info->location = RESOURCE_LOCATION_EMBEDDED | RESOURCE_LOCATION_IN_MANIFEST;
4826 }
4827 else {
4828 switch (cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) {
4829 case MONO_IMPLEMENTATION_FILE:
4830 i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
4831 table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
4832 mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE);
4833 val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]);
4834 MONO_OBJECT_SETREF (info, filename, mono_string_new (mono_object_domain (assembly), val));
4835 if (file_cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
4836 info->location = 0;
4837 else
4838 info->location = RESOURCE_LOCATION_EMBEDDED;
4839 break;
4840
4841 case MONO_IMPLEMENTATION_ASSEMBLYREF:
4842 i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
4843 mono_assembly_load_reference (assembly->assembly->image, i - 1);
4844 if (assembly->assembly->image->references [i - 1] == (gpointer)-1) {
4845 char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name);
4846 MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL);
4847 g_free (msg);
4848 mono_raise_exception (ex);
4849 }
4850 MONO_OBJECT_SETREF (info, assembly, mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1]));
4851
4852 /* Obtain info recursively */
4853 ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info);
4854 info->location |= RESOURCE_LOCATION_ANOTHER_ASSEMBLY;
4855 break;
4856
4857 case MONO_IMPLEMENTATION_EXP_TYPE:
4858 g_assert_not_reached ();
4859 break;
4860 }
4861 }
4862
4863 return TRUE;
4864 }
4865
4866 static MonoObject*
4867 ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
4868 {
4869 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
4870 MonoArray *result = NULL;
4871 int i, count;
4872 const char *val;
4873 char *n;
4874
4875 MONO_ARCH_SAVE_REGS;
4876
4877 /* check hash if needed */
4878 if (name) {
4879 n = mono_string_to_utf8 (name);
4880 for (i = 0; i < table->rows; ++i) {
4881 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
4882 if (strcmp (val, n) == 0) {
4883 MonoString *fn;
4884 g_free (n);
4885 n = g_concat_dir_and_file (assembly->assembly->basedir, val);
4886 fn = mono_string_new (mono_object_domain (assembly), n);
4887 g_free (n);
4888 return (MonoObject*)fn;
4889 }
4890 }
4891 g_free (n);
4892 return NULL;
4893 }
4894
4895 count = 0;
4896 for (i = 0; i < table->rows; ++i) {
4897 if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA))
4898 count ++;
4899 }
4900
4901 result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, count);
4902
4903 count = 0;
4904 for (i = 0; i < table->rows; ++i) {
4905 if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
4906 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
4907 n = g_concat_dir_and_file (assembly->assembly->basedir, val);
4908 mono_array_setref (result, count, mono_string_new (mono_object_domain (assembly), n));
4909 g_free (n);
4910 count ++;
4911 }
4912 }
4913 return (MonoObject*)result;
4914 }
4915
4916 static MonoArray*
4917 ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly)
4918 {
4919 MonoDomain *domain = mono_domain_get();
4920 MonoArray *res;
4921 MonoClass *klass;
4922 int i, j, file_count = 0;
4923 MonoImage **modules;
4924 guint32 module_count, real_module_count;
4925 MonoTableInfo *table;
4926 guint32 cols [MONO_FILE_SIZE];
4927 MonoImage *image = assembly->assembly->image;
4928
4929 g_assert (image != NULL);
4930 g_assert (!assembly->assembly->dynamic);
4931
4932 table = &image->tables [MONO_TABLE_FILE];
4933 file_count = table->rows;
4934
4935 modules = image->modules;
4936 module_count = image->module_count;
4937
4938 real_module_count = 0;
4939 for (i = 0; i < module_count; ++i)
4940 if (modules [i])
4941 real_module_count ++;
4942
4943 klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module");
4944 res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
4945
4946 mono_array_setref (res, 0, mono_module_get_object (domain, image));
4947 j = 1;
4948 for (i = 0; i < module_count; ++i)
4949 if (modules [i]) {
4950 mono_array_setref (res, j, mono_module_get_object (domain, modules[i]));
4951 ++j;
4952 }
4953
4954 for (i = 0; i < file_count; ++i, ++j) {
4955 mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE);
4956 if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
4957 mono_array_setref (res, j, mono_module_file_get_object (domain, image, i));
4958 else {
4959 MonoImage *m = mono_image_load_file_for_image (image, i + 1);
4960 if (!m) {
4961 MonoString *fname = mono_string_new (mono_domain_get (), mono_metadata_string_heap (image, cols [MONO_FILE_NAME]));
4962 mono_raise_exception (mono_get_exception_file_not_found2 (NULL, fname));
4963 }
4964 mono_array_setref (res, j, mono_module_get_object (domain, m));
4965 }
4966 }
4967
4968 return res;
4969 }
4970
4971 static MonoReflectionMethod*
4972 ves_icall_GetCurrentMethod (void)
4973 {
4974 MonoMethod *m = mono_method_get_last_managed ();
4975
4976 MONO_ARCH_SAVE_REGS;
4977
4978 return mono_method_get_object (mono_domain_get (), m, NULL);
4979 }
4980
4981
4982 static MonoMethod*
4983 mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass)
4984 {
4985 int offset = -1, i;
4986 if (method->is_inflated && ((MonoMethodInflated*)method)->context.method_inst) {
4987 MonoMethodInflated *inflated = (MonoMethodInflated*)method;
4988 //method is inflated, we should inflate it on the other class
4989 MonoGenericContext ctx;
4990 ctx.method_inst = inflated->context.method_inst;
4991 ctx.class_inst = inflated->context.class_inst;
4992 if (klass->generic_class)
4993 ctx.class_inst = klass->generic_class->context.class_inst;
4994 else if (klass->generic_container)
4995 ctx.class_inst = klass->generic_container->context.class_inst;
4996 return mono_class_inflate_generic_method_full (inflated->declaring, klass, &ctx);
4997 }
4998
4999 mono_class_setup_methods (method->klass);
5000 for (i = 0; i < method->klass->method.count; ++i) {
5001 if (method->klass->methods [i] == method) {
5002 offset = i;
5003 break;
5004 }
5005 }
5006 mono_class_setup_methods (klass);
5007 g_assert (offset >= 0 && offset < klass->method.count);
5008 return klass->methods [offset];
5009 }
5010
5011 static MonoReflectionMethod*
5012 ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
5013 {
5014 MonoClass *klass;
5015 if (type) {
5016 klass = mono_class_from_mono_type (type);
5017 if (mono_class_get_generic_type_definition (method->klass) != mono_class_get_generic_type_definition (klass))
5018 return NULL;
5019 if (method->klass != klass)
5020 method = mono_method_get_equivalent_method (method, klass);
5021 } else
5022 klass = method->klass;
5023 return mono_method_get_object (mono_domain_get (), method, klass);
5024 }
5025
5026 static MonoReflectionMethod*
5027 ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod *method)
5028 {
5029 return mono_method_get_object (mono_domain_get (), method, NULL);
5030 }
5031
5032 static MonoReflectionMethodBody*
5033 ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
5034 {
5035 return mono_method_body_get_object (mono_domain_get (), method);
5036 }
5037
5038 static MonoReflectionAssembly*
5039 ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
5040 {
5041 MonoMethod *dest = NULL;
5042
5043 MONO_ARCH_SAVE_REGS;
5044
5045 mono_stack_walk_no_il (get_executing, &dest);
5046 return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
5047 }
5048
5049
5050 static MonoReflectionAssembly*
5051 ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
5052 {
5053 MonoDomain* domain = mono_domain_get ();
5054
5055 MONO_ARCH_SAVE_REGS;
5056
5057 if (!domain->entry_assembly)
5058 return NULL;
5059
5060 return mono_assembly_get_object (domain, domain->entry_assembly);
5061 }
5062
5063 static MonoReflectionAssembly*
5064 ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
5065 {
5066 MonoMethod *m;
5067 MonoMethod *dest;
5068
5069 MONO_ARCH_SAVE_REGS;
5070
5071 dest = NULL;
5072 mono_stack_walk_no_il (get_executing, &dest);
5073 m = dest;
5074 mono_stack_walk_no_il (get_caller, &dest);
5075 if (!dest)
5076 dest = m;
5077 return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
5078 }
5079
5080 static MonoString *
5081 ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
5082 gboolean assembly_qualified)
5083 {
5084 MonoDomain *domain = mono_object_domain (object);
5085 MonoTypeNameFormat format;
5086 MonoString *res;
5087 gchar *name;
5088
5089 MONO_ARCH_SAVE_REGS;
5090 if (full_name)
5091 format = assembly_qualified ?
5092 MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED :
5093 MONO_TYPE_NAME_FORMAT_FULL_NAME;
5094 else
5095 format = MONO_TYPE_NAME_FORMAT_REFLECTION;
5096
5097 name = mono_type_get_name_full (object->type, format);
5098 if (!name)
5099 return NULL;
5100
5101 if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR)) {
5102 g_free (name);
5103 return NULL;
5104 }
5105
5106 res = mono_string_new (domain, name);
5107 g_free (name);
5108
5109 return res;
5110 }
5111
5112 static void
5113 fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
5114 {
5115 static MonoMethod *create_culture = NULL;
5116 gpointer args [2];
5117 guint32 pkey_len;
5118 const char *pkey_ptr;
5119 gchar *codebase;
5120 MonoBoolean assembly_ref = 0;
5121
5122 MONO_ARCH_SAVE_REGS;
5123
5124 MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
5125 aname->major = name->major;
5126 aname->minor = name->minor;
5127 aname->build = name->build;
5128 aname->flags = name->flags;
5129 aname->revision = name->revision;
5130 aname->hashalg = name->hash_alg;
5131 aname->versioncompat = 1; /* SameMachine (default) */
5132
5133 if (by_default_version)
5134 MONO_OBJECT_SETREF (aname, version, create_version (domain, name->major, name->minor, name->build, name->revision));
5135
5136 codebase = NULL;
5137 if (absolute != NULL && *absolute != '\0') {
5138 const gchar *prepend = "file://";
5139 gchar *result;
5140
5141 codebase = g_strdup (absolute);
5142
5143 #if PLATFORM_WIN32
5144 {
5145 gint i;
5146 for (i = strlen (codebase) - 1; i >= 0; i--)
5147 if (codebase [i] == '\\')
5148 codebase [i] = '/';
5149
5150 if (*codebase == '/' && *(codebase + 1) == '/') {
5151 prepend = "file:";
5152 } else {
5153 prepend = "file:///";
5154 }
5155 }
5156 #endif
5157 result = g_strconcat (prepend, codebase, NULL);
5158 g_free (codebase);
5159 codebase = result;
5160 }
5161
5162 if (codebase) {
5163 MONO_OBJECT_SETREF (aname, codebase, mono_string_new (domain, codebase));
5164 g_free (codebase);
5165 }
5166
5167 if (!create_culture) {
5168 MonoMethodDesc *desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE);
5169 create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib);
5170 g_assert (create_culture);
5171 mono_method_desc_free (desc);
5172 }
5173
5174 if (name->culture) {
5175 args [0] = mono_string_new (domain, name->culture);
5176 args [1] = &assembly_ref;
5177 MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL));
5178 }
5179
5180 if (name->public_key) {
5181 pkey_ptr = (char*)name->public_key;
5182 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
5183
5184 MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
5185 memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
5186 aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
5187 } else if (default_publickey) {
5188 MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, 0));
5189 aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
5190 }
5191
5192 /* MonoAssemblyName keeps the public key token as an hexadecimal string */
5193 if (name->public_key_token [0]) {
5194 int i, j;
5195 char *p;
5196
5197 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8));
5198 p = mono_array_addr (aname->keyToken, char, 0);
5199
5200 for (i = 0, j = 0; i < 8; i++) {
5201 *p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4;
5202 *p |= g_ascii_xdigit_value (name->public_key_token [j++]);
5203 p++;
5204 }
5205 } else if (default_token) {
5206 MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
5207 }
5208 }
5209
5210 static MonoString *
5211 ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly *assembly)
5212 {
5213 MonoDomain *domain = mono_object_domain (assembly);
5214 MonoAssembly *mass = assembly->assembly;
5215 MonoString *res;
5216 gchar *name;
5217
5218 name = g_strdup_printf (
5219 "%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
5220 mass->aname.name,
5221 mass->aname.major, mass->aname.minor, mass->aname.build, mass->aname.revision,
5222 mass->aname.culture && *mass->aname.culture? mass->aname.culture: "neutral",
5223 mass->aname.public_key_token [0] ? (char *)mass->aname.public_key_token : "null",
5224 (mass->aname.flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : "");
5225
5226 res = mono_string_new (domain, name);
5227 g_free (name);
5228
5229 return res;
5230 }
5231
5232 static void
5233 ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
5234 {
5235 gchar *absolute;
5236 MonoAssembly *mass = assembly->assembly;
5237
5238 MONO_ARCH_SAVE_REGS;
5239
5240 if (g_path_is_absolute (mass->image->name)) {
5241 fill_reflection_assembly_name (mono_object_domain (assembly),
5242 aname, &mass->aname, mass->image->name, TRUE,
5243 TRUE, mono_framework_version () >= 2);
5244 return;
5245 }
5246 absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
5247
5248 fill_reflection_assembly_name (mono_object_domain (assembly),
5249 aname, &mass->aname, absolute, TRUE, TRUE,
5250 mono_framework_version () >= 2);
5251
5252 g_free (absolute);
5253 }
5254
5255 static void
5256 ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
5257 {
5258 char *filename;
5259 MonoImageOpenStatus status = MONO_IMAGE_OK;
5260 gboolean res;
5261 MonoImage *image;
5262 MonoAssemblyName name;
5263 char *dirname
5264
5265 MONO_ARCH_SAVE_REGS;
5266
5267 filename = mono_string_to_utf8 (fname);
5268
5269 dirname = g_path_get_dirname (filename);
5270 replace_shadow_path (mono_domain_get (), dirname, &filename);
5271 g_free (dirname);
5272
5273 image = mono_image_open (filename, &status);
5274
5275 if (!image){
5276 MonoException *exc;
5277
5278 g_free (filename);
5279 if (status == MONO_IMAGE_IMAGE_INVALID)
5280 exc = mono_get_exception_bad_image_format2 (NULL, fname);
5281 else
5282 exc = mono_get_exception_file_not_found2 (NULL, fname);
5283 mono_raise_exception (exc);
5284 }
5285
5286 res = mono_assembly_fill_assembly_name (image, &name);
5287 if (!res) {
5288 mono_image_close (image);
5289 g_free (filename);
5290 mono_raise_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest"));
5291 }
5292
5293 fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename,
5294 TRUE, mono_framework_version () == 1,
5295 mono_framework_version () >= 2);
5296
5297 g_free (filename);
5298 mono_image_close (image);
5299 }
5300
5301 static MonoBoolean
5302 ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly *assembly,
5303 char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength)
5304 {
5305 MonoBoolean result = FALSE;
5306 MonoDeclSecurityEntry entry;
5307
5308 /* SecurityAction.RequestMinimum */
5309 if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQMIN, &entry)) {
5310 *minimum = entry.blob;
5311 *minLength = entry.size;
5312 result = TRUE;
5313 }
5314 /* SecurityAction.RequestOptional */
5315 if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQOPT, &entry)) {
5316 *optional = entry.blob;
5317 *optLength = entry.size;
5318 result = TRUE;
5319 }
5320 /* SecurityAction.RequestRefuse */
5321 if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQREFUSE, &entry)) {
5322 *refused = entry.blob;
5323 *refLength = entry.size;
5324 result = TRUE;
5325 }
5326
5327 return result;
5328 }
5329
5330 static MonoArray*
5331 mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly)
5332 {
5333 MonoArray *res;
5334 MonoClass *klass;
5335 MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
5336 int i, count;
5337 guint32 attrs, visibility;
5338
5339 /* we start the count from 1 because we skip the special type <Module> */
5340 if (exportedOnly) {
5341 count = 0;
5342 for (i = 1; i < tdef->rows; ++i) {
5343 attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS);
5344 visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5345 if (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)
5346 count++;
5347 }
5348 } else {
5349 count = tdef->rows - 1;
5350 }
5351 res = mono_array_new (domain, mono_defaults.monotype_class, count);
5352 *exceptions = mono_array_new (domain, mono_defaults.exception_class, count);
5353 count = 0;
5354 for (i = 1; i < tdef->rows; ++i) {
5355 attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS);
5356 visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5357 if (!exportedOnly || (visibility == TYPE_ATTRIBUTE_PUBLIC || visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)) {
5358 klass = mono_class_get (image, (i + 1) | MONO_TOKEN_TYPE_DEF);
5359 if (klass) {
5360 mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg));
5361 } else {
5362 MonoLoaderError *error;
5363 MonoException *ex;
5364
5365 error = mono_loader_get_last_error ();
5366 g_assert (error != NULL);
5367
5368 ex = mono_loader_error_prepare_exception (error);
5369 mono_array_setref (*exceptions, count, ex);
5370 }
5371 if (mono_loader_get_last_error ())
5372 mono_loader_clear_error ();
5373 count++;
5374 }
5375 }
5376
5377 return res;
5378 }
5379
5380 static MonoArray*
5381 ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
5382 {
5383 MonoArray *res = NULL;
5384 MonoArray *exceptions = NULL;
5385 MonoImage *image = NULL;
5386 MonoTableInfo *table = NULL;
5387 MonoDomain *domain;
5388 GList *list = NULL;
5389 int i, len, ex_count;
5390
5391 MONO_ARCH_SAVE_REGS;
5392
5393 domain = mono_object_domain (assembly);
5394
5395 g_assert (!assembly->assembly->dynamic);
5396 image = assembly->assembly->image;
5397 table = &image->tables [MONO_TABLE_FILE];
5398 res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
5399
5400 /* Append data from all modules in the assembly */
5401 for (i = 0; i < table->rows; ++i) {
5402 if (!(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
5403 MonoImage *loaded_image = mono_assembly_load_module (image->assembly, i + 1);
5404 if (loaded_image) {
5405 MonoArray *ex2;
5406 MonoArray *res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
5407 /* Append the new types to the end of the array */
5408 if (mono_array_length (res2) > 0) {
5409 guint32 len1, len2;
5410 MonoArray *res3, *ex3;
5411
5412 len1 = mono_array_length (res);
5413 len2 = mono_array_length (res2);
5414
5415 res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
5416 mono_array_memcpy_refs (res3, 0, res, 0, len1);
5417 mono_array_memcpy_refs (res3, len1, res2, 0, len2);
5418 res = res3;
5419
5420 ex3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
5421 mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1);
5422 mono_array_memcpy_refs (ex3, len1, ex2, 0, len2);
5423 exceptions = ex3;
5424 }
5425 }
5426 }
5427 }
5428
5429 /* the ReflectionTypeLoadException must have all the types (Types property),
5430 * NULL replacing types which throws an exception. The LoaderException must
5431 * contain all exceptions for NULL items.
5432 */
5433
5434 len = mono_array_length (res);
5435
5436 ex_count = 0;
5437 for (i = 0; i < len; i++) {
5438 MonoReflectionType *t = mono_array_get (res, gpointer, i);
5439 MonoClass *klass;
5440
5441 if (t) {
5442 klass = mono_type_get_class (t->type);
5443 if ((klass != NULL) && klass->exception_type) {
5444 /* keep the class in the list */
5445 list = g_list_append (list, klass);
5446 /* and replace Type with NULL */
5447 mono_array_setref (res, i, NULL);
5448 }
5449 } else {
5450 ex_count ++;
5451 }
5452 }
5453
5454 if (list || ex_count) {
5455 GList *tmp = NULL;
5456 MonoException *exc = NULL;
5457 MonoArray *exl = NULL;
5458 int j, length = g_list_length (list) + ex_count;
5459
5460 mono_loader_clear_error ();
5461
5462 exl = mono_array_new (domain, mono_defaults.exception_class, length);
5463 /* Types for which mono_class_get () succeeded */
5464 for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
5465 MonoException *exc = mono_class_get_exception_for_failure (tmp->data);
5466 mono_array_setref (exl, i, exc);
5467 }
5468 /* Types for which it don't */
5469 for (j = 0; j < mono_array_length (exceptions); ++j) {
5470 MonoException *exc = mono_array_get (exceptions, MonoException*, j);
5471 if (exc) {
5472 g_assert (i < length);
5473 mono_array_setref (exl, i, exc);
5474 i ++;
5475 }
5476 }
5477 g_list_free (list);
5478 list = NULL;
5479
5480 exc = mono_get_exception_reflection_type_load (res, exl);
5481 mono_loader_clear_error ();
5482 mono_raise_exception (exc);
5483 }
5484
5485 return res;
5486 }
5487
5488 static gboolean
5489 ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
5490 {
5491 MonoAssemblyName aname;
5492 MonoDomain *domain = mono_object_domain (name);
5493 char *val;
5494 gboolean is_version_defined;
5495 gboolean is_token_defined;
5496
5497 aname.public_key = NULL;
5498 val = mono_string_to_utf8 (assname);
5499 if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) {
5500 g_free ((guint8*) aname.public_key);
5501 g_free (val);
5502 return FALSE;
5503 }
5504
5505 fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined,
5506 FALSE, is_token_defined);
5507
5508 mono_assembly_name_free (&aname);
5509 g_free ((guint8*) aname.public_key);
5510 g_free (val);
5511
5512 return TRUE;
5513 }
5514
5515 static MonoReflectionType*
5516 ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
5517 {
5518 MonoDomain *domain = mono_object_domain (module);
5519 MonoClass *klass;
5520
5521 MONO_ARCH_SAVE_REGS;
5522
5523 g_assert (module->image);
5524
5525 if (module->image->dynamic && ((MonoDynamicImage*)(module->image))->initial_image)
5526 /* These images do not have a global type */
5527 return NULL;
5528
5529 klass = mono_class_get (module->image, 1 | MONO_TOKEN_TYPE_DEF);
5530 return mono_type_get_object (domain, &klass->byval_arg);
5531 }
5532
5533 static void
5534 ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module)
5535 {
5536 /*if (module->image)
5537 mono_image_close (module->image);*/
5538 }
5539
5540 static MonoString*
5541 ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module)
5542 {
5543 MonoDomain *domain = mono_object_domain (module);
5544
5545 MONO_ARCH_SAVE_REGS;
5546
5547 g_assert (module->image);
5548 return mono_string_new (domain, module->image->guid);
5549 }
5550
5551 static gpointer
5552 ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule *module)
5553 {
5554 #ifdef PLATFORM_WIN32
5555 if (module->image && module->image->is_module_handle)
5556 return module->image->raw_data;
5557 #endif
5558
5559 return (gpointer) (-1);
5560 }
5561
5562 static void
5563 ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine)
5564 {
5565 if (image->dynamic) {
5566 MonoDynamicImage *dyn = (MonoDynamicImage*)image;
5567 *pe_kind = dyn->pe_kind;
5568 *machine = dyn->machine;
5569 }
5570 else {
5571 *pe_kind = ((MonoCLIImageInfo*)(image->image_info))->cli_cli_header.ch_flags & 0x3;
5572 *machine = ((MonoCLIImageInfo*)(image->image_info))->cli_header.coff.coff_machine;
5573 }
5574 }
5575
5576 static gint32
5577 ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image)
5578 {
5579 return (image->md_version_major << 16) | (image->md_version_minor);
5580 }
5581
5582 static MonoArray*
5583 ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
5584 {
5585 MonoArray *exceptions;
5586 int i;
5587
5588 MONO_ARCH_SAVE_REGS;
5589
5590 if (!module->image)
5591 return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0);
5592 else {
5593 MonoArray *res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE);
5594 for (i = 0; i < mono_array_length (exceptions); ++i) {
5595 MonoException *ex = mono_array_get (exceptions, MonoException *, i);
5596 if (ex)
5597 mono_raise_exception (ex);
5598 }
5599 return res;
5600 }
5601 }
5602
5603 static gboolean
5604 mono_metadata_memberref_is_method (MonoImage *image, guint32 token)
5605 {
5606 guint32 cols [MONO_MEMBERREF_SIZE];
5607 const char *sig;
5608 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
5609 sig = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
5610 mono_metadata_decode_blob_size (sig, &sig);
5611 return (*sig != 0x6);
5612 }
5613
5614 static void
5615 init_generic_context_from_args (MonoGenericContext *context, MonoArray *type_args, MonoArray *method_args)
5616 {
5617 if (type_args)
5618 context->class_inst = mono_metadata_get_generic_inst (mono_array_length (type_args),
5619 mono_array_addr (type_args, MonoType*, 0));
5620 else
5621 context->class_inst = NULL;
5622 if (method_args)
5623 context->method_inst = mono_metadata_get_generic_inst (mono_array_length (method_args),
5624 mono_array_addr (method_args, MonoType*, 0));
5625 else
5626 context->method_inst = NULL;
5627 }
5628
5629 static MonoType*
5630 ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5631 {
5632 MonoClass *klass;
5633 int table = mono_metadata_token_table (token);
5634 int index = mono_metadata_token_index (token);
5635 MonoGenericContext context;
5636
5637 *error = ResolveTokenError_Other;
5638
5639 /* Validate token */
5640 if ((table != MONO_TABLE_TYPEDEF) && (table != MONO_TABLE_TYPEREF) &&
5641 (table != MONO_TABLE_TYPESPEC)) {
5642 *error = ResolveTokenError_BadTable;
5643 return NULL;
5644 }
5645
5646 if (image->dynamic) {
5647 if (type_args || method_args)
5648 mono_raise_exception (mono_get_exception_not_implemented (NULL));
5649 klass = mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5650 if (!klass)
5651 return NULL;
5652 return &klass->byval_arg;
5653 }
5654
5655 if ((index <= 0) || (index > image->tables [table].rows)) {
5656 *error = ResolveTokenError_OutOfRange;
5657 return NULL;
5658 }
5659
5660 init_generic_context_from_args (&context, type_args, method_args);
5661 klass = mono_class_get_full (image, token, &context);
5662
5663 if (mono_loader_get_last_error ())
5664 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
5665
5666 if (klass)
5667 return &klass->byval_arg;
5668 else
5669 return NULL;
5670 }
5671
5672 static MonoMethod*
5673 ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5674 {
5675 int table = mono_metadata_token_table (token);
5676 int index = mono_metadata_token_index (token);
5677 MonoGenericContext context;
5678 MonoMethod *method;
5679
5680 *error = ResolveTokenError_Other;
5681
5682 /* Validate token */
5683 if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) &&
5684 (table != MONO_TABLE_MEMBERREF)) {
5685 *error = ResolveTokenError_BadTable;
5686 return NULL;
5687 }
5688
5689 if (image->dynamic) {
5690 if (type_args || method_args)
5691 mono_raise_exception (mono_get_exception_not_implemented (NULL));
5692 /* FIXME: validate memberref token type */
5693 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5694 }
5695
5696 if ((index <= 0) || (index > image->tables [table].rows)) {
5697 *error = ResolveTokenError_OutOfRange;
5698 return NULL;
5699 }
5700 if ((table == MONO_TABLE_MEMBERREF) && (!mono_metadata_memberref_is_method (image, token))) {
5701 *error = ResolveTokenError_BadTable;
5702 return NULL;
5703 }
5704
5705 init_generic_context_from_args (&context, type_args, method_args);
5706 method = mono_get_method_full (image, token, NULL, &context);
5707
5708 if (mono_loader_get_last_error ())
5709 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
5710
5711 return method;
5712 }
5713
5714 static MonoString*
5715 ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *error)
5716 {
5717 int index = mono_metadata_token_index (token);
5718
5719 *error = ResolveTokenError_Other;
5720
5721 /* Validate token */
5722 if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
5723 *error = ResolveTokenError_BadTable;
5724 return NULL;
5725 }
5726
5727 if (image->dynamic)
5728 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5729
5730 if ((index <= 0) || (index >= image->heap_us.size)) {
5731 *error = ResolveTokenError_OutOfRange;
5732 return NULL;
5733 }
5734
5735 /* FIXME: What to do if the index points into the middle of a string ? */
5736
5737 return mono_ldstr (mono_domain_get (), image, index);
5738 }
5739
5740 static MonoClassField*
5741 ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5742 {
5743 MonoClass *klass;
5744 int table = mono_metadata_token_table (token);
5745 int index = mono_metadata_token_index (token);
5746 MonoGenericContext context;
5747 MonoClassField *field;
5748
5749 *error = ResolveTokenError_Other;
5750
5751 /* Validate token */
5752 if ((table != MONO_TABLE_FIELD) && (table != MONO_TABLE_MEMBERREF)) {
5753 *error = ResolveTokenError_BadTable;
5754 return NULL;
5755 }
5756
5757 if (image->dynamic) {
5758 if (type_args || method_args)
5759 mono_raise_exception (mono_get_exception_not_implemented (NULL));
5760 /* FIXME: validate memberref token type */
5761 return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL);
5762 }
5763
5764 if ((index <= 0) || (index > image->tables [table].rows)) {
5765 *error = ResolveTokenError_OutOfRange;
5766 return NULL;
5767 }
5768 if ((table == MONO_TABLE_MEMBERREF) && (mono_metadata_memberref_is_method (image, token))) {
5769 *error = ResolveTokenError_BadTable;
5770 return NULL;
5771 }
5772
5773 init_generic_context_from_args (&context, type_args, method_args);
5774 field = mono_field_from_token (image, token, &klass, &context);
5775
5776 if (mono_loader_get_last_error ())
5777 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
5778
5779 return field;
5780 }
5781
5782
5783 static MonoObject*
5784 ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
5785 {
5786 int table = mono_metadata_token_table (token);
5787
5788 *error = ResolveTokenError_Other;
5789
5790 switch (table) {
5791 case MONO_TABLE_TYPEDEF:
5792 case MONO_TABLE_TYPEREF:
5793 case MONO_TABLE_TYPESPEC: {
5794 MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
5795 if (t)
5796 return (MonoObject*)mono_type_get_object (mono_domain_get (), t);
5797 else
5798 return NULL;
5799 }
5800 case MONO_TABLE_METHOD:
5801 case MONO_TABLE_METHODSPEC: {
5802 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
5803 if (m)
5804 return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
5805 else
5806 return NULL;
5807 }
5808 case MONO_TABLE_FIELD: {
5809 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
5810 if (f)
5811 return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
5812 else
5813 return NULL;
5814 }
5815 case MONO_TABLE_MEMBERREF:
5816 if (mono_metadata_memberref_is_method (image, token)) {
5817 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
5818 if (m)
5819 return (MonoObject*)mono_method_get_object (mono_domain_get (), m, m->klass);
5820 else
5821 return NULL;
5822 }
5823 else {
5824 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
5825 if (f)
5826 return (MonoObject*)mono_field_get_object (mono_domain_get (), f->parent, f);
5827 else
5828 return NULL;
5829 }
5830 break;
5831
5832 default:
5833 *error = ResolveTokenError_BadTable;
5834 }
5835
5836 return NULL;
5837 }
5838
5839 static MonoArray*
5840 ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
5841 {
5842 int table = mono_metadata_token_table (token);
5843 int idx = mono_metadata_token_index (token);
5844 MonoTableInfo *tables = image->tables;
5845 guint32 sig, len;
5846 const char *ptr;
5847 MonoArray *res;
5848
5849 *error = ResolveTokenError_OutOfRange;
5850
5851 /* FIXME: Support other tables ? */
5852 if (table != MONO_TABLE_STANDALONESIG)
5853 return NULL;
5854
5855 if (image->dynamic)
5856 return NULL;
5857
5858 if ((idx == 0) || (idx > tables [MONO_TABLE_STANDALONESIG].rows))
5859 return NULL;
5860
5861 sig = mono_metadata_decode_row_col (&tables [MONO_TABLE_STANDALONESIG], idx - 1, 0);
5862
5863 ptr = mono_metadata_blob_heap (image, sig);
5864 len = mono_metadata_decode_blob_size (ptr, &ptr);
5865
5866 res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, len);
5867 memcpy (mono_array_addr (res, guint8, 0), ptr, len);
5868 return res;
5869 }
5870
5871 static MonoReflectionType*
5872 ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
5873 {
5874 MonoClass *klass;
5875 int isbyref = 0, rank;
5876 char *str = mono_string_to_utf8 (smodifiers);
5877 char *p;
5878
5879 MONO_ARCH_SAVE_REGS;
5880
5881 klass = mono_class_from_mono_type (tb->type.type);
5882 p = str;
5883 /* logic taken from mono_reflection_parse_type(): keep in sync */
5884 while (*p) {
5885 switch (*p) {
5886 case '&':
5887 if (isbyref) { /* only one level allowed by the spec */
5888 g_free (str);
5889 return NULL;
5890 }
5891 isbyref = 1;
5892 p++;
5893 g_free (str);
5894 return mono_type_get_object (mono_object_domain (tb), &klass->this_arg);
5895 break;
5896 case '*':
5897 klass = mono_ptr_class_get (&klass->byval_arg);
5898 mono_class_init (klass);
5899 p++;
5900 break;
5901 case '[':
5902 rank = 1;
5903 p++;
5904 while (*p) {
5905 if (*p == ']')
5906 break;
5907 if (*p == ',')
5908 rank++;
5909 else if (*p != '*') { /* '*' means unknown lower bound */
5910 g_free (str);
5911 return NULL;
5912 }
5913 ++p;
5914 }
5915 if (*p != ']') {
5916 g_free (str);
5917 return NULL;
5918 }
5919 p++;
5920 klass = mono_array_class_get (klass, rank);
5921 mono_class_init (klass);
5922 break;
5923 default:
5924 break;
5925 }
5926 }
5927 g_free (str);
5928 return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
5929 }
5930
5931 static MonoBoolean
5932 ves_icall_Type_IsArrayImpl (MonoReflectionType *t)
5933 {
5934 MonoType *type;
5935 MonoBoolean res;
5936
5937 MONO_ARCH_SAVE_REGS;
5938
5939 type = t->type;
5940 res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY);
5941
5942 return res;
5943 }
5944
5945 static MonoReflectionType *
5946 ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
5947 {
5948 MonoClass *klass, *aklass;
5949
5950 MONO_ARCH_SAVE_REGS;
5951
5952 klass = mono_class_from_mono_type (type->type);
5953 aklass = mono_array_class_get (klass, rank);
5954
5955 return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
5956 }
5957
5958 static MonoReflectionType *
5959 ves_icall_Type_make_byref_type (MonoReflectionType *type)
5960 {
5961 MonoClass *klass;
5962
5963 MONO_ARCH_SAVE_REGS;
5964
5965 klass = mono_class_from_mono_type (type->type);
5966
5967 return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
5968 }
5969
5970 static MonoReflectionType *
5971 ves_icall_Type_MakePointerType (MonoReflectionType *type)
5972 {
5973 MonoClass *pklass;
5974
5975 MONO_ARCH_SAVE_REGS;
5976
5977 pklass = mono_ptr_class_get (type->type);
5978
5979 return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
5980 }
5981
5982 static MonoObject *
5983 ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
5984 MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
5985 {
5986 MonoClass *delegate_class = mono_class_from_mono_type (type->type);
5987 MonoObject *delegate;
5988 gpointer func;
5989 MonoMethod *method = info->method;
5990
5991 MONO_ARCH_SAVE_REGS;
5992
5993 mono_assert (delegate_class->parent == mono_defaults.multicastdelegate_class);
5994
5995 if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) {
5996 if (!mono_security_core_clr_ensure_delegate_creation (method, throwOnBindFailure))
5997 return NULL;
5998 }
5999
6000 delegate = mono_object_new (mono_object_domain (type), delegate_class);
6001
6002 if (mono_method_needs_static_rgctx_invoke (method, FALSE)) {
6003 method = mono_marshal_get_static_rgctx_invoke (method);
6004 func = mono_compile_method (method);
6005 } else if (method->dynamic) {
6006 /* Creating a trampoline would leak memory */
6007 func = mono_compile_method (method);
6008 } else {
6009 func = mono_create_ftnptr (mono_domain_get (),
6010 mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE));
6011 }
6012
6013 mono_delegate_ctor_with_method (delegate, target, func, method);
6014
6015 return delegate;
6016 }
6017
6018 static void
6019 ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate *this)
6020 {
6021 /* Reset the invoke impl to the default one */
6022 this->invoke_impl = mono_runtime_create_delegate_trampoline (this->object.vtable->klass);
6023 }
6024
6025 /*
6026 * Magic number to convert a time which is relative to
6027 * Jan 1, 1970 into a value which is relative to Jan 1, 0001.
6028 */
6029 #define EPOCH_ADJUST ((guint64)62135596800LL)
6030
6031 /*
6032 * Magic number to convert FILETIME base Jan 1, 1601 to DateTime - base Jan, 1, 0001
6033 */
6034 #define FILETIME_ADJUST ((guint64)504911232000000000LL)
6035
6036 #ifdef PLATFORM_WIN32
6037 /* convert a SYSTEMTIME which is of the form "last thursday in october" to a real date */
6038 static void
6039 convert_to_absolute_date(SYSTEMTIME *date)
6040 {
6041 #define IS_LEAP(y) ((y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0))
6042 static int days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
6043 static int leap_days_in_month[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
6044 /* from the calendar FAQ */
6045 int a = (14 - date->wMonth) / 12;
6046 int y = date->wYear - a;
6047 int m = date->wMonth + 12 * a - 2;
6048 int d = (1 + y + y/4 - y/100 + y/400 + (31*m)/12) % 7;
6049
6050 /* d is now the day of the week for the first of the month (0 == Sunday) */
6051
6052 int day_of_week = date->wDayOfWeek;
6053
6054 /* set day_in_month to the first day in the month which falls on day_of_week */
6055 int day_in_month = 1 + (day_of_week - d);
6056 if (day_in_month <= 0)
6057 day_in_month += 7;
6058
6059 /* wDay is 1 for first weekday in month, 2 for 2nd ... 5 means last - so work that out allowing for days in the month */
6060 date->wDay = day_in_month + (date->wDay - 1) * 7;
6061 if (date->wDay > (IS_LEAP(date->wYear) ? leap_days_in_month[date->wMonth - 1] : days_in_month[date->wMonth - 1]))
6062 date->wDay -= 7;
6063 }
6064 #endif
6065
6066 #ifndef PLATFORM_WIN32
6067 /*
6068 * Return's the offset from GMT of a local time.
6069 *
6070 * tm is a local time
6071 * t is the same local time as seconds.
6072 */
6073 static int
6074 gmt_offset(struct tm *tm, time_t t)
6075 {
6076 #if defined (HAVE_TM_GMTOFF)
6077 return tm->tm_gmtoff;
6078 #else
6079 struct tm g;
6080 time_t t2;
6081 g = *gmtime(&t);
6082 g.tm_isdst = tm->tm_isdst;
6083 t2 = mktime(&g);
6084 return (int)difftime(t, t2);
6085 #endif
6086 }
6087 #endif
6088 /*
6089 * This is heavily based on zdump.c from glibc 2.2.
6090 *
6091 * * data[0]: start of daylight saving time (in DateTime ticks).
6092 * * data[1]: end of daylight saving time (in DateTime ticks).
6093 * * data[2]: utcoffset (in TimeSpan ticks).
6094 * * data[3]: additional offset when daylight saving (in TimeSpan ticks).
6095 * * name[0]: name of this timezone when not daylight saving.
6096 * * name[1]: name of this timezone when daylight saving.
6097 *
6098 * FIXME: This only works with "standard" Unix dates (years between 1900 and 2100) while
6099 * the class library allows years between 1 and 9999.
6100 *
6101 * Returns true on success and zero on failure.
6102 */
6103 static guint32
6104 ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
6105 {
6106 #ifndef PLATFORM_WIN32
6107 MonoDomain *domain = mono_domain_get ();
6108 struct tm start, tt;
6109 time_t t;
6110
6111 long int gmtoff;
6112 int is_daylight = 0, day;
6113 char tzone [64];
6114
6115 MONO_ARCH_SAVE_REGS;
6116
6117 MONO_CHECK_ARG_NULL (data);
6118 MONO_CHECK_ARG_NULL (names);
6119
6120 (*data) = mono_array_new (domain, mono_defaults.int64_class, 4);
6121 (*names) = mono_array_new (domain, mono_defaults.string_class, 2);
6122
6123 /*
6124 * no info is better than crashing: we'll need our own tz data
6125 * to make this work properly, anyway. The range is probably
6126 * reduced to 1970 .. 2037 because that is what mktime is
6127 * guaranteed to support (we get into an infinite loop
6128 * otherwise).
6129 */
6130
6131 memset (&start, 0, sizeof (start));
6132
6133 start.tm_mday = 1;
6134 start.tm_year = year-1900;
6135
6136 t = mktime (&start);
6137
6138 if ((year < 1970) || (year > 2037) || (t == -1)) {
6139 t = time (NULL);
6140 tt = *localtime (&t);
6141 strftime (tzone, sizeof (tzone), "%Z", &tt);
6142 mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
6143 mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
6144 return 1;
6145 }
6146
6147 gmtoff = gmt_offset (&start, t);
6148
6149 /* For each day of the year, calculate the tm_gmtoff. */
6150 for (day = 0; day < 365; day++) {
6151
6152 t += 3600*24;
6153 tt = *localtime (&t);
6154
6155 /* Daylight saving starts or ends here. */
6156 if (gmt_offset (&tt, t) != gmtoff) {
6157 struct tm tt1;
6158 time_t t1;
6159
6160 /* Try to find the exact hour when daylight saving starts/ends. */
6161 t1 = t;
6162 do {
6163 t1 -= 3600;
6164 tt1 = *localtime (&t1);
6165 } while (gmt_offset (&tt1, t1) != gmtoff);
6166
6167 /* Try to find the exact minute when daylight saving starts/ends. */
6168 do {
6169 t1 += 60;
6170 tt1 = *localtime (&t1);
6171 } while (gmt_offset (&tt1, t1) == gmtoff);
6172 t1+=gmtoff;
6173 strftime (tzone, sizeof (tzone), "%Z", &tt);
6174
6175 /* Write data, if we're already in daylight saving, we're done. */
6176 if (is_daylight) {
6177 mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
6178 mono_array_set ((*data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
6179 return 1;
6180 } else {
6181 mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
6182 mono_array_set ((*data), gint64, 0, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
6183 is_daylight = 1;
6184 }
6185
6186 /* This is only set once when we enter daylight saving. */
6187 mono_array_set ((*data), gint64, 2, (gint64)gmtoff * 10000000L);
6188 mono_array_set ((*data), gint64, 3, (gint64)(gmt_offset (&tt, t) - gmtoff) * 10000000L);
6189
6190 gmtoff = gmt_offset (&tt, t);
6191 }
6192 }
6193
6194 if (!is_daylight) {
6195 strftime (tzone, sizeof (tzone), "%Z", &tt);
6196 mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
6197 mono_array_setref ((*names), 1, mono_string_new (domain, tzone));
6198 mono_array_set ((*data), gint64, 0, 0);
6199 mono_array_set ((*data), gint64, 1, 0);
6200 mono_array_set ((*data), gint64, 2, (gint64) gmtoff * 10000000L);
6201 mono_array_set ((*data), gint64, 3, 0);
6202 }
6203
6204 return 1;
6205 #else
6206 MonoDomain *domain = mono_domain_get ();
6207 TIME_ZONE_INFORMATION tz_info;
6208 FILETIME ft;
6209 int i;
6210 int err, tz_id;
6211
6212 tz_id = GetTimeZoneInformation (&tz_info);
6213 if (tz_id == TIME_ZONE_ID_INVALID)
6214 return 0;
6215
6216 MONO_CHECK_ARG_NULL (data);
6217 MONO_CHECK_ARG_NULL (names);
6218
6219 (*data) = mono_array_new (domain, mono_defaults.int64_class, 4);
6220 (*names) = mono_array_new (domain, mono_defaults.string_class, 2);
6221
6222 for (i = 0; i < 32; ++i)
6223 if (!tz_info.DaylightName [i])
6224 break;
6225 mono_array_setref ((*names), 1, mono_string_new_utf16 (domain, tz_info.DaylightName, i));
6226 for (i = 0; i < 32; ++i)
6227 if (!tz_info.StandardName [i])
6228 break;
6229 mono_array_setref ((*names), 0, mono_string_new_utf16 (domain, tz_info.StandardName, i));
6230
6231 if ((year <= 1601) || (year > 30827)) {
6232 /*
6233 * According to MSDN, the MS time functions can't handle dates outside
6234 * this interval.
6235 */
6236 return 1;
6237 }
6238
6239 /* even if the timezone has no daylight savings it may have Bias (e.g. GMT+13 it seems) */
6240 if (tz_id != TIME_ZONE_ID_UNKNOWN) {
6241 tz_info.StandardDate.wYear = year;
6242 convert_to_absolute_date(&tz_info.StandardDate);
6243 err = SystemTimeToFileTime (&tz_info.StandardDate, &ft);
6244 //g_assert(err);
6245 if (err == 0)
6246 return 0;
6247
6248 mono_array_set ((*data), gint64, 1, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) | ft.dwLowDateTime));
6249 tz_info.DaylightDate.wYear = year;
6250 convert_to_absolute_date(&tz_info.DaylightDate);
6251 err = SystemTimeToFileTime (&tz_info.DaylightDate, &ft);
6252 //g_assert(err);
6253 if (err == 0)
6254 return 0;
6255
6256 mono_array_set ((*data), gint64, 0, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) | ft.dwLowDateTime));
6257 }
6258 mono_array_set ((*data), gint64, 2, (tz_info.Bias + tz_info.StandardBias) * -600000000LL);
6259 mono_array_set ((*data), gint64, 3, (tz_info.DaylightBias - tz_info.StandardBias) * -600000000LL);
6260
6261 return 1;
6262 #endif
6263 }
6264
6265 static gpointer
6266 ves_icall_System_Object_obj_address (MonoObject *this)
6267 {
6268 MONO_ARCH_SAVE_REGS;
6269
6270 return this;
6271 }
6272
6273 /* System.Buffer */
6274
6275 static inline gint32
6276 mono_array_get_byte_length (MonoArray *array)
6277 {
6278 MonoClass *klass;
6279 int length;
6280 int i;
6281
6282 klass = array->obj.vtable->klass;
6283
6284 if (array->bounds == NULL)
6285 length = array->max_length;
6286 else {
6287 length = 1;
6288 for (i = 0; i < klass->rank; ++ i)
6289 length *= array->bounds [i].length;
6290 }
6291
6292 switch (klass->element_class->byval_arg.type) {
6293 case MONO_TYPE_I1:
6294 case MONO_TYPE_U1:
6295 case MONO_TYPE_BOOLEAN:
6296 return length;
6297 case MONO_TYPE_I2:
6298 case MONO_TYPE_U2:
6299 case MONO_TYPE_CHAR:
6300 return length << 1;
6301 case MONO_TYPE_I4:
6302 case MONO_TYPE_U4:
6303 case MONO_TYPE_R4:
6304 return length << 2;
6305 case MONO_TYPE_I:
6306 case MONO_TYPE_U:
6307 return length * sizeof (gpointer);
6308 case MONO_TYPE_I8:
6309 case MONO_TYPE_U8:
6310 case MONO_TYPE_R8:
6311 return length << 3;
6312 default:
6313 return -1;
6314 }
6315 }
6316
6317 static gint32
6318 ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
6319 {
6320 MONO_ARCH_SAVE_REGS;
6321
6322 return mono_array_get_byte_length (array);
6323 }
6324
6325 static gint8
6326 ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
6327 {
6328 MONO_ARCH_SAVE_REGS;
6329
6330 return mono_array_get (array, gint8, idx);
6331 }
6332
6333 static void
6334 ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
6335 {
6336 MONO_ARCH_SAVE_REGS;
6337
6338 mono_array_set (array, gint8, idx, value);
6339 }
6340
6341 static MonoBoolean
6342 ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count)
6343 {
6344 guint8 *src_buf, *dest_buf;
6345
6346 MONO_ARCH_SAVE_REGS;
6347
6348 /* watch out for integer overflow */
6349 if ((src_offset > mono_array_get_byte_length (src) - count) || (dest_offset > mono_array_get_byte_length (dest) - count))
6350 return FALSE;
6351
6352 src_buf = (guint8 *)src->vector + src_offset;
6353 dest_buf = (guint8 *)dest->vector + dest_offset;
6354
6355 if (src != dest)
6356 memcpy (dest_buf, src_buf, count);
6357 else
6358 memmove (dest_buf, src_buf, count); /* Source and dest are the same array */
6359
6360 return TRUE;
6361 }
6362
6363 static MonoObject *
6364 ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this, MonoString *class_name)
6365 {
6366 MonoDomain *domain = mono_object_domain (this);
6367 MonoObject *res;
6368 MonoRealProxy *rp = ((MonoRealProxy *)this);
6369 MonoTransparentProxy *tp;
6370 MonoType *type;
6371 MonoClass *klass;
6372
6373 MONO_ARCH_SAVE_REGS;
6374
6375 res = mono_object_new (domain, mono_defaults.transparent_proxy_class);
6376 tp = (MonoTransparentProxy*) res;
6377
6378 MONO_OBJECT_SETREF (tp, rp, rp);
6379 type = ((MonoReflectionType *)rp->class_to_proxy)->type;
6380 klass = mono_class_from_mono_type (type);
6381
6382 tp->custom_type_info = (mono_object_isinst (this, mono_defaults.iremotingtypeinfo_class) != NULL);
6383 tp->remote_class = mono_remote_class (domain, class_name, klass);
6384
6385 res->vtable = mono_remote_class_vtable (domain, tp->remote_class, rp);
6386 return res;
6387 }
6388
6389 static MonoReflectionType *
6390 ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
6391 {
6392 return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg);
6393 }
6394
6395 /* System.Environment */
6396
6397 MonoString*
6398 ves_icall_System_Environment_get_UserName (void)
6399 {
6400 MONO_ARCH_SAVE_REGS;
6401
6402 /* using glib is more portable */
6403 return mono_string_new (mono_domain_get (), g_get_user_name ());
6404 }
6405
6406
6407 static MonoString *
6408 ves_icall_System_Environment_get_MachineName (void)
6409 {
6410 #if defined (PLATFORM_WIN32)
6411 gunichar2 *buf;
6412 guint32 len;
6413 MonoString *result;
6414
6415 len = MAX_COMPUTERNAME_LENGTH + 1;
6416 buf = g_new (gunichar2, len);
6417
6418 result = NULL;
6419 if (GetComputerName (buf, (PDWORD) &len))
6420 result = mono_string_new_utf16 (mono_domain_get (), buf, len);
6421
6422 g_free (buf);
6423 return result;
6424 #elif !defined(DISABLE_SOCKETS)
6425 gchar buf [256];
6426 MonoString *result;
6427
6428 if (gethostname (buf, sizeof (buf)) == 0)
6429 result = mono_string_new (mono_domain_get (), buf);
6430 else
6431 result = NULL;
6432
6433 return result;
6434 #else
6435 return mono_string_new (mono_domain_get (), "mono");
6436 #endif
6437 }
6438
6439 static int
6440 ves_icall_System_Environment_get_Platform (void)
6441 {
6442 #if defined (PLATFORM_WIN32)
6443 /* Win32NT */
6444 return 2;
6445 #elif defined(__MACH__)
6446 /* OSX */
6447 if (mono_framework_version () < 2)
6448 return 128;
6449
6450 //
6451 // For compatibility with our client code, this will be 4 for a while.
6452 // We will eventually move to 6 to match .NET, but it requires all client
6453 // code to be updated and the documentation everywhere to be updated
6454 // first.
6455 //
6456 return 4;
6457 #else
6458 /* Unix */
6459 if (mono_framework_version () < 2)
6460 return 128;
6461 return 4;
6462 #endif
6463 }
6464
6465 static MonoString *
6466 ves_icall_System_Environment_get_NewLine (void)
6467 {
6468 MONO_ARCH_SAVE_REGS;
6469
6470 #if defined (PLATFORM_WIN32)
6471 return mono_string_new (mono_domain_get (), "\r\n");
6472 #else
6473 return mono_string_new (mono_domain_get (), "\n");
6474 #endif
6475 }
6476
6477 static MonoString *
6478 ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
6479 {
6480 const gchar *value;
6481 gchar *utf8_name;
6482
6483 MONO_ARCH_SAVE_REGS;
6484
6485 if (name == NULL)
6486 return NULL;
6487
6488 utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
6489 value = g_getenv (utf8_name);
6490
6491 g_free (utf8_name);
6492
6493 if (value == 0)
6494 return NULL;
6495
6496 return mono_string_new (mono_domain_get (), value);
6497 }
6498
6499 /*
6500 * There is no standard way to get at environ.
6501 */
6502 #ifndef _MSC_VER
6503 #ifndef __MINGW32_VERSION
6504 #ifdef __APPLE__
6505 /* Apple defines this in crt_externs.h but doesn't provide that header for
6506 * arm-apple-darwin9. We'll manually define the symbol on Apple as it does
6507 * in fact exist on all implementations (so far)
6508 */
6509 gchar ***_NSGetEnviron();
6510 #define environ (*_NSGetEnviron())
6511 #else
6512 extern
6513 char **environ;
6514 #endif
6515 #endif
6516 #endif
6517
6518 static MonoArray *
6519 ves_icall_System_Environment_GetEnvironmentVariableNames (void)
6520 {
6521 #ifdef PLATFORM_WIN32
6522 MonoArray *names;
6523 MonoDomain *domain;
6524 MonoString *str;
6525 WCHAR* env_strings;
6526 WCHAR* env_string;
6527 WCHAR* equal_str;
6528 int n = 0;
6529
6530 env_strings = GetEnvironmentStrings();
6531
6532 if (env_strings) {
6533 env_string = env_strings;
6534 while (*env_string != '\0') {
6535 /* weird case that MS seems to skip */
6536 if (*env_string != '=')
6537 n++;
6538 while (*env_string != '\0')
6539 env_string++;
6540 env_string++;
6541 }
6542 }
6543
6544 domain = mono_domain_get ();
6545 names = mono_array_new (domain, mono_defaults.string_class, n);
6546
6547 if (env_strings) {
6548 n = 0;
6549 env_string = env_strings;
6550 while (*env_string != '\0') {
6551 /* weird case that MS seems to skip */
6552 if (*env_string != '=') {
6553 equal_str = wcschr(env_string, '=');
6554 g_assert(equal_str);
6555 str = mono_string_new_utf16 (domain, env_string, equal_str-env_string);
6556 mono_array_setref (names, n, str);
6557 n++;
6558 }
6559 while (*env_string != '\0')
6560 env_string++;
6561 env_string++;
6562 }
6563
6564 FreeEnvironmentStrings (env_strings);
6565 }
6566
6567 return names;
6568
6569 #else
6570 MonoArray *names;
6571 MonoDomain *domain;
6572 MonoString *str;
6573 gchar **e, **parts;
6574 int n;
6575
6576 MONO_ARCH_SAVE_REGS;
6577
6578 n = 0;
6579 for (e = environ; *e != 0; ++ e)
6580 ++ n;
6581
6582 domain = mono_domain_get ();
6583 names = mono_array_new (domain, mono_defaults.string_class, n);
6584
6585 n = 0;
6586 for (e = environ; *e != 0; ++ e) {
6587 parts = g_strsplit (*e, "=", 2);
6588 if (*parts != 0) {
6589 str = mono_string_new (domain, *parts);
6590 mono_array_setref (names, n, str);
6591 }
6592
6593 g_strfreev (parts);
6594
6595 ++ n;
6596 }
6597
6598 return names;
6599 #endif
6600 }
6601
6602 /*
6603 * If your platform lacks setenv/unsetenv, you must upgrade your glib.
6604 */
6605 #if !GLIB_CHECK_VERSION(2,4,0)
6606 #define g_setenv(a,b,c) setenv(a,b,c)
6607 #define g_unsetenv(a) unsetenv(a)
6608 #endif
6609
6610 static void
6611 ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
6612 {
6613 #ifdef PLATFORM_WIN32
6614 gunichar2 *utf16_name, *utf16_value;
6615 #else
6616 gchar *utf8_name, *utf8_value;
6617 #endif
6618
6619 MONO_ARCH_SAVE_REGS;
6620
6621 #ifdef PLATFORM_WIN32
6622 utf16_name = mono_string_to_utf16 (name);
6623 if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
6624 SetEnvironmentVariable (utf16_name, NULL);
6625 g_free (utf16_name);
6626 return;
6627 }
6628
6629 utf16_value = mono_string_to_utf16 (value);
6630
6631 SetEnvironmentVariable (utf16_name, utf16_value);
6632
6633 g_free (utf16_name);
6634 g_free (utf16_value);
6635 #else
6636 utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
6637
6638 if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
6639 g_unsetenv (utf8_name);
6640 g_free (utf8_name);
6641 return;
6642 }
6643
6644 utf8_value = mono_string_to_utf8 (value);
6645 g_setenv (utf8_name, utf8_value, TRUE);
6646
6647 g_free (utf8_name);
6648 g_free (utf8_value);
6649 #endif
6650 }
6651
6652 static void
6653 ves_icall_System_Environment_Exit (int result)
6654 {
6655 MONO_ARCH_SAVE_REGS;
6656
6657 mono_threads_set_shutting_down ();
6658
6659 mono_runtime_set_shutting_down ();
6660
6661 /* Suspend all managed threads since the runtime is going away */
6662 mono_thread_suspend_all_other_threads ();
6663
6664 mono_runtime_quit ();
6665
6666 /* we may need to do some cleanup here... */
6667 exit (result);
6668 }
6669
6670 static MonoString*
6671 ves_icall_System_Environment_GetGacPath (void)
6672 {
6673 return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ());
6674 }
6675
6676 static MonoString*
6677 ves_icall_System_Environment_GetWindowsFolderPath (int folder)
6678 {
6679 #if defined (PLATFORM_WIN32)
6680 #ifndef CSIDL_FLAG_CREATE
6681 #define CSIDL_FLAG_CREATE 0x8000
6682 #endif
6683
6684 WCHAR path [MAX_PATH];
6685 /* Create directory if no existing */
6686 if (SUCCEEDED (SHGetFolderPathW (NULL, folder | CSIDL_FLAG_CREATE, NULL, 0, path))) {
6687 int len = 0;
6688 while (path [len])
6689 ++ len;
6690 return mono_string_new_utf16 (mono_domain_get (), path, len);
6691 }
6692 #else
6693 g_warning ("ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
6694 #endif
6695 return mono_string_new (mono_domain_get (), "");
6696 }
6697
6698 static MonoArray *
6699 ves_icall_System_Environment_GetLogicalDrives (void)
6700 {
6701 gunichar2 buf [128], *ptr, *dname;
6702 gunichar2 *u16;
6703 guint initial_size = 127, size = 128;
6704 gint ndrives;
6705 MonoArray *result;
6706 MonoString *drivestr;
6707 MonoDomain *domain = mono_domain_get ();
6708 gint len;
6709
6710 MONO_ARCH_SAVE_REGS;
6711
6712 buf [0] = '\0';
6713 ptr = buf;
6714
6715 while (size > initial_size) {
6716 size = (guint) GetLogicalDriveStrings (initial_size, ptr);
6717 if (size > initial_size) {
6718 if (ptr != buf)
6719 g_free (ptr);
6720 ptr = g_malloc0 ((size + 1) * sizeof (gunichar2));
6721 initial_size = size;
6722 size++;
6723 }
6724 }
6725
6726 /* Count strings */
6727 dname = ptr;
6728 ndrives = 0;
6729 do {
6730 while (*dname++);
6731 ndrives++;
6732 } while (*dname);
6733
6734 dname = ptr;
6735 result = mono_array_new (domain, mono_defaults.string_class, ndrives);
6736 ndrives = 0;
6737 do {
6738 len = 0;
6739 u16 = dname;
6740 while (*u16) { u16++; len ++; }
6741 drivestr = mono_string_new_utf16 (domain, dname, len);
6742 mono_array_setref (result, ndrives++, drivestr);
6743 while (*dname++);
6744 } while (*dname);
6745
6746 if (ptr != buf)
6747 g_free (ptr);
6748
6749 return result;
6750 }
6751
6752 static MonoString *
6753 ves_icall_System_Environment_InternalGetHome (void)
6754 {
6755 MONO_ARCH_SAVE_REGS;
6756
6757 return mono_string_new (mono_domain_get (), g_get_home_dir ());
6758 }
6759
6760 static const char *encodings [] = {
6761 (char *) 1,
6762 "ascii", "us_ascii", "us", "ansi_x3.4_1968",
6763 "ansi_x3.4_1986", "cp367", "csascii", "ibm367",
6764 "iso_ir_6", "iso646_us", "iso_646.irv:1991",
6765 (char *) 2,
6766 "utf_7", "csunicode11utf7", "unicode_1_1_utf_7",
6767 "unicode_2_0_utf_7", "x_unicode_1_1_utf_7",
6768 "x_unicode_2_0_utf_7",
6769 (char *) 3,
6770 "utf_8", "unicode_1_1_utf_8", "unicode_2_0_utf_8",
6771 "x_unicode_1_1_utf_8", "x_unicode_2_0_utf_8",
6772 (char *) 4,
6773 "utf_16", "UTF_16LE", "ucs_2", "unicode",
6774 "iso_10646_ucs2",
6775 (char *) 5,
6776 "unicodefffe", "utf_16be",
6777 (char *) 6,
6778 "iso_8859_1",
6779 (char *) 0
6780 };
6781
6782 /*
6783 * Returns the internal codepage, if the value of "int_code_page" is
6784 * 1 at entry, and we can not compute a suitable code page number,
6785 * returns the code page as a string
6786 */
6787 static MonoString*
6788 ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page)
6789 {
6790 const char *cset;
6791 const char *p;
6792 char *c;
6793 char *codepage = NULL;
6794 int code;
6795 int want_name = *int_code_page;
6796 int i;
6797
6798 *int_code_page = -1;
6799 MONO_ARCH_SAVE_REGS;
6800
6801 g_get_charset (&cset);
6802 c = codepage = strdup (cset);
6803 for (c = codepage; *c; c++){
6804 if (isascii (*c) && isalpha (*c))
6805 *c = tolower (*c);
6806 if (*c == '-')
6807 *c = '_';
6808 }
6809 /* g_print ("charset: %s\n", cset); */
6810
6811 /* handle some common aliases */
6812 p = encodings [0];
6813 code = 0;
6814 for (i = 0; p != 0; ){
6815 if ((gssize) p < 7){
6816 code = (gssize) p;
6817 p = encodings [++i];
6818 continue;
6819 }
6820 if (strcmp (p, codepage) == 0){
6821 *int_code_page = code;
6822 break;
6823 }
6824 p = encodings [++i];
6825 }
6826
6827 if (strstr (codepage, "utf_8") != NULL)
6828 *int_code_page |= 0x10000000;
6829 free (codepage);
6830
6831 if (want_name && *int_code_page == -1)
6832 return mono_string_new (mono_domain_get (), cset);
6833 else
6834 return NULL;
6835 }
6836
6837 static MonoBoolean
6838 ves_icall_System_Environment_get_HasShutdownStarted (void)
6839 {
6840 if (mono_runtime_is_shutting_down ())
6841 return TRUE;
6842
6843 if (mono_domain_is_unloading (mono_domain_get ()))
6844 return TRUE;
6845
6846 return FALSE;
6847 }
6848
6849 static void
6850 ves_icall_System_Environment_BroadcastSettingChange (void)
6851 {
6852 #ifdef PLATFORM_WIN32
6853 SendMessageTimeout (HWND_BROADCAST, WM_SETTINGCHANGE, NULL, L"Environment", SMTO_ABORTIFHUNG, 2000, 0);
6854 #endif
6855 }
6856
6857 static void
6858 ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this,
6859 MonoReflectionMethod *method,
6860 MonoArray *out_args)
6861 {
6862 MONO_ARCH_SAVE_REGS;
6863
6864 mono_message_init (mono_object_domain (this), this, method, out_args);
6865 }
6866
6867 static MonoBoolean
6868 ves_icall_IsTransparentProxy (MonoObject *proxy)
6869 {
6870 MONO_ARCH_SAVE_REGS;
6871
6872 if (!proxy)
6873 return 0;
6874
6875 if (proxy->vtable->klass == mono_defaults.transparent_proxy_class)
6876 return 1;
6877
6878 return 0;
6879 }
6880
6881 static MonoReflectionMethod *
6882 ves_icall_Remoting_RemotingServices_GetVirtualMethod (
6883 MonoReflectionType *rtype, MonoReflectionMethod *rmethod)
6884 {
6885 MonoClass *klass;
6886 MonoMethod *method;
6887 MonoMethod **vtable;
6888 MonoMethod *res = NULL;
6889
6890 MONO_CHECK_ARG_NULL (rtype);
6891 MONO_CHECK_ARG_NULL (rmethod);
6892
6893 method = rmethod->method;
6894 klass = mono_class_from_mono_type (rtype->type);
6895
6896 if (MONO_CLASS_IS_INTERFACE (klass))
6897 return NULL;
6898
6899 if (method->flags & METHOD_ATTRIBUTE_STATIC)
6900 return NULL;
6901
6902 if ((method->flags & METHOD_ATTRIBUTE_FINAL) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
6903 if (klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE))
6904 return rmethod;
6905 else
6906 return NULL;
6907 }
6908
6909 mono_class_setup_vtable (klass);
6910 vtable = klass->vtable;
6911
6912 if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
6913 int offs = mono_class_interface_offset (klass, method->klass);
6914 if (offs >= 0)
6915 res = vtable [offs + method->slot];
6916 } else {
6917 if (!(klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE)))
6918 return NULL;
6919
6920 if (method->slot != -1)
6921 res = vtable [method->slot];
6922 }
6923
6924 if (!res)
6925 return NULL;
6926
6927 return mono_method_get_object (mono_domain_get (), res, NULL);
6928 }
6929
6930 static void
6931 ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
6932 {
6933 MonoClass *klass;
6934 MonoVTable* vtable;
6935
6936 MONO_ARCH_SAVE_REGS;
6937
6938 klass = mono_class_from_mono_type (type->type);
6939 vtable = mono_class_vtable (mono_domain_get (), klass);
6940
6941 if (enable) vtable->remote = 1;
6942 else vtable->remote = 0;
6943 }
6944
6945 static MonoObject *
6946 ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType *type)
6947 {
6948 MonoClass *klass;
6949 MonoDomain *domain;
6950
6951 MONO_ARCH_SAVE_REGS;
6952
6953 domain = mono_object_domain (type);
6954 klass = mono_class_from_mono_type (type->type);
6955
6956 if (klass->rank >= 1) {
6957 g_assert (klass->rank == 1);
6958 return (MonoObject *) mono_array_new (domain, klass->element_class, 0);
6959 } else {
6960 /* Bypass remoting object creation check */
6961 return mono_object_new_alloc_specific (mono_class_vtable (domain, klass));
6962 }
6963 }
6964
6965 static MonoString *
6966 ves_icall_System_IO_get_temp_path (void)
6967 {
6968 MONO_ARCH_SAVE_REGS;
6969
6970 return mono_string_new (mono_domain_get (), g_get_tmp_dir ());
6971 }
6972
6973 #ifndef PLATFORM_NO_DRIVEINFO
6974 static MonoBoolean
6975 ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 *free_bytes_avail,
6976 guint64 *total_number_of_bytes, guint64 *total_number_of_free_bytes,
6977 gint32 *error)
6978 {
6979 gboolean result;
6980 ULARGE_INTEGER wapi_free_bytes_avail;
6981 ULARGE_INTEGER wapi_total_number_of_bytes;
6982 ULARGE_INTEGER wapi_total_number_of_free_bytes;
6983
6984 MONO_ARCH_SAVE_REGS;
6985
6986 *error = ERROR_SUCCESS;
6987 result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes,
6988 &wapi_total_number_of_free_bytes);
6989
6990 if (result) {
6991 *free_bytes_avail = wapi_free_bytes_avail.QuadPart;
6992 *total_number_of_bytes = wapi_total_number_of_bytes.QuadPart;
6993 *total_number_of_free_bytes = wapi_total_number_of_free_bytes.QuadPart;
6994 } else {
6995 *free_bytes_avail = 0;
6996 *total_number_of_bytes = 0;
6997 *total_number_of_free_bytes = 0;
6998 *error = GetLastError ();
6999 }
7000
7001 return result;
7002 }
7003
7004 static guint32
7005 ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name)
7006 {
7007 MONO_ARCH_SAVE_REGS;
7008
7009 return GetDriveType (mono_string_chars (root_path_name));
7010 }
7011 #endif
7012
7013 static gpointer
7014 ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
7015 {
7016 MONO_ARCH_SAVE_REGS;
7017
7018 return mono_compile_method (method);
7019 }
7020
7021 static MonoString *
7022 ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
7023 {
7024 MonoString *mcpath;
7025 gchar *path;
7026
7027 MONO_ARCH_SAVE_REGS;
7028
7029 path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL);
7030
7031 #if defined (PLATFORM_WIN32)
7032 /* Avoid mixing '/' and '\\' */
7033 {
7034 gint i;
7035 for (i = strlen (path) - 1; i >= 0; i--)
7036 if (path [i] == '/')
7037 path [i] = '\\';
7038 }
7039 #endif
7040 mcpath = mono_string_new (mono_domain_get (), path);
7041 g_free (path);
7042
7043 return mcpath;
7044 }
7045
7046 static MonoString *
7047 get_bundled_machine_config (void)
7048 {
7049 const gchar *machine_config;
7050
7051 MONO_ARCH_SAVE_REGS;
7052
7053 machine_config = mono_get_machine_config ();
7054
7055 if (!machine_config)
7056 return NULL;
7057
7058 return mono_string_new (mono_domain_get (), machine_config);
7059 }
7060
7061 static MonoString *
7062 ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void)
7063 {
7064 MonoString *ipath;
7065 gchar *path;
7066
7067 MONO_ARCH_SAVE_REGS;
7068
7069 path = g_path_get_dirname (mono_get_config_dir ());
7070
7071 #if defined (PLATFORM_WIN32)
7072 /* Avoid mixing '/' and '\\' */
7073 {
7074 gint i;
7075 for (i = strlen (path) - 1; i >= 0; i--)
7076 if (path [i] == '/')
7077 path [i] = '\\';
7078 }
7079 #endif
7080 ipath = mono_string_new (mono_domain_get (), path);
7081 g_free (path);
7082
7083 return ipath;
7084 }
7085
7086 static gboolean
7087 ves_icall_get_resources_ptr (MonoReflectionAssembly *assembly, gpointer *result, gint32 *size)
7088 {
7089 MonoPEResourceDataEntry *entry;
7090 MonoImage *image;
7091
7092 MONO_ARCH_SAVE_REGS;
7093
7094 if (!assembly || !result || !size)
7095 return FALSE;
7096
7097 *result = NULL;
7098 *size = 0;
7099 image = assembly->assembly->image;
7100 entry = mono_image_lookup_resource (image, MONO_PE_RESOURCE_ID_ASPNET_STRING, 0, NULL);
7101 if (!entry)
7102 return FALSE;
7103
7104 *result = mono_image_rva_map (image, entry->rde_data_offset);
7105 if (!(*result)) {
7106 g_free (entry);
7107 return FALSE;
7108 }
7109 *size = entry->rde_size;
7110 g_free (entry);
7111 return TRUE;
7112 }
7113
7114 static MonoBoolean
7115 ves_icall_System_Diagnostics_Debugger_IsAttached_internal (void)
7116 {
7117 return mono_debug_using_mono_debugger ();
7118 }
7119
7120 static void
7121 ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoString *message)
7122 {
7123 #if defined (PLATFORM_WIN32)
7124 OutputDebugString (mono_string_chars (message));
7125 #else
7126 g_warning ("WriteWindowsDebugString called and PLATFORM_WIN32 not defined!\n");
7127 #endif
7128 }
7129
7130 /* Only used for value types */
7131 static MonoObject *
7132 ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
7133 {
7134 MonoClass *klass;
7135 MonoDomain *domain;
7136
7137 MONO_ARCH_SAVE_REGS;
7138
7139 domain = mono_object_domain (type);
7140 klass = mono_class_from_mono_type (type->type);
7141
7142 if (mono_class_is_nullable (klass))
7143 /* No arguments -> null */
7144 return NULL;
7145
7146 return mono_object_new (domain, klass);
7147 }
7148
7149 static MonoReflectionMethod *
7150 ves_icall_MonoMethod_get_base_definition (MonoReflectionMethod *m)
7151 {
7152 MonoClass *klass, *parent;
7153 MonoMethod *method = m->method;
7154 MonoMethod *result = NULL;
7155
7156 MONO_ARCH_SAVE_REGS;
7157
7158 if (method->klass == NULL)
7159 return m;
7160
7161 if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
7162 MONO_CLASS_IS_INTERFACE (method->klass) ||
7163 method->flags & METHOD_ATTRIBUTE_NEW_SLOT)
7164 return m;
7165
7166 klass = method->klass;
7167 if (klass->generic_class)
7168 klass = klass->generic_class->container_class;
7169
7170 /* At the end of the loop, klass points to the eldest class that has this virtual function slot. */
7171 for (parent = klass->parent; parent != NULL; parent = parent->parent) {
7172 mono_class_setup_vtable (parent);
7173 if (parent->vtable_size <= method->slot)
7174 break;
7175 klass = parent;
7176 }
7177
7178 if (klass == method->klass)
7179 return m;
7180
7181 result = klass->vtable [method->slot];
7182 if (result == NULL) {
7183 /* It is an abstract method */
7184 gpointer iter = NULL;
7185 while ((result = mono_class_get_methods (klass, &iter)))
7186 if (result->slot == method->slot)
7187 break;
7188 }
7189
7190 if (result == NULL)
7191 return m;
7192
7193 return mono_method_get_object (mono_domain_get (), result, NULL);
7194 }
7195
7196 static MonoString*
7197 ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
7198 {
7199 MonoMethod *method = m->method;
7200
7201 MONO_OBJECT_SETREF (m, name, mono_string_new (mono_object_domain (m), method->name));
7202 return m->name;
7203 }
7204
7205 static void
7206 mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
7207 {
7208 MONO_ARCH_SAVE_REGS;
7209
7210 iter->sig = *(MonoMethodSignature**)argsp;
7211
7212 g_assert (iter->sig->sentinelpos <= iter->sig->param_count);
7213 g_assert (iter->sig->call_convention == MONO_CALL_VARARG);
7214
7215 iter->next_arg = 0;
7216 /* FIXME: it's not documented what start is exactly... */
7217 if (start) {
7218 iter->args = start;
7219 } else {
7220 iter->args = argsp + sizeof (gpointer);
7221 #ifndef MONO_ARCH_REGPARMS
7222 {
7223 guint32 i, arg_size;
7224 gint32 align;
7225 for (i = 0; i < iter->sig->sentinelpos; ++i) {
7226 arg_size = mono_type_stack_size (iter->sig->params [i], &align);
7227 iter->args = (char*)iter->args + arg_size;
7228 }
7229 }
7230 #endif
7231 }
7232 iter->num_args = iter->sig->param_count - iter->sig->sentinelpos;
7233
7234 /* g_print ("sig %p, param_count: %d, sent: %d\n", iter->sig, iter->sig->param_count, iter->sig->sentinelpos); */
7235 }
7236
7237 static MonoTypedRef
7238 mono_ArgIterator_IntGetNextArg (MonoArgIterator *iter)
7239 {
7240 guint32 i, arg_size;
7241 gint32 align;
7242 MonoTypedRef res;
7243 MONO_ARCH_SAVE_REGS;
7244
7245 i = iter->sig->sentinelpos + iter->next_arg;
7246
7247 g_assert (i < iter->sig->param_count);
7248
7249 res.type = iter->sig->params [i];
7250 res.klass = mono_class_from_mono_type (res.type);
7251 res.value = iter->args;
7252 arg_size = mono_type_stack_size (res.type, &align);
7253 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
7254 if (arg_size <= sizeof (gpointer)) {
7255 int dummy;
7256 int padding = arg_size - mono_type_size (res.type, &dummy);
7257 res.value = (guint8*)res.value + padding;
7258 }
7259 #endif
7260 iter->args = (char*)iter->args + arg_size;
7261 iter->next_arg++;
7262
7263 /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); */
7264
7265 return res;
7266 }
7267
7268 static MonoTypedRef
7269 mono_ArgIterator_IntGetNextArgT (MonoArgIterator *iter, MonoType *type)
7270 {
7271 guint32 i, arg_size;
7272 gint32 align;
7273 MonoTypedRef res;
7274 MONO_ARCH_SAVE_REGS;
7275
7276 i = iter->sig->sentinelpos + iter->next_arg;
7277
7278 g_assert (i < iter->sig->param_count);
7279
7280 while (i < iter->sig->param_count) {
7281 if (!mono_metadata_type_equal (type, iter->sig->params [i]))
7282 continue;
7283 res.type = iter->sig->params [i];
7284 res.klass = mono_class_from_mono_type (res.type);
7285 /* FIXME: endianess issue... */
7286 res.value = iter->args;
7287 arg_size = mono_type_stack_size (res.type, &align);
7288 iter->args = (char*)iter->args + arg_size;
7289 iter->next_arg++;
7290 /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); */
7291 return res;
7292 }
7293 /* g_print ("arg type 0x%02x not found\n", res.type->type); */
7294
7295 res.type = NULL;
7296 res.value = NULL;
7297 res.klass = NULL;
7298 return res;
7299 }
7300
7301 static MonoType*
7302 mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter)
7303 {
7304 gint i;
7305 MONO_ARCH_SAVE_REGS;
7306
7307 i = iter->sig->sentinelpos + iter->next_arg;
7308
7309 g_assert (i < iter->sig->param_count);
7310
7311 return iter->sig->params [i];
7312 }
7313
7314 static MonoObject*
7315 mono_TypedReference_ToObject (MonoTypedRef tref)
7316 {
7317 MONO_ARCH_SAVE_REGS;
7318
7319 if (MONO_TYPE_IS_REFERENCE (tref.type)) {
7320 MonoObject** objp = tref.value;
7321 return *objp;
7322 }
7323
7324 return mono_value_box (mono_domain_get (), tref.klass, tref.value);
7325 }
7326
7327 static MonoObject*
7328 mono_TypedReference_ToObjectInternal (MonoType *type, gpointer value, MonoClass *klass)
7329 {
7330 MONO_ARCH_SAVE_REGS;
7331
7332 if (MONO_TYPE_IS_REFERENCE (type)) {
7333 MonoObject** objp = value;
7334 return *objp;
7335 }
7336
7337 return mono_value_box (mono_domain_get (), klass, value);
7338 }
7339
7340 static void
7341 prelink_method (MonoMethod *method)
7342 {
7343 const char *exc_class, *exc_arg;
7344 if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
7345 return;
7346 mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
7347 if (exc_class) {
7348 mono_raise_exception(
7349 mono_exception_from_name_msg (mono_defaults.corlib, "System", exc_class, exc_arg ) );
7350 }
7351 /* create the wrapper, too? */
7352 }
7353
7354 static void
7355 ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
7356 {
7357 MONO_ARCH_SAVE_REGS;
7358 prelink_method (method->method);
7359 }
7360
7361 static void
7362 ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType *type)
7363 {
7364 MonoClass *klass = mono_class_from_mono_type (type->type);
7365 MonoMethod* m;
7366 gpointer iter = NULL;
7367 MONO_ARCH_SAVE_REGS;
7368
7369 while ((m = mono_class_get_methods (klass, &iter)))
7370 prelink_method (m);
7371 }
7372
7373 /* These parameters are "readonly" in corlib/System/NumberFormatter.cs */
7374 static void
7375 ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas,
7376 gint32 const **exponents,
7377 gunichar2 const **digitLowerTable,
7378 gunichar2 const **digitUpperTable,
7379 gint64 const **tenPowersList,
7380 gint32 const **decHexDigits)
7381 {
7382 *mantissas = Formatter_MantissaBitsTable;
7383 *exponents = Formatter_TensExponentTable;
7384 *digitLowerTable = Formatter_DigitLowerTable;
7385 *digitUpperTable = Formatter_DigitUpperTable;
7386 *tenPowersList = Formatter_TenPowersList;
7387 *decHexDigits = Formatter_DecHexDigits;
7388 }
7389
7390 /* These parameters are "readonly" in corlib/System/Char.cs */
7391 static void
7392 ves_icall_System_Char_GetDataTablePointers (guint8 const **category_data,
7393 guint8 const **numeric_data,
7394 gdouble const **numeric_data_values,
7395 guint16 const **to_lower_data_low,
7396 guint16 const **to_lower_data_high,
7397 guint16 const **to_upper_data_low,
7398 guint16 const **to_upper_data_high)
7399 {
7400 *category_data = CategoryData;
7401 *numeric_data = NumericData;
7402 *numeric_data_values = NumericDataValues;
7403 *to_lower_data_low = ToLowerDataLow;
7404 *to_lower_data_high = ToLowerDataHigh;
7405 *to_upper_data_low = ToUpperDataLow;
7406 *to_upper_data_high = ToUpperDataHigh;
7407 }
7408
7409 static gint32
7410 ves_icall_MonoDebugger_GetMethodToken (MonoReflectionMethod *method)
7411 {
7412 return method->method->token;
7413 }
7414
7415 /*
7416 * We return NULL for no modifiers so the corlib code can return Type.EmptyTypes
7417 * and avoid useless allocations.
7418 */
7419 static MonoArray*
7420 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional)
7421 {
7422 MonoArray *res;
7423 int i, count = 0;
7424 for (i = 0; i < type->num_mods; ++i) {
7425 if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required))
7426 count++;
7427 }
7428 if (!count)
7429 return NULL;
7430 res = mono_array_new (mono_domain_get (), mono_defaults.systemtype_class, count);
7431 count = 0;
7432 for (i = 0; i < type->num_mods; ++i) {
7433 if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
7434 MonoClass *klass = mono_class_get (image, type->modifiers [i].token);
7435 mono_array_setref (res, count, mono_type_get_object (mono_domain_get (), &klass->byval_arg));
7436 count++;
7437 }
7438 }
7439 return res;
7440 }
7441
7442 static MonoArray*
7443 param_info_get_type_modifiers (MonoReflectionParameter *param, MonoBoolean optional)
7444 {
7445 MonoType *type = param->ClassImpl->type;
7446 MonoReflectionMethod *method = (MonoReflectionMethod*)param->MemberImpl;
7447 MonoImage *image = method->method->klass->image;
7448 int pos = param->PositionImpl;
7449 MonoMethodSignature *sig = mono_method_signature (method->method);
7450 if (pos == -1)
7451 type = sig->ret;
7452 else
7453 type = sig->params [pos];
7454
7455 return type_array_from_modifiers (image, type, optional);
7456 }
7457
7458 static MonoType*
7459 get_property_type (MonoProperty *prop)
7460 {
7461 MonoMethodSignature *sig;
7462 if (prop->get) {
7463 sig = mono_method_signature (prop->get);
7464 return sig->ret;
7465 } else if (prop->set) {
7466 sig = mono_method_signature (prop->set);
7467 return sig->params [sig->param_count - 1];
7468 }
7469 return NULL;
7470 }
7471
7472 static MonoArray*
7473 property_info_get_type_modifiers (MonoReflectionProperty *property, MonoBoolean optional)
7474 {
7475 MonoType *type = get_property_type (property->property);
7476 MonoImage *image = property->klass->image;
7477
7478 if (!type)
7479 return NULL;
7480 return type_array_from_modifiers (image, type, optional);
7481 }
7482
7483 static MonoBoolean
7484 custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type)
7485 {
7486 MonoCustomAttrInfo *cinfo;
7487 gboolean found;
7488
7489 cinfo = mono_reflection_get_custom_attrs_info (obj);
7490 if (!cinfo)
7491 return FALSE;
7492 found = mono_custom_attrs_has_attr (cinfo, mono_class_from_mono_type (attr_type->type));
7493 if (!cinfo->cached)
7494 mono_custom_attrs_free (cinfo);
7495 return found;
7496 }
7497
7498 static MonoArray*
7499 custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
7500 {
7501 MonoArray *res = mono_reflection_get_custom_attrs_by_type (obj, attr_type ? mono_class_from_mono_type (attr_type->type) : NULL);
7502
7503 if (mono_loader_get_last_error ()) {
7504 mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
7505 g_assert_not_reached ();
7506 /* Not reached */
7507 return NULL;
7508 } else {
7509 return res;
7510 }
7511 }
7512
7513 static MonoBoolean
7514 GCHandle_CheckCurrentDomain (guint32 gchandle)
7515 {
7516 return mono_gchandle_is_in_domain (gchandle, mono_domain_get ());
7517 }
7518
7519 static MonoString*
7520 ves_icall_Mono_Runtime_GetDisplayName (void)
7521 {
7522 static const char display_name_str [] = "Mono " VERSION;
7523 MonoString *display_name = mono_string_new (mono_domain_get (), display_name_str);
7524 return display_name;
7525 }
7526
7527 static MonoString*
7528 ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
7529 {
7530 MonoString *message;
7531 guint32 ret;
7532 gunichar2 buf[256];
7533
7534 ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
7535 FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code, 0,
7536 buf, 255, NULL);
7537 if (ret == 0) {
7538 message = mono_string_new (mono_domain_get (), "Error looking up error string");
7539 } else {
7540 message = mono_string_new_utf16 (mono_domain_get (), buf, ret);
7541 }
7542
7543 return message;
7544 }
7545
7546 const static guchar
7547 dbase64 [] = {
7548 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
7549 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
7550 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63,
7551 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 0, 128, 128,
7552 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
7553 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128,
7554 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
7555 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
7556 };
7557
7558 static MonoArray *
7559 base64_to_byte_array (gunichar2 *start, gint ilength, MonoBoolean allowWhitespaceOnly)
7560 {
7561 gint ignored;
7562 gint i;
7563 gunichar2 c;
7564 gunichar2 last, prev_last, prev2_last;
7565 gint olength;
7566 MonoArray *result;
7567 guchar *res_ptr;
7568 gint a [4], b [4];
7569 MonoException *exc;
7570
7571 ignored = 0;
7572 last = prev_last = 0, prev2_last = 0;
7573 for (i = 0; i < ilength; i++) {
7574 c = start [i];
7575 if (c >= sizeof (dbase64)) {
7576 exc = mono_exception_from_name_msg (mono_get_corlib (),
7577 "System", "FormatException",
7578 "Invalid character found.");
7579 mono_raise_exception (exc);
7580 } else if (isspace (c)) {
7581 ignored++;
7582 } else {
7583 prev2_last = prev_last;
7584 prev_last = last;
7585 last = c;
7586 }
7587 }
7588
7589 olength = ilength - ignored;
7590
7591 if (allowWhitespaceOnly && olength == 0) {
7592 return mono_array_new (mono_domain_get (), mono_defaults.byte_class, 0);
7593 }
7594
7595 if ((olength & 3) != 0 || olength <= 0) {
7596 exc = mono_exception_from_name_msg (mono_get_corlib (), "System",
7597 "FormatException", "Invalid length.");
7598 mono_raise_exception (exc);
7599 }
7600
7601 if (prev2_last == '=') {
7602 exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid format.");
7603 mono_raise_exception (exc);
7604 }
7605
7606 olength = (olength * 3) / 4;
7607 if (last == '=')
7608 olength--;
7609
7610 if (prev_last == '=')
7611 olength--;
7612
7613 result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, olength);
7614 res_ptr = mono_array_addr (result, guchar, 0);
7615 for (i = 0; i < ilength; ) {
7616 int k;
7617
7618 for (k = 0; k < 4 && i < ilength;) {
7619 c = start [i++];
7620 if (isspace (c))
7621 continue;
7622
7623 a [k] = (guchar) c;
7624 if (((b [k] = dbase64 [c]) & 0x80) != 0) {
7625 exc = mono_exception_from_name_msg (mono_get_corlib (),
7626 "System", "FormatException",
7627 "Invalid character found.");
7628 mono_raise_exception (exc);
7629 }
7630 k++;
7631 }
7632
7633 *res_ptr++ = (b [0] << 2) | (b [1] >> 4);
7634 if (a [2] != '=')
7635 *res_ptr++ = (b [1] << 4) | (b [2] >> 2);
7636 if (a [3] != '=')
7637 *res_ptr++ = (b [2] << 6) | b [3];
7638
7639 while (i < ilength && isspace (start [i]))
7640 i++;
7641 }
7642
7643 return result;
7644 }
7645
7646 static MonoArray *
7647 InternalFromBase64String (MonoString *str, MonoBoolean allowWhitespaceOnly)
7648 {
7649 MONO_ARCH_SAVE_REGS;
7650
7651 return base64_to_byte_array (mono_string_chars (str),
7652 mono_string_length (str), allowWhitespaceOnly);
7653 }
7654
7655 static MonoArray *
7656 InternalFromBase64CharArray (MonoArray *input, gint offset, gint length)
7657 {
7658 MONO_ARCH_SAVE_REGS;
7659
7660 return base64_to_byte_array (mono_array_addr (input, gunichar2, offset),
7661 length, FALSE);
7662 }
7663
7664 #define ICALL_TYPE(id,name,first)
7665 #define ICALL(id,name,func) Icall_ ## id,
7666
7667 enum {
7668 #include "metadata/icall-def.h"
7669 Icall_last
7670 };
7671
7672 #undef ICALL_TYPE
7673 #undef ICALL
7674 #define ICALL_TYPE(id,name,first) Icall_type_ ## id,
7675 #define ICALL(id,name,func)
7676 enum {
7677 #include "metadata/icall-def.h"
7678 Icall_type_num
7679 };
7680
7681 #undef ICALL_TYPE
7682 #undef ICALL
7683 #define ICALL_TYPE(id,name,firstic) {(Icall_ ## firstic)},
7684 #define ICALL(id,name,func)
7685 typedef struct {
7686 guint16 first_icall;
7687 } IcallTypeDesc;
7688
7689 static const IcallTypeDesc
7690 icall_type_descs [] = {
7691 #include "metadata/icall-def.h"
7692 {Icall_last}
7693 };
7694
7695 #define icall_desc_num_icalls(desc) ((desc) [1].first_icall - (desc) [0].first_icall)
7696
7697 #undef ICALL_TYPE
7698 #define ICALL_TYPE(id,name,first)
7699 #undef ICALL
7700
7701 #ifdef HAVE_ARRAY_ELEM_INIT
7702 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
7703 #define MSGSTRFIELD1(line) str##line
7704
7705 static const struct msgstrtn_t {
7706 #define ICALL(id,name,func)
7707 #undef ICALL_TYPE
7708 #define ICALL_TYPE(id,name,first) char MSGSTRFIELD(__LINE__) [sizeof (name)];
7709 #include "metadata/icall-def.h"
7710 #undef ICALL_TYPE
7711 } icall_type_names_str = {
7712 #define ICALL_TYPE(id,name,first) (name),
7713 #include "metadata/icall-def.h"
7714 #undef ICALL_TYPE
7715 };
7716 static const guint16 icall_type_names_idx [] = {
7717 #define ICALL_TYPE(id,name,first) [Icall_type_ ## id] = offsetof (struct msgstrtn_t, MSGSTRFIELD(__LINE__)),
7718 #include "metadata/icall-def.h"
7719 #undef ICALL_TYPE
7720 };
7721 #define icall_type_name_get(id) ((const char*)&icall_type_names_str + icall_type_names_idx [(id)])
7722
7723 static const struct msgstr_t {
7724 #undef ICALL
7725 #define ICALL_TYPE(id,name,first)
7726 #define ICALL(id,name,func) char MSGSTRFIELD(__LINE__) [sizeof (name)];
7727 #include "metadata/icall-def.h"
7728 #undef ICALL
7729 } icall_names_str = {
7730 #define ICALL(id,name,func) (name),
7731 #include "metadata/icall-def.h"
7732 #undef ICALL
7733 };
7734 static const guint16 icall_names_idx [] = {
7735 #define ICALL(id,name,func) [Icall_ ## id] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
7736 #include "metadata/icall-def.h"
7737 #undef ICALL
7738 };
7739 #define icall_name_get(id) ((const char*)&icall_names_str + icall_names_idx [(id)])
7740
7741 #else
7742
7743 #undef ICALL_TYPE
7744 #undef ICALL
7745 #define ICALL_TYPE(id,name,first) name,
7746 #define ICALL(id,name,func)
7747 static const char* const
7748 icall_type_names [] = {
7749 #include "metadata/icall-def.h"
7750 NULL
7751 };
7752
7753 #define icall_type_name_get(id) (icall_type_names [(id)])
7754
7755 #undef ICALL_TYPE
7756 #undef ICALL
7757 #define ICALL_TYPE(id,name,first)
7758 #define ICALL(id,name,func) name,
7759 static const char* const
7760 icall_names [] = {
7761 #include "metadata/icall-def.h"
7762 NULL
7763 };
7764 #define icall_name_get(id) icall_names [(id)]
7765
7766 #endif /* !HAVE_ARRAY_ELEM_INIT */
7767
7768 #undef ICALL_TYPE
7769 #undef ICALL
7770 #define ICALL_TYPE(id,name,first)
7771 #define ICALL(id,name,func) func,
7772 static const gconstpointer
7773 icall_functions [] = {
7774 #include "metadata/icall-def.h"
7775 NULL
7776 };
7777
7778 static GHashTable *icall_hash = NULL;
7779 static GHashTable *jit_icall_hash_name = NULL;
7780 static GHashTable *jit_icall_hash_addr = NULL;
7781
7782 void
7783 mono_icall_init (void)
7784 {
7785 int i = 0;
7786
7787 /* check that tables are sorted: disable in release */
7788 if (TRUE) {
7789 int j;
7790 const char *prev_class = NULL;
7791 const char *prev_method;
7792
7793 for (i = 0; i < Icall_type_num; ++i) {
7794 const IcallTypeDesc *desc;
7795 int num_icalls;
7796 prev_method = NULL;
7797 if (prev_class && strcmp (prev_class, icall_type_name_get (i)) >= 0)
7798 g_print ("class %s should come before class %s\n", icall_type_name_get (i), prev_class);
7799 prev_class = icall_type_name_get (i);
7800 desc = &icall_type_descs [i];
7801 num_icalls = icall_desc_num_icalls (desc);
7802 /*g_print ("class %s has %d icalls starting at %d\n", prev_class, num_icalls, desc->first_icall);*/
7803 for (j = 0; j < num_icalls; ++j) {
7804 const char *methodn = icall_name_get (desc->first_icall + j);
7805 if (prev_method && strcmp (prev_method, methodn) >= 0)
7806 g_print ("method %s should come before method %s\n", methodn, prev_method);
7807 prev_method = methodn;
7808 }
7809 }
7810 }
7811
7812 icall_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
7813 }
7814
7815 void
7816 mono_icall_cleanup (void)
7817 {
7818 g_hash_table_destroy (icall_hash);
7819 g_hash_table_destroy (jit_icall_hash_name);
7820 g_hash_table_destroy (jit_icall_hash_addr);
7821 }
7822
7823 void
7824 mono_add_internal_call (const char *name, gconstpointer method)
7825 {
7826 mono_loader_lock ();
7827
7828 g_hash_table_insert (icall_hash, g_strdup (name), (gpointer) method);
7829
7830 mono_loader_unlock ();
7831 }
7832
7833 #ifdef HAVE_ARRAY_ELEM_INIT
7834 static int
7835 compare_method_imap (const void *key, const void *elem)
7836 {
7837 const char* method_name = (const char*)&icall_names_str + (*(guint16*)elem);
7838 return strcmp (key, method_name);
7839 }
7840
7841 static gpointer
7842 find_method_icall (const IcallTypeDesc *imap, const char *name)
7843 {
7844 const guint16 *nameslot = bsearch (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap);
7845 if (!nameslot)
7846 return NULL;
7847 return (gpointer)icall_functions [(nameslot - &icall_names_idx [0])];
7848 }
7849
7850 static int
7851 compare_class_imap (const void *key, const void *elem)
7852 {
7853 const char* class_name = (const char*)&icall_type_names_str + (*(guint16*)elem);
7854 return strcmp (key, class_name);
7855 }
7856
7857 static const IcallTypeDesc*
7858 find_class_icalls (const char *name)
7859 {
7860 const guint16 *nameslot = bsearch (name, icall_type_names_idx, Icall_type_num, sizeof (icall_type_names_idx [0]), compare_class_imap);
7861 if (!nameslot)
7862 return NULL;
7863 return &icall_type_descs [nameslot - &icall_type_names_idx [0]];
7864 }
7865
7866 #else
7867 static int
7868 compare_method_imap (const void *key, const void *elem)
7869 {
7870 const char** method_name = (const char**)elem;
7871 return strcmp (key, *method_name);
7872 }
7873
7874 static gpointer
7875 find_method_icall (const IcallTypeDesc *imap, const char *name)
7876 {
7877 const char **nameslot = bsearch (name, icall_names + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names [0]), compare_method_imap);
7878 if (!nameslot)
7879 return NULL;
7880 return (gpointer)icall_functions [(nameslot - icall_names)];
7881 }
7882
7883 static int
7884 compare_class_imap (const void *key, const void *elem)
7885 {
7886 const char** class_name = (const char**)elem;
7887 return strcmp (key, *class_name);
7888 }
7889
7890 static const IcallTypeDesc*
7891 find_class_icalls (const char *name)
7892 {
7893 const char **nameslot = bsearch (name, icall_type_names, Icall_type_num, sizeof (icall_type_names [0]), compare_class_imap);
7894 if (!nameslot)
7895 return NULL;
7896 return &icall_type_descs [nameslot - icall_type_names];
7897 }
7898
7899 #endif
7900
7901 /*
7902 * we should probably export this as an helper (handle nested types).
7903 * Returns the number of chars written in buf.
7904 */
7905 static int
7906 concat_class_name (char *buf, int bufsize, MonoClass *klass)
7907 {
7908 int nspacelen, cnamelen;
7909 nspacelen = strlen (klass->name_space);
7910 cnamelen = strlen (klass->name);
7911 if (nspacelen + cnamelen + 2 > bufsize)
7912 return 0;
7913 if (nspacelen) {
7914 memcpy (buf, klass->name_space, nspacelen);
7915 buf [nspacelen ++] = '.';
7916 }
7917 memcpy (buf + nspacelen, klass->name, cnamelen);
7918 buf [nspacelen + cnamelen] = 0;
7919 return nspacelen + cnamelen;
7920 }
7921
7922 gpointer
7923 mono_lookup_internal_call (MonoMethod *method)
7924 {
7925 char *sigstart;
7926 char *tmpsig;
7927 char mname [2048];
7928 int typelen = 0, mlen, siglen;
7929 gpointer res;
7930 const IcallTypeDesc *imap;
7931
7932 g_assert (method != NULL);
7933
7934 if (method->is_inflated)
7935 method = ((MonoMethodInflated *) method)->declaring;
7936
7937 if (method->klass->nested_in) {
7938 int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in);
7939 if (!pos)
7940 return NULL;
7941
7942 mname [pos++] = '/';
7943 mname [pos] = 0;
7944
7945 typelen = concat_class_name (mname+pos, sizeof (mname)-pos-1, method->klass);
7946 if (!typelen)
7947 return NULL;
7948
7949 typelen += pos;
7950 } else {
7951 typelen = concat_class_name (mname, sizeof (mname), method->klass);
7952 if (!typelen)
7953 return NULL;
7954 }
7955
7956 imap = find_class_icalls (mname);
7957
7958 mname [typelen] = ':';
7959 mname [typelen + 1] = ':';
7960
7961 mlen = strlen (method->name);
7962 memcpy (mname + typelen + 2, method->name, mlen);
7963 sigstart = mname + typelen + 2 + mlen;
7964 *sigstart = 0;
7965
7966 tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
7967 siglen = strlen (tmpsig);
7968 if (typelen + mlen + siglen + 6 > sizeof (mname))
7969 return NULL;
7970 sigstart [0] = '(';
7971 memcpy (sigstart + 1, tmpsig, siglen);
7972 sigstart [siglen + 1] = ')';
7973 sigstart [siglen + 2] = 0;
7974 g_free (tmpsig);
7975
7976 mono_loader_lock ();
7977
7978 res = g_hash_table_lookup (icall_hash, mname);
7979 if (res) {
7980 mono_loader_unlock ();
7981 return res;
7982 }
7983 /* try without signature */
7984 *sigstart = 0;
7985 res = g_hash_table_lookup (icall_hash, mname);
7986 if (res) {
7987 mono_loader_unlock ();
7988 return res;
7989 }
7990
7991 /* it wasn't found in the static call tables */
7992 if (!imap) {
7993 mono_loader_unlock ();
7994 return NULL;
7995 }
7996 res = find_method_icall (imap, sigstart - mlen);
7997 if (res) {
7998 mono_loader_unlock ();
7999 return res;
8000 }
8001 /* try _with_ signature */
8002 *sigstart = '(';
8003 res = find_method_icall (imap, sigstart - mlen);
8004 if (res) {
8005 mono_loader_unlock ();
8006 return res;
8007 }
8008
8009 g_warning ("cant resolve internal call to \"%s\" (tested without signature also)", mname);
8010 g_print ("\nYour mono runtime and class libraries are out of sync.\n");
8011 g_print ("The out of sync library is: %s\n", method->klass->image->name);
8012 g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n");
8013 g_print ("Do not report this as a bug unless you're sure you have updated correctly:\nyou probably have a broken mono install.\n");
8014 g_print ("If you see other errors or faults after this message they are probably related\n");
8015 g_print ("and you need to fix your mono install first.\n");
8016
8017 mono_loader_unlock ();
8018
8019 return NULL;
8020 }
8021
8022 static MonoType*
8023 type_from_typename (char *typename)
8024 {
8025 MonoClass *klass = NULL; /* assignment to shut GCC warning up */
8026
8027 if (!strcmp (typename, "int"))
8028 klass = mono_defaults.int_class;
8029 else if (!strcmp (typename, "ptr"))
8030 klass = mono_defaults.int_class;
8031 else if (!strcmp (typename, "void"))
8032 klass = mono_defaults.void_class;
8033 else if (!strcmp (typename, "int32"))
8034 klass = mono_defaults.int32_class;
8035 else if (!strcmp (typename, "uint32"))
8036 klass = mono_defaults.uint32_class;
8037 else if (!strcmp (typename, "int8"))
8038 klass = mono_defaults.sbyte_class;
8039 else if (!strcmp (typename, "uint8"))
8040 klass = mono_defaults.byte_class;
8041 else if (!strcmp (typename, "int16"))
8042 klass = mono_defaults.int16_class;
8043 else if (!strcmp (typename, "uint16"))
8044 klass = mono_defaults.uint16_class;
8045 else if (!strcmp (typename, "long"))
8046 klass = mono_defaults.int64_class;
8047 else if (!strcmp (typename, "ulong"))
8048 klass = mono_defaults.uint64_class;
8049 else if (!strcmp (typename, "float"))
8050 klass = mono_defaults.single_class;
8051 else if (!strcmp (typename, "double"))
8052 klass = mono_defaults.double_class;
8053 else if (!strcmp (typename, "object"))
8054 klass = mono_defaults.object_class;
8055 else if (!strcmp (typename, "obj"))
8056 klass = mono_defaults.object_class;
8057 else if (!strcmp (typename, "string"))
8058 klass = mono_defaults.string_class;
8059 else if (!strcmp (typename, "bool"))
8060 klass = mono_defaults.boolean_class;
8061 else if (!strcmp (typename, "boolean"))
8062 klass = mono_defaults.boolean_class;
8063 else {
8064 g_error ("%s", typename);
8065 g_assert_not_reached ();
8066 }
8067 return &klass->byval_arg;
8068 }
8069
8070 MonoMethodSignature*
8071 mono_create_icall_signature (const char *sigstr)
8072 {
8073 gchar **parts;
8074 int i, len;
8075 gchar **tmp;
8076 MonoMethodSignature *res;
8077
8078 mono_loader_lock ();
8079 res = g_hash_table_lookup (mono_defaults.corlib->helper_signatures, sigstr);
8080 if (res) {
8081 mono_loader_unlock ();
8082 return res;
8083 }
8084
8085 parts = g_strsplit (sigstr, " ", 256);
8086
8087 tmp = parts;
8088 len = 0;
8089 while (*tmp) {
8090 len ++;
8091 tmp ++;
8092 }
8093
8094 res = mono_metadata_signature_alloc (mono_defaults.corlib, len - 1);
8095 res->pinvoke = 1;
8096
8097 #ifdef PLATFORM_WIN32
8098 /*
8099 * Under windows, the default pinvoke calling convention is STDCALL but
8100 * we need CDECL.
8101 */
8102 res->call_convention = MONO_CALL_C;
8103 #endif
8104
8105 res->ret = type_from_typename (parts [0]);
8106 for (i = 1; i < len; ++i) {
8107 res->params [i - 1] = type_from_typename (parts [i]);
8108 }
8109
8110 g_strfreev (parts);
8111
8112 g_hash_table_insert (mono_defaults.corlib->helper_signatures, (gpointer)sigstr, res);
8113
8114 mono_loader_unlock ();
8115
8116 return res;
8117 }
8118
8119 MonoJitICallInfo *
8120 mono_find_jit_icall_by_name (const char *name)
8121 {
8122 MonoJitICallInfo *info;
8123 g_assert (jit_icall_hash_name);
8124
8125 mono_loader_lock ();
8126 info = g_hash_table_lookup (jit_icall_hash_name, name);
8127 mono_loader_unlock ();
8128 return info;
8129 }
8130
8131 MonoJitICallInfo *
8132 mono_find_jit_icall_by_addr (gconstpointer addr)
8133 {
8134 MonoJitICallInfo *info;
8135 g_assert (jit_icall_hash_addr);
8136
8137 mono_loader_lock ();
8138 info = g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr);
8139 mono_loader_unlock ();
8140
8141 return info;
8142 }
8143
8144 /*
8145 * mono_get_jit_icall_info:
8146 *
8147 * Return the hashtable mapping JIT icall names to MonoJitICallInfo structures. The
8148 * caller should access it while holding the loader lock.
8149 */
8150 GHashTable*
8151 mono_get_jit_icall_info (void)
8152 {
8153 return jit_icall_hash_name;
8154 }
8155
8156 void
8157 mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
8158 {
8159 mono_loader_lock ();
8160 g_hash_table_insert (jit_icall_hash_addr, (gpointer)wrapper, info);
8161 mono_loader_unlock ();
8162 }
8163
8164 MonoJitICallInfo *
8165 mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
8166 {
8167 MonoJitICallInfo *info;
8168
8169 g_assert (func);
8170 g_assert (name);
8171
8172 mono_loader_lock ();
8173
8174 if (!jit_icall_hash_name) {
8175 jit_icall_hash_name = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
8176 jit_icall_hash_addr = g_hash_table_new (NULL, NULL);
8177 }
8178
8179 if (g_hash_table_lookup (jit_icall_hash_name, name)) {
8180 g_warning ("jit icall already defined \"%s\"\n", name);
8181 g_assert_not_reached ();
8182 }
8183
8184 info = g_new0 (MonoJitICallInfo, 1);
8185
8186 info->name = name;
8187 info->func = func;
8188 info->sig = sig;
8189
8190 if (is_save) {
8191 info->wrapper = func;
8192 } else {
8193 info->wrapper = NULL;
8194 }
8195
8196 g_hash_table_insert (jit_icall_hash_name, (gpointer)info->name, info);
8197 g_hash_table_insert (jit_icall_hash_addr, (gpointer)func, info);
8198
8199 mono_loader_unlock ();
8200 return info;
8201 }
ppc64 and Haiku ports