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