mono/tests/libtest.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <glib.h>
   5 #include <errno.h>
   6 #include <time.h>
   7
   8 #ifdef WIN32
   9 #include <windows.h>
  10 #endif
  11
  12 #ifdef WIN32
  13 #define STDCALL __stdcall
  14 #else
  15 #define STDCALL
  16 #endif
  17
  18 #ifdef WIN32
  19 extern __declspec(dllimport) __stdcall void CoTaskMemFree(void *ptr);
  20 #endif
  21
  22 typedef int (STDCALL *SimpleDelegate) (int a);
  23
  24 static void marshal_free (void *ptr)
  25 {
  26 #ifdef WIN32
  27         CoTaskMemFree (ptr);
  28 #else
  29         g_free (ptr);
  30 #endif
  31 }
  32
  33 STDCALL unsigned short*
  34 test_lpwstr_marshal (unsigned short* chars, long length)
  35 {
  36         int i = 0;
  37         unsigned short *res;
  38
  39         res = malloc (2 * (length + 1));
  40
  41         // printf("test_lpwstr_marshal()\n");
  42
  43         while ( i < length ) {
  44                 // printf("X|%u|\n", chars[i]);
  45                 res [i] = chars[i];
  46                 i++;
  47         }
  48
  49         res [i] = 0;
  50
  51         return res;
  52 }
  53
  54 typedef struct {
  55         int b;
  56         int a;
  57         int c;
  58 } union_test_1_type;
  59
  60 STDCALL int
  61 mono_union_test_1 (union_test_1_type u1) {
  62         // printf ("Got values %d %d %d\n", u1.b, u1.a, u1.c);
  63         return u1.a + u1.b + u1.c;
  64 }
  65
  66 STDCALL int
  67 mono_return_int (int a) {
  68         // printf ("Got value %d\n", a);
  69         return a;
  70 }
  71
  72 struct ss
  73 {
  74         int i;
  75 };
  76
  77 STDCALL int
  78 mono_return_int_ss (struct ss a) {
  79         // printf ("Got value %d\n", a.i);
  80         return a.i;
  81 }
  82
  83 STDCALL struct ss
  84 mono_return_ss (struct ss a) {
  85         // printf ("Got value %d\n", a.i);
  86         a.i++;
  87         return a;
  88 }
  89
  90 struct sc1
  91 {
  92         char c[1];
  93 };
  94
  95 STDCALL struct sc1
  96 mono_return_sc1 (struct sc1 a) {
  97         // printf ("Got value %d\n", a.c[0]);
  98         a.c[0]++;
  99         return a;
 100 }
 101
 102
 103 struct sc3
 104 {
 105         char c[3];
 106 };
 107
 108 STDCALL struct sc3
 109 mono_return_sc3 (struct sc3 a) {
 110         // printf ("Got values %d %d %d\n", a.c[0], a.c[1], a.c[2]);
 111         a.c[0]++;
 112         a.c[1] += 2;
 113         a.c[2] += 3;
 114         return a;
 115 }
 116
 117 struct sc5
 118 {
 119         char c[5];
 120 };
 121
 122 STDCALL struct sc5
 123 mono_return_sc5 (struct sc5 a) {
 124         // printf ("Got values %d %d %d %d %d\n", a.c[0], a.c[1], a.c[2], a.c[3], a.c[4]);
 125         a.c[0]++;
 126         a.c[1] += 2;
 127         a.c[2] += 3;
 128         a.c[3] += 4;
 129         a.c[4] += 5;
 130         return a;
 131 }
 132
 133 union su
 134 {
 135         int i1;
 136         int i2;
 137 };
 138
 139 STDCALL int
 140 mono_return_int_su (union su a) {
 141         // printf ("Got value %d\n", a.i1);
 142         return a.i1;
 143 }
 144
 145 STDCALL int
 146 mono_test_many_int_arguments (int a, int b, int c, int d, int e,
 147                                                           int f, int g, int h, int i, int j);
 148 STDCALL short
 149 mono_test_many_short_arguments (short a, short b, short c, short d, short e,
 150                                                                 short f, short g, short h, short i, short j);
 151 STDCALL char
 152 mono_test_many_char_arguments (char a, char b, char c, char d, char e,
 153                                                            char f, char g, char h, char i, char j);
 154
 155 STDCALL int
 156 mono_test_many_int_arguments (int a, int b, int c, int d, int e, int f, int g, int h, int i, int j)
 157 {
 158         return a + b + c + d + e + f + g + h + i + j;
 159 }
 160
 161 STDCALL short
 162 mono_test_many_short_arguments (short a, short b, short c, short d, short e, short f, short g, short h, short i, short j)
 163 {
 164         return a + b + c + d + e + f + g + h + i + j;
 165 }
 166
 167 STDCALL char
 168 mono_test_many_byte_arguments (char a, char b, char c, char d, char e, char f, char g, char h, char i, char j)
 169 {
 170         return a + b + c + d + e + f + g + h + i + j;
 171 }
 172
 173 STDCALL float
 174 mono_test_many_float_arguments (float a, float b, float c, float d, float e, float f, float g, float h, float i, float j)
 175 {
 176         return a + b + c + d + e + f + g + h + i + j;
 177 }
 178
 179 STDCALL double
 180 mono_test_many_double_arguments (double a, double b, double c, double d, double e, double f, double g, double h, double i, double j)
 181 {
 182         return a + b + c + d + e + f + g + h + i + j;
 183 }
 184
 185 STDCALL double
 186 mono_test_split_double_arguments (double a, double b, float c, double d, double e)
 187 {
 188         return a + b + c + d + e;
 189 }
 190
 191 STDCALL int
 192 mono_test_puts_static (char *s)
 193 {
 194         // printf ("TEST %s\n", s);
 195         return 1;
 196 }
 197
 198 typedef int (STDCALL *SimpleDelegate3) (int a, int b);
 199
 200 STDCALL int
 201 mono_invoke_delegate (SimpleDelegate3 delegate)
 202 {
 203         int res;
 204
 205         // printf ("start invoke %p\n", delegate);
 206
 207         res = delegate (2, 3);
 208
 209         // printf ("end invoke\n");
 210
 211         return res;
 212 }
 213
 214 STDCALL int
 215 mono_test_marshal_char (short a1)
 216 {
 217         if (a1 == 'a')
 218                 return 0;
 219
 220         return 1;
 221 }
 222
 223 STDCALL void
 224 mono_test_marshal_char_array (gunichar2 *s)
 225 {
 226         const char m[] = "abcdef";
 227         gunichar2* s2;
 228         glong len;
 229
 230         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
 231
 232         len = (len * 2) + 2;
 233         memcpy (s, s2, len);
 234
 235         g_free (s2);
 236 }
 237
 238 STDCALL int
 239 mono_test_empty_pinvoke (int i)
 240 {
 241         return i;
 242 }
 243
 244 STDCALL int
 245 mono_test_marshal_bool_byref (int a, int *b, int c)
 246 {
 247     int res = *b;
 248
 249         *b = 1;
 250
 251         return res;
 252 }
 253
 254 STDCALL int
 255 mono_test_marshal_array (int *a1)
 256 {
 257         int i, sum = 0;
 258
 259         for (i = 0; i < 50; i++)
 260                 sum += a1 [i];
 261
 262         return sum;
 263 }
 264
 265 STDCALL int
 266 mono_test_marshal_inout_array (int *a1)
 267 {
 268         int i, sum = 0;
 269
 270         for (i = 0; i < 50; i++) {
 271                 sum += a1 [i];
 272                 a1 [i] = 50 - a1 [i];
 273         }
 274
 275         return sum;
 276 }
 277
 278 STDCALL int
 279 mono_test_marshal_out_array (int *a1)
 280 {
 281         int i;
 282
 283         for (i = 0; i < 50; i++) {
 284                 a1 [i] = i;
 285         }
 286
 287         return 0;
 288 }
 289
 290 STDCALL int
 291 mono_test_marshal_inout_nonblittable_array (gunichar2 *a1)
 292 {
 293         int i, sum = 0;
 294
 295         for (i = 0; i < 10; i++) {
 296                 a1 [i] = 'F';
 297         }
 298
 299         return sum;
 300 }
 301
 302 typedef struct {
 303         int a;
 304         int b;
 305         int c;
 306         const char *d;
 307         gunichar2 *d2;
 308 } simplestruct;
 309
 310 typedef struct {
 311         double x;
 312         double y;
 313 } point;
 314
 315 STDCALL simplestruct
 316 mono_test_return_vtype (int i)
 317 {
 318         simplestruct res;
 319         static gunichar2 test2 [] = { 'T', 'E', 'S', 'T', '2', 0 };
 320
 321         res.a = 0;
 322         res.b = 1;
 323         res.c = 0;
 324         res.d = "TEST";
 325         res.d2 = test2;
 326
 327         return res;
 328 }
 329
 330 STDCALL void
 331 mono_test_delegate_struct (void)
 332 {
 333         // printf ("TEST\n");
 334 }
 335
 336 typedef char* (STDCALL *ReturnStringDelegate) (const char *s);
 337
 338 STDCALL char *
 339 mono_test_return_string (ReturnStringDelegate func)
 340 {
 341         char *res;
 342
 343         // printf ("mono_test_return_string\n");
 344
 345         res = func ("TEST");
 346         marshal_free (res);
 347
 348         // printf ("got string: %s\n", res);
 349         return g_strdup ("12345");
 350 }
 351
 352 typedef int (STDCALL *RefVTypeDelegate) (int a, simplestruct *ss, int b);
 353
 354 STDCALL int
 355 mono_test_ref_vtype (int a, simplestruct *ss, int b, RefVTypeDelegate func)
 356 {
 357         if (a == 1 && b == 2 && ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 358             !strcmp (ss->d, "TEST1")) {
 359                 ss->a = 1;
 360                 ss->b = 0;
 361                 ss->c = 1;
 362                 ss->d = "TEST2";
 363
 364                 return func (a, ss, b);
 365         }
 366
 367         return 1;
 368 }
 369
 370 typedef int (STDCALL *OutVTypeDelegate) (int a, simplestruct *ss, int b);
 371
 372 STDCALL int
 373 mono_test_marshal_out_struct (int a, simplestruct *ss, int b, OutVTypeDelegate func)
 374 {
 375         /* Check that the input pointer is ignored */
 376         ss->d = (gpointer)0x12345678;
 377
 378         func (a, ss, b);
 379
 380         if (ss->a && ss->b && ss->c && !strcmp (ss->d, "TEST3"))
 381                 return 0;
 382         else
 383                 return 1;
 384 }
 385
 386 typedef struct {
 387         int a;
 388         SimpleDelegate func, func2;
 389 } DelegateStruct;
 390
 391 STDCALL DelegateStruct
 392 mono_test_marshal_delegate_struct (DelegateStruct ds)
 393 {
 394         DelegateStruct res;
 395
 396         res.a = ds.func (ds.a) + ds.func2 (ds.a);
 397         res.func = ds.func;
 398         res.func2 = ds.func2;
 399
 400         return res;
 401 }
 402
 403 STDCALL int
 404 mono_test_marshal_struct (simplestruct ss)
 405 {
 406         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 407             !strcmp (ss.d, "TEST"))
 408                 return 0;
 409
 410         return 1;
 411 }
 412
 413 STDCALL int
 414 mono_test_marshal_byref_struct (simplestruct *ss, int a, int b, int c, char *d)
 415 {
 416         gboolean res = (ss->a == a && ss->b == b && ss->c == c && strcmp (ss->d, d) == 0);
 417
 418         ss->a = !ss->a;
 419         ss->b = !ss->b;
 420         ss->c = !ss->c;
 421         ss->d = g_strdup ("DEF");
 422
 423         return res ? 0 : 1;
 424 }
 425
 426 typedef struct {
 427         int a;
 428         int b;
 429         int c;
 430         char *d;
 431         unsigned char e;
 432         double f;
 433         unsigned char g;
 434         guint64 h;
 435 } simplestruct2;
 436
 437 STDCALL int
 438 mono_test_marshal_struct2 (simplestruct2 ss)
 439 {
 440         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 441             !strcmp (ss.d, "TEST") &&
 442             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
 443                 return 0;
 444
 445         return 1;
 446 }
 447
 448 /* on HP some of the struct should be on the stack and not in registers */
 449 STDCALL int
 450 mono_test_marshal_struct2_2 (int i, int j, int k, simplestruct2 ss)
 451 {
 452         if (i != 10 || j != 11 || k != 12)
 453                 return 1;
 454         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 455             !strcmp (ss.d, "TEST") &&
 456             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
 457                 return 0;
 458
 459         return 1;
 460 }
 461
 462 STDCALL int
 463 mono_test_marshal_lpstruct (simplestruct *ss)
 464 {
 465         if (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 466             !strcmp (ss->d, "TEST"))
 467                 return 0;
 468
 469         return 1;
 470 }
 471
 472 STDCALL int
 473 mono_test_marshal_lpstruct_blittable (point *p)
 474 {
 475         if (p->x == 1.0 && p->y == 2.0)
 476                 return 0;
 477         else
 478                 return 1;
 479 }
 480
 481 STDCALL int
 482 mono_test_marshal_struct_array (simplestruct2 *ss)
 483 {
 484         if (! (ss[0].a == 0 && ss[0].b == 1 && ss[0].c == 0 &&
 485                    !strcmp (ss[0].d, "TEST") &&
 486                    ss[0].e == 99 && ss[0].f == 1.5 && ss[0].g == 42 && ss[0].h == (guint64)123))
 487                 return 1;
 488
 489         if (! (ss[1].a == 0 && ss[1].b == 0 && ss[1].c == 0 &&
 490                    !strcmp (ss[1].d, "TEST2") &&
 491                    ss[1].e == 100 && ss[1].f == 2.5 && ss[1].g == 43 && ss[1].h == (guint64)124))
 492                 return 1;
 493
 494         return 0;
 495 }
 496
 497 typedef struct long_align_struct {
 498         gint32 a;
 499         gint64 b;
 500         gint64 c;
 501 } long_align_struct;
 502
 503 STDCALL int
 504 mono_test_marshal_long_align_struct_array (long_align_struct *ss)
 505 {
 506         return ss[0].a + ss[0].b + ss[0].c + ss[1].a + ss[1].b + ss[1].c;
 507 }
 508
 509 STDCALL simplestruct2 *
 510 mono_test_marshal_class (int i, int j, int k, simplestruct2 *ss, int l)
 511 {
 512         simplestruct2 *res;
 513
 514         if (!ss)
 515                 return NULL;
 516
 517         if (i != 10 || j != 11 || k != 12 || l != 14)
 518                 return NULL;
 519         if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 520                    !strcmp (ss->d, "TEST") &&
 521                    ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
 522                 return NULL;
 523
 524         res = g_new0 (simplestruct2, 1);
 525         memcpy (res, ss, sizeof (simplestruct2));
 526         res->d = g_strdup ("TEST");
 527         return res;
 528 }
 529
 530 STDCALL int
 531 mono_test_marshal_byref_class (simplestruct2 **ssp)
 532 {
 533         simplestruct2 *ss = *ssp;
 534         simplestruct2 *res;
 535
 536         if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 537                    !strcmp (ss->d, "TEST") &&
 538                    ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
 539                 return 1;
 540
 541         res = g_new0 (simplestruct2, 1);
 542         memcpy (res, ss, sizeof (simplestruct2));
 543         res->d = g_strdup ("TEST-RES");
 544
 545         *ssp = res;
 546         return 0;
 547 }
 548
 549 static void *
 550 get_sp (void)
 551 {
 552         int i;
 553         void *p;
 554
 555         /* Yes, this is correct, we are only trying to determine the value of the stack here */
 556         p = &i;
 557         return p;
 558 }
 559
 560 STDCALL int
 561 reliable_delegate (int a)
 562 {
 563         return a;
 564 }
 565
 566 /*
 567  * Checks whether get_sp() works as expected. It doesn't work with gcc-2.95.3 on linux.
 568  */
 569 static gboolean
 570 is_get_sp_reliable (void)
 571 {
 572         void *sp1, *sp2;
 573
 574         reliable_delegate(1);
 575         sp1 = get_sp();
 576         reliable_delegate(1);
 577         sp2 = get_sp();
 578         return sp1 == sp2;
 579 }
 580
 581 STDCALL int
 582 mono_test_marshal_delegate (SimpleDelegate delegate)
 583 {
 584         void *sp1, *sp2;
 585
 586         /* Check that the delegate wrapper is stdcall */
 587         delegate (2);
 588         sp1 = get_sp ();
 589         delegate (2);
 590         sp2 = get_sp ();
 591         if (is_get_sp_reliable())
 592                 g_assert (sp1 == sp2);
 593
 594         return delegate (2);
 595 }
 596
 597 STDCALL SimpleDelegate
 598 mono_test_marshal_return_delegate (SimpleDelegate delegate)
 599 {
 600         return delegate;
 601 }
 602
 603 static STDCALL int
 604 return_plus_one (int i)
 605 {
 606         return i + 1;
 607 }
 608
 609 STDCALL SimpleDelegate
 610 mono_test_marshal_return_delegate_2 ()
 611 {
 612         return return_plus_one;
 613 }
 614
 615 typedef simplestruct (STDCALL *SimpleDelegate2) (simplestruct ss);
 616
 617 static gboolean
 618 is_utf16_equals (gunichar2 *s1, const char *s2)
 619 {
 620         char *s;
 621         int res;
 622
 623         s = g_utf16_to_utf8 (s1, -1, NULL, NULL, NULL);
 624         res = strcmp (s, s2);
 625         g_free (s);
 626
 627         return res == 0;
 628 }
 629
 630 STDCALL int
 631 mono_test_marshal_delegate2 (SimpleDelegate2 delegate)
 632 {
 633         simplestruct ss, res;
 634
 635         ss.a = 0;
 636         ss.b = 1;
 637         ss.c = 0;
 638         ss.d = "TEST";
 639         ss.d2 = g_utf8_to_utf16 ("TEST2", -1, NULL, NULL, NULL);
 640
 641         res = delegate (ss);
 642         if (! (res.a && !res.b && res.c && !strcmp (res.d, "TEST-RES") && is_utf16_equals (res.d2, "TEST2-RES")))
 643                 return 1;
 644
 645         return 0;
 646 }
 647
 648 typedef simplestruct* (STDCALL *SimpleDelegate4) (simplestruct *ss);
 649
 650 STDCALL int
 651 mono_test_marshal_delegate4 (SimpleDelegate4 delegate)
 652 {
 653         simplestruct ss;
 654         simplestruct *res;
 655
 656         ss.a = 0;
 657         ss.b = 1;
 658         ss.c = 0;
 659         ss.d = "TEST";
 660
 661         /* Check argument */
 662         res = delegate (&ss);
 663         if (!res)
 664                 return 1;
 665
 666         /* Check return value */
 667         if (! (!res->a && res->b && !res->c && !strcmp (res->d, "TEST")))
 668                 return 2;
 669
 670         /* Check NULL argument and NULL result */
 671         res = delegate (NULL);
 672         if (res)
 673                 return 3;
 674
 675         return 0;
 676 }
 677
 678 typedef int (STDCALL *SimpleDelegate5) (simplestruct **ss);
 679
 680 STDCALL int
 681 mono_test_marshal_delegate5 (SimpleDelegate5 delegate)
 682 {
 683         simplestruct ss;
 684         int res;
 685         simplestruct *ptr;
 686
 687         ss.a = 0;
 688         ss.b = 1;
 689         ss.c = 0;
 690         ss.d = "TEST";
 691
 692         ptr = &ss;
 693
 694         res = delegate (&ptr);
 695         if (res != 0)
 696                 return 1;
 697
 698         if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
 699                 return 2;
 700
 701         return 0;
 702 }
 703
 704 STDCALL int
 705 mono_test_marshal_delegate6 (SimpleDelegate5 delegate)
 706 {
 707         int res;
 708
 709         res = delegate (NULL);
 710
 711         return 0;
 712 }
 713
 714 typedef int (STDCALL *SimpleDelegate7) (simplestruct **ss);
 715
 716 STDCALL int
 717 mono_test_marshal_delegate7 (SimpleDelegate7 delegate)
 718 {
 719         int res;
 720         simplestruct *ptr;
 721
 722         /* Check that the input pointer is ignored */
 723         ptr = (gpointer)0x12345678;
 724
 725         res = delegate (&ptr);
 726         if (res != 0)
 727                 return 1;
 728
 729         if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
 730                 return 2;
 731
 732         return 0;
 733 }
 734
 735 typedef int (STDCALL *SimpleDelegate8) (gunichar2 *s);
 736
 737 STDCALL int
 738 mono_test_marshal_delegate8 (SimpleDelegate8 delegate, gunichar2 *s)
 739 {
 740         return delegate (s);
 741 }
 742
 743 typedef int (STDCALL *return_int_fnt) (int i);
 744 typedef int (STDCALL *SimpleDelegate9) (return_int_fnt d);
 745
 746 STDCALL int
 747 mono_test_marshal_delegate9 (SimpleDelegate9 delegate, gpointer ftn)
 748 {
 749         return delegate (ftn);
 750 }
 751
 752 STDCALL static int
 753 return_self (int i)
 754 {
 755         return i;
 756 }
 757
 758 STDCALL int
 759 mono_test_marshal_delegate10 (SimpleDelegate9 delegate)
 760 {
 761         return delegate (return_self);
 762 }
 763
 764 typedef int (STDCALL *PrimitiveByrefDelegate) (int *i);
 765
 766 STDCALL int
 767 mono_test_marshal_primitive_byref_delegate (PrimitiveByrefDelegate delegate)
 768 {
 769         int i = 1;
 770
 771         int res = delegate (&i);
 772         if (res != 0)
 773                 return res;
 774
 775         if (i != 2)
 776                 return 2;
 777
 778         return 0;
 779 }
 780
 781 typedef int (STDCALL *return_int_delegate) (int i);
 782
 783 typedef return_int_delegate (STDCALL *ReturnDelegateDelegate) (void);
 784
 785 STDCALL int
 786 mono_test_marshal_return_delegate_delegate (ReturnDelegateDelegate d)
 787 {
 788         return (d ()) (55);
 789 }
 790
 791 STDCALL int
 792 mono_test_marshal_stringbuilder (char *s, int n)
 793 {
 794         const char m[] = "This is my message.  Isn't it nice?";
 795
 796         if (strcmp (s, "ABCD") != 0)
 797                 return 1;
 798         strncpy(s, m, n);
 799         return 0;
 800 }
 801
 802 STDCALL int
 803 mono_test_marshal_stringbuilder_unicode (gunichar2 *s, int n)
 804 {
 805         const char m[] = "This is my message.  Isn't it nice?";
 806         gunichar2* s2;
 807         glong len;
 808
 809         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
 810
 811         len = (len * 2) + 2;
 812         if (len > n)
 813                 len = n;
 814         memcpy (s, s2, len);
 815
 816         g_free (s2);
 817
 818         return 0;
 819 }
 820
 821 typedef struct {
 822 #ifndef __GNUC__
 823     char a;
 824 #endif
 825 } EmptyStruct;
 826
 827 STDCALL int
 828 mono_test_marshal_empty_string_array (char **array)
 829 {
 830         return (array == NULL) ? 0 : 1;
 831 }
 832
 833 STDCALL int
 834 mono_test_marshal_string_array (char **array)
 835 {
 836         if (strcmp (array [0], "ABC"))
 837                 return 1;
 838         if (strcmp (array [1], "DEF"))
 839                 return 2;
 840
 841         if (array [2] != NULL)
 842                 return 3;
 843
 844         return 0;
 845 }
 846
 847 STDCALL int
 848 mono_test_marshal_byref_string_array (char ***array)
 849 {
 850         if (*array == NULL)
 851                 return 0;
 852
 853         if (strcmp ((*array) [0], "Alpha"))
 854                 return 2;
 855         if (strcmp ((*array) [1], "Beta"))
 856                 return 2;
 857         if (strcmp ((*array) [2], "Gamma"))
 858                 return 2;
 859
 860         return 1;
 861 }
 862
 863 STDCALL int
 864 mono_test_marshal_stringbuilder_array (char **array)
 865 {
 866         if (strcmp (array [0], "ABC"))
 867                 return 1;
 868         if (strcmp (array [1], "DEF"))
 869                 return 2;
 870
 871         strcpy (array [0], "DEF");
 872         strcpy (array [1], "ABC");
 873
 874         return 0;
 875 }
 876
 877 STDCALL int
 878 mono_test_marshal_unicode_string_array (gunichar2 **array, char **array2)
 879 {
 880         GError *error = NULL;
 881         char *s;
 882
 883         s = g_utf16_to_utf8 (array [0], -1, NULL, NULL, &error);
 884         if (strcmp (s, "ABC")) {
 885                 g_free (s);
 886                 return 1;
 887         }
 888         else
 889                 g_free (s);
 890
 891         s = g_utf16_to_utf8 (array [1], -1, NULL, NULL, &error);
 892         if (strcmp (s, "DEF")) {
 893                 g_free (s);
 894                 return 2;
 895         }
 896         else
 897                 g_free (s);
 898
 899         if (strcmp (array2 [0], "ABC"))
 900                 return 3;
 901
 902         if (strcmp (array2 [1], "DEF"))
 903                 return 4;
 904
 905         return 0;
 906 }
 907
 908 /* this does not work on Redhat gcc 2.96 */
 909 STDCALL int
 910 mono_test_empty_struct (int a, EmptyStruct es, int b)
 911 {
 912         // printf ("mono_test_empty_struct %d %d\n", a, b);
 913
 914         // Intel icc on ia64 passes 'es' in 2 registers
 915 #if defined(__ia64) && defined(__INTEL_COMPILER)
 916         return 0;
 917 #else
 918         if (a == 1 && b == 2)
 919                 return 0;
 920         return 1;
 921 #endif
 922 }
 923
 924 typedef struct {
 925        char a[100];
 926 } ByValStrStruct;
 927
 928 STDCALL ByValStrStruct *
 929 mono_test_byvalstr_gen (void)
 930 {
 931         ByValStrStruct *ret;
 932
 933         ret = malloc(sizeof(ByValStrStruct));
 934         memset(ret, 'a', sizeof(ByValStrStruct)-1);
 935         ret->a[sizeof(ByValStrStruct)-1] = 0;
 936
 937         return ret;
 938 }
 939
 940 STDCALL int
 941 mono_test_byvalstr_check (ByValStrStruct* data, char* correctString)
 942 {
 943         int ret;
 944
 945         ret = strcmp(data->a, correctString);
 946         // printf ("T1: %s\n", data->a);
 947         // printf ("T2: %s\n", correctString);
 948
 949         marshal_free (data);
 950         return (ret != 0);
 951 }
 952
 953 STDCALL int
 954 NameManglingAnsi (char *data)
 955 {
 956         return data [0] + data [1] + data [2];
 957 }
 958
 959 STDCALL int
 960 NameManglingAnsiA (char *data)
 961 {
 962         g_assert_not_reached ();
 963 }
 964
 965 STDCALL int
 966 NameManglingAnsiW (char *data)
 967 {
 968         g_assert_not_reached ();
 969 }
 970
 971 STDCALL int
 972 NameManglingAnsi2A (char *data)
 973 {
 974         return data [0] + data [1] + data [2];
 975 }
 976
 977 STDCALL int
 978 NameManglingAnsi2W (char *data)
 979 {
 980         g_assert_not_reached ();
 981 }
 982
 983 STDCALL int
 984 NameManglingUnicode (char *data)
 985 {
 986         g_assert_not_reached ();
 987 }
 988
 989 STDCALL int
 990 NameManglingUnicodeW (gunichar2 *data)
 991 {
 992         return data [0] + data [1] + data [2];
 993 }
 994
 995 STDCALL int
 996 NameManglingUnicode2 (gunichar2 *data)
 997 {
 998         return data [0] + data [1] + data [2];
 999 }
1000
1001 STDCALL int
1002 NameManglingAutoW (char *data)
1003 {
1004 #ifdef WIN32
1005         return (data [0] + data [1] + data [2]) == 131 ? 0 : 1;
1006 #else
1007         g_assert_not_reached ();
1008 #endif
1009 }
1010
1011 STDCALL int
1012 NameManglingAuto (char *data)
1013 {
1014 #ifndef WIN32
1015         return (data [0] + data [1] + data [2]) == 198 ? 0 : 1;
1016 #else
1017         g_assert_not_reached ();
1018 #endif
1019 }
1020
1021 typedef int (STDCALL *intcharFunc)(const char*);
1022
1023 STDCALL void
1024 callFunction (intcharFunc f)
1025 {
1026         f ("ABC");
1027 }
1028
1029 typedef struct {
1030         const char* str;
1031         int i;
1032 } SimpleObj;
1033
1034 STDCALL int
1035 class_marshal_test0 (SimpleObj *obj1)
1036 {
1037         // printf ("class_marshal_test0 %s %d\n", obj1->str, obj1->i);
1038
1039         if (strcmp(obj1->str, "T1"))
1040                 return -1;
1041         if (obj1->i != 4)
1042                 return -2;
1043
1044         return 0;
1045 }
1046
1047 STDCALL int
1048 class_marshal_test4 (SimpleObj *obj1)
1049 {
1050         if (obj1)
1051                 return -1;
1052
1053         return 0;
1054 }
1055
1056 STDCALL void
1057 class_marshal_test1 (SimpleObj **obj1)
1058 {
1059         SimpleObj *res = malloc (sizeof (SimpleObj));
1060
1061         res->str = g_strdup ("ABC");
1062         res->i = 5;
1063
1064         *obj1 = res;
1065 }
1066
1067 STDCALL int
1068 class_marshal_test2 (SimpleObj **obj1)
1069 {
1070         // printf ("class_marshal_test2 %s %d\n", (*obj1)->str, (*obj1)->i);
1071
1072         if (strcmp((*obj1)->str, "ABC"))
1073                 return -1;
1074         if ((*obj1)->i != 5)
1075                 return -2;
1076
1077         return 0;
1078 }
1079
1080 STDCALL int
1081 string_marshal_test0 (char *str)
1082 {
1083         if (strcmp (str, "TEST0"))
1084                 return -1;
1085
1086         return 0;
1087 }
1088
1089 STDCALL void
1090 string_marshal_test1 (const char **str)
1091 {
1092         *str = "TEST1";
1093 }
1094
1095 STDCALL int
1096 string_marshal_test2 (char **str)
1097 {
1098         // printf ("string_marshal_test2 %s\n", *str);
1099
1100         if (strcmp (*str, "TEST1"))
1101                 return -1;
1102
1103         return 0;
1104 }
1105
1106 STDCALL int
1107 string_marshal_test3 (char *str)
1108 {
1109         if (str)
1110                 return -1;
1111
1112         return 0;
1113 }
1114
1115 typedef struct {
1116         int a;
1117         int b;
1118 } VectorList;
1119
1120 STDCALL VectorList*
1121 TestVectorList (VectorList *vl)
1122 {
1123         VectorList *res;
1124
1125         // printf ("TestVectorList %d %d\n", vl->a, vl->b);
1126
1127         vl->a++;
1128         vl->b++;
1129
1130         res = g_new0 (VectorList, 1);
1131         memcpy (res, vl, sizeof (VectorList));
1132
1133         return res;
1134 }
1135
1136 typedef struct OSVERSIONINFO_STRUCT
1137 {
1138         int a;
1139         int b;
1140 } OSVERSIONINFO_STRUCT;
1141
1142 STDCALL int
1143 MyGetVersionEx (OSVERSIONINFO_STRUCT *osvi)
1144 {
1145
1146         // printf ("GOT %d %d\n", osvi->a, osvi->b);
1147
1148         osvi->a += 1;
1149         osvi->b += 1;
1150
1151         return osvi->a + osvi->b;
1152 }
1153
1154 STDCALL int
1155 BugGetVersionEx (int a, int b, int c, int d, int e, int f, int g, int h, OSVERSIONINFO_STRUCT *osvi)
1156 {
1157
1158         // printf ("GOT %d %d\n", osvi->a, osvi->b);
1159
1160         osvi->a += 1;
1161         osvi->b += 1;
1162
1163         return osvi->a + osvi->b;
1164 }
1165
1166 STDCALL int
1167 mono_test_marshal_point (point pt)
1168 {
1169         // printf("point %g %g\n", pt.x, pt.y);
1170         if (pt.x == 1.25 && pt.y == 3.5)
1171                 return 0;
1172
1173         return 1;
1174 }
1175
1176 typedef struct {
1177         int x;
1178         double y;
1179 } mixed_point;
1180
1181 STDCALL int
1182 mono_test_marshal_mixed_point (mixed_point pt)
1183 {
1184         // printf("mixed point %d %g\n", pt.x, pt.y);
1185         if (pt.x == 5 && pt.y == 6.75)
1186                 return 0;
1187
1188         return 1;
1189 }
1190
1191 STDCALL int
1192 mono_test_marshal_mixed_point_2 (mixed_point *pt)
1193 {
1194         if (pt->x != 5 || pt->y != 6.75)
1195                 return 1;
1196
1197         pt->x = 10;
1198         pt->y = 12.35;
1199
1200         return 0;
1201 }
1202
1203 STDCALL int
1204 marshal_test_ref_bool(int i, char *b1, short *b2, int *b3)
1205 {
1206     int res = 1;
1207     if (*b1 != 0 && *b1 != 1)
1208         return 1;
1209     if (*b2 != 0 && *b2 != -1) /* variant_bool */
1210         return 1;
1211     if (*b3 != 0 && *b3 != 1)
1212         return 1;
1213     if (i == ((*b1 << 2) | (-*b2 << 1) | *b3))
1214         res = 0;
1215     *b1 = !*b1;
1216     *b2 = ~*b2;
1217     *b3 = !*b3;
1218     return res;
1219 }
1220
1221 struct BoolStruct
1222 {
1223     int i;
1224     char b1;
1225     short b2; /* variant_bool */
1226     int b3;
1227 };
1228
1229 STDCALL int
1230 marshal_test_bool_struct(struct BoolStruct *s)
1231 {
1232     int res = 1;
1233     if (s->b1 != 0 && s->b1 != 1)
1234         return 1;
1235     if (s->b2 != 0 && s->b2 != -1)
1236         return 1;
1237     if (s->b3 != 0 && s->b3 != 1)
1238         return 1;
1239     if (s->i == ((s->b1 << 2) | (-s->b2 << 1) | s->b3))
1240         res = 0;
1241     s->b1 = !s->b1;
1242     s->b2 = ~s->b2;
1243     s->b3 = !s->b3;
1244     return res;
1245 }
1246
1247 STDCALL void
1248 mono_test_last_error (int err)
1249 {
1250 #ifdef WIN32
1251         SetLastError (err);
1252 #else
1253         errno = err;
1254 #endif
1255 }
1256
1257 STDCALL int
1258 mono_test_asany (void *ptr, int what)
1259 {
1260         switch (what) {
1261         case 1:
1262                 return (*(int*)ptr == 5) ? 0 : 1;
1263         case 2:
1264                 return strcmp (ptr, "ABC") == 0 ? 0 : 1;
1265         case 3: {
1266                 simplestruct2 ss = *(simplestruct2*)ptr;
1267
1268                 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
1269             !strcmp (ss.d, "TEST") &&
1270             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
1271                         return 0;
1272                 else
1273                         return 1;
1274         }
1275         case 4: {
1276                 GError *error = NULL;
1277                 char *s;
1278
1279                 s = g_utf16_to_utf8 (ptr, -1, NULL, NULL, &error);
1280                 if (!strcmp (s, "ABC")) {
1281                         g_free (s);
1282                         return 0;
1283                 }
1284                 else {
1285                         g_free (s);
1286                         return 1;
1287                 }
1288         }
1289         default:
1290                 g_assert_not_reached ();
1291         }
1292
1293         return 1;
1294 }
1295
1296 typedef struct
1297 {
1298         int i;
1299         int j;
1300         int k;
1301         char *s;
1302 } AsAnyStruct;
1303
1304 STDCALL int
1305 mono_test_marshal_asany_inout (void* ptr)
1306 {
1307         AsAnyStruct* asAny = ptr;
1308         int res = asAny->i + asAny->j + asAny->k;
1309
1310         asAny->i = 10;
1311         asAny->j = 20;
1312         asAny->k = 30;
1313         asAny->s = 0;
1314
1315         return res;
1316 }
1317
1318 /*
1319  * AMD64 marshalling tests.
1320  */
1321
1322 typedef struct amd64_struct1 {
1323         int i;
1324         int j;
1325         int k;
1326         int l;
1327 } amd64_struct1;
1328
1329 STDCALL amd64_struct1
1330 mono_test_marshal_amd64_pass_return_struct1 (amd64_struct1 s)
1331 {
1332         s.i ++;
1333         s.j ++;
1334         s.k ++;
1335         s.l ++;
1336
1337         return s;
1338 }
1339
1340 typedef struct amd64_struct2 {
1341         int i;
1342         int j;
1343 } amd64_struct2;
1344
1345 STDCALL amd64_struct2
1346 mono_test_marshal_amd64_pass_return_struct2 (amd64_struct2 s)
1347 {
1348         s.i ++;
1349         s.j ++;
1350
1351         return s;
1352 }
1353
1354 typedef struct amd64_struct3 {
1355         int i;
1356 } amd64_struct3;
1357
1358 STDCALL amd64_struct3
1359 mono_test_marshal_amd64_pass_return_struct3 (amd64_struct3 s)
1360 {
1361         s.i ++;
1362
1363         return s;
1364 }
1365
1366 typedef struct amd64_struct4 {
1367         double d1, d2;
1368 } amd64_struct4;
1369
1370 STDCALL amd64_struct4
1371 mono_test_marshal_amd64_pass_return_struct4 (amd64_struct4 s)
1372 {
1373         s.d1 ++;
1374         s.d2 ++;
1375
1376         return s;
1377 }
1378
1379 /*
1380  * IA64 marshalling tests.
1381  */
1382 typedef struct test_struct5 {
1383         float d1, d2;
1384 } test_struct5;
1385
1386 STDCALL test_struct5
1387 mono_test_marshal_ia64_pass_return_struct5 (double d1, double d2, test_struct5 s, double d3, double d4)
1388 {
1389         s.d1 += d1 + d2;
1390         s.d2 += d3 + d4;
1391
1392         return s;
1393 }
1394
1395 typedef struct test_struct6 {
1396         double d1, d2;
1397 } test_struct6;
1398
1399 STDCALL test_struct6
1400 mono_test_marshal_ia64_pass_return_struct6 (double d1, double d2, test_struct6 s, double d3, double d4)
1401 {
1402         s.d1 += d1 + d2;
1403         s.d2 += d3 + d4;
1404
1405         return s;
1406 }
1407
1408 static guint32 custom_res [2];
1409
1410 STDCALL void*
1411 mono_test_marshal_pass_return_custom (int i, guint32 *ptr, int j)
1412 {
1413         /* ptr will be freed by CleanupNative, so make a copy */
1414         custom_res [0] = 0; /* not allocated by AllocHGlobal */
1415         custom_res [1] = ptr [1];
1416
1417         return &custom_res;
1418 }
1419
1420 STDCALL int
1421 mono_test_marshal_pass_out_custom (int i, guint32 **ptr, int j)
1422 {
1423         custom_res [0] = 0;
1424         custom_res [1] = i + j + 10;
1425
1426         *ptr = custom_res;
1427
1428         return 0;
1429 }
1430
1431 STDCALL int
1432 mono_test_marshal_pass_byref_custom (int i, guint32 **ptr, int j)
1433 {
1434         (*ptr)[1] += i + j;
1435
1436         return 0;
1437 }
1438
1439 STDCALL void*
1440 mono_test_marshal_pass_return_custom2 (int i, guint32 *ptr, int j)
1441 {
1442         g_assert_not_reached ();
1443
1444         return NULL;
1445 }
1446
1447 STDCALL void*
1448 mono_test_marshal_pass_return_custom_null (int i, guint32 *ptr, int j)
1449 {
1450         g_assert (ptr == NULL);
1451
1452         return NULL;
1453 }
1454
1455 typedef void *(STDCALL *PassReturnPtrDelegate) (void *ptr);
1456
1457 STDCALL int
1458 mono_test_marshal_pass_return_custom_in_delegate (PassReturnPtrDelegate del)
1459 {
1460         guint32 buf [2];
1461         guint32 res;
1462         guint32 *ptr;
1463
1464         buf [0] = 0;
1465         buf [1] = 10;
1466
1467         ptr = del (&buf);
1468
1469         res = ptr [1];
1470
1471 #ifdef WIN32
1472         /* FIXME: Freed with FreeHGlobal */
1473 #else
1474         g_free (ptr);
1475 #endif
1476
1477         return res;
1478 }
1479
1480 STDCALL int
1481 mono_test_marshal_pass_return_custom_null_in_delegate (PassReturnPtrDelegate del)
1482 {
1483         void *ptr = del (NULL);
1484
1485         return (ptr == NULL) ? 15 : 0;
1486 }
1487
1488 typedef int (STDCALL *ReturnEnumDelegate) (int e);
1489
1490 STDCALL int
1491 mono_test_marshal_return_enum_delegate (ReturnEnumDelegate func)
1492 {
1493         return func (1);
1494 }
1495
1496 typedef struct {
1497         int a, b, c;
1498         gint64 d;
1499 } BlittableStruct;
1500
1501 typedef BlittableStruct (STDCALL *SimpleDelegate10) (BlittableStruct ss);
1502
1503 STDCALL int
1504 mono_test_marshal_blittable_struct_delegate (SimpleDelegate10 delegate)
1505 {
1506         BlittableStruct ss, res;
1507
1508         ss.a = 1;
1509         ss.b = 2;
1510         ss.c = 3;
1511         ss.d = 55;
1512
1513         res = delegate (ss);
1514         if (! ((res.a == -1) && (res.b == -2) && (res.c == -3) && (res.d == -55)))
1515                 return 1;
1516
1517         return 0;
1518 }
1519
1520 STDCALL int
1521 mono_test_stdcall_name_mangling (int a, int b, int c)
1522 {
1523         return a + b + c;
1524 }
1525
1526 /*
1527  * PASSING AND RETURNING SMALL STRUCTURES FROM DELEGATES TESTS
1528  */
1529
1530 typedef struct {
1531         int i;
1532 } SmallStruct1;
1533
1534 typedef SmallStruct1 (STDCALL *SmallStructDelegate1) (SmallStruct1 ss);
1535
1536 STDCALL int
1537 mono_test_marshal_small_struct_delegate1 (SmallStructDelegate1 delegate)
1538 {
1539         SmallStruct1 ss, res;
1540
1541         ss.i = 1;
1542
1543         res = delegate (ss);
1544         if (! (res.i == -1))
1545                 return 1;
1546
1547         return 0;
1548 }
1549
1550 typedef struct {
1551         gint16 i, j;
1552 } SmallStruct2;
1553
1554 typedef SmallStruct2 (STDCALL *SmallStructDelegate2) (SmallStruct2 ss);
1555
1556 STDCALL int
1557 mono_test_marshal_small_struct_delegate2 (SmallStructDelegate2 delegate)
1558 {
1559         SmallStruct2 ss, res;
1560
1561         ss.i = 2;
1562         ss.j = 3;
1563
1564         res = delegate (ss);
1565         if (! ((res.i == -2) && (res.j == -3)))
1566                 return 1;
1567
1568         return 0;
1569 }
1570
1571 typedef struct {
1572         gint16 i;
1573         gint8 j;
1574 } SmallStruct3;
1575
1576 typedef SmallStruct3 (STDCALL *SmallStructDelegate3) (SmallStruct3 ss);
1577
1578 STDCALL int
1579 mono_test_marshal_small_struct_delegate3 (SmallStructDelegate3 delegate)
1580 {
1581         SmallStruct3 ss, res;
1582
1583         ss.i = 1;
1584         ss.j = 2;
1585
1586         res = delegate (ss);
1587         if (! ((res.i == -1) && (res.j == -2)))
1588                 return 1;
1589
1590         return 0;
1591 }
1592
1593 typedef struct {
1594         gint16 i;
1595 } SmallStruct4;
1596
1597 typedef SmallStruct4 (STDCALL *SmallStructDelegate4) (SmallStruct4 ss);
1598
1599 STDCALL int
1600 mono_test_marshal_small_struct_delegate4 (SmallStructDelegate4 delegate)
1601 {
1602         SmallStruct4 ss, res;
1603
1604         ss.i = 1;
1605
1606         res = delegate (ss);
1607         if (! (res.i == -1))
1608                 return 1;
1609
1610         return 0;
1611 }
1612
1613 typedef struct {
1614         gint64 i;
1615 } SmallStruct5;
1616
1617 typedef SmallStruct5 (STDCALL *SmallStructDelegate5) (SmallStruct5 ss);
1618
1619 STDCALL int
1620 mono_test_marshal_small_struct_delegate5 (SmallStructDelegate5 delegate)
1621 {
1622         SmallStruct5 ss, res;
1623
1624         ss.i = 5;
1625
1626         res = delegate (ss);
1627         if (! (res.i == -5))
1628                 return 1;
1629
1630         return 0;
1631 }
1632
1633 typedef struct {
1634         int i, j;
1635 } SmallStruct6;
1636
1637 typedef SmallStruct6 (STDCALL *SmallStructDelegate6) (SmallStruct6 ss);
1638
1639 STDCALL int
1640 mono_test_marshal_small_struct_delegate6 (SmallStructDelegate6 delegate)
1641 {
1642         SmallStruct6 ss, res;
1643
1644         ss.i = 1;
1645         ss.j = 2;
1646
1647         res = delegate (ss);
1648         if (! ((res.i == -1) && (res.j == -2)))
1649                 return 1;
1650
1651         return 0;
1652 }
1653
1654 typedef struct {
1655         int i;
1656         gint16 j;
1657 } SmallStruct7;
1658
1659 typedef SmallStruct7 (STDCALL *SmallStructDelegate7) (SmallStruct7 ss);
1660
1661 STDCALL int
1662 mono_test_marshal_small_struct_delegate7 (SmallStructDelegate7 delegate)
1663 {
1664         SmallStruct7 ss, res;
1665
1666         ss.i = 1;
1667         ss.j = 2;
1668
1669         res = delegate (ss);
1670         if (! ((res.i == -1) && (res.j == -2)))
1671                 return 1;
1672
1673         return 0;
1674 }
1675
1676 typedef struct {
1677         float i;
1678 } SmallStruct8;
1679
1680 typedef SmallStruct8 (STDCALL *SmallStructDelegate8) (SmallStruct8 ss);
1681
1682 STDCALL int
1683 mono_test_marshal_small_struct_delegate8 (SmallStructDelegate8 delegate)
1684 {
1685         SmallStruct8 ss, res;
1686
1687         ss.i = 1.0;
1688
1689         res = delegate (ss);
1690         if (! ((res.i == -1.0)))
1691                 return 1;
1692
1693         return 0;
1694 }
1695
1696 typedef struct {
1697         double i;
1698 } SmallStruct9;
1699
1700 typedef SmallStruct9 (STDCALL *SmallStructDelegate9) (SmallStruct9 ss);
1701
1702 STDCALL int
1703 mono_test_marshal_small_struct_delegate9 (SmallStructDelegate9 delegate)
1704 {
1705         SmallStruct9 ss, res;
1706
1707         ss.i = 1.0;
1708
1709         res = delegate (ss);
1710         if (! ((res.i == -1.0)))
1711                 return 1;
1712
1713         return 0;
1714 }
1715
1716 typedef struct {
1717         float i, j;
1718 } SmallStruct10;
1719
1720 typedef SmallStruct10 (STDCALL *SmallStructDelegate10) (SmallStruct10 ss);
1721
1722 STDCALL int
1723 mono_test_marshal_small_struct_delegate10 (SmallStructDelegate10 delegate)
1724 {
1725         SmallStruct10 ss, res;
1726
1727         ss.i = 1.0;
1728         ss.j = 2.0;
1729
1730         res = delegate (ss);
1731         if (! ((res.i == -1.0) && (res.j == -2.0)))
1732                 return 1;
1733
1734         return 0;
1735 }
1736
1737 typedef struct {
1738         float i;
1739         int j;
1740 } SmallStruct11;
1741
1742 typedef SmallStruct11 (STDCALL *SmallStructDelegate11) (SmallStruct11 ss);
1743
1744 STDCALL int
1745 mono_test_marshal_small_struct_delegate11 (SmallStructDelegate11 delegate)
1746 {
1747         SmallStruct11 ss, res;
1748
1749         ss.i = 1.0;
1750         ss.j = 2;
1751
1752         res = delegate (ss);
1753         if (! ((res.i == -1.0) && (res.j == -2)))
1754                 return 1;
1755
1756         return 0;
1757 }
1758
1759 typedef int (STDCALL *ArrayDelegate) (int i, char *j, void *arr);
1760
1761 STDCALL int
1762 mono_test_marshal_array_delegate (void *arr, int len, ArrayDelegate del)
1763 {
1764         return del (len, NULL, arr);
1765 }
1766
1767 STDCALL int
1768 mono_test_marshal_out_array_delegate (int *arr, int len, ArrayDelegate del)
1769 {
1770         del (len, NULL, arr);
1771
1772         if ((arr [0] != 1) || (arr [1] != 2))
1773                 return 1;
1774         else
1775                 return 0;
1776 }
1777
1778 STDCALL int
1779 mono_test_marshal_out_string_array_delegate (char **arr, int len, ArrayDelegate del)
1780 {
1781         del (len, NULL, arr);
1782
1783         if (!strcmp (arr [0], "ABC") && !strcmp (arr [1], "DEF"))
1784                 return 0;
1785         else
1786                 return 1;
1787 }
1788
1789 typedef int (*CdeclDelegate) (int i, int j);
1790
1791 STDCALL int
1792 mono_test_marshal_cdecl_delegate (CdeclDelegate del)
1793 {
1794         int i;
1795
1796         for (i = 0; i < 1000; ++i)
1797                 del (1, 2);
1798
1799         return 0;
1800 }
1801
1802 typedef char** (*ReturnStringArrayDelegate) (int i);
1803
1804 STDCALL int
1805 mono_test_marshal_return_string_array_delegate (ReturnStringArrayDelegate d)
1806 {
1807         char **arr = d (2);
1808         int res;
1809
1810         if (arr == NULL)
1811                 return 3;
1812
1813         if (strcmp (arr [0], "ABC") || strcmp (arr [1], "DEF"))
1814                 res = 1;
1815         else
1816                 res = 0;
1817
1818         marshal_free (arr);
1819
1820         return res;
1821 }
1822
1823 STDCALL int
1824 add_delegate (int i, int j)
1825 {
1826         return i + j;
1827 }
1828
1829 STDCALL gpointer
1830 mono_test_marshal_return_fnptr (void)
1831 {
1832         return &add_delegate;
1833 }
1834
1835 /*
1836  * COM INTEROP TESTS
1837  */
1838
1839 #ifdef WIN32
1840
1841 STDCALL int
1842 mono_test_marshal_bstr_in(BSTR bstr)
1843 {
1844         if (!wcscmp(bstr, L"mono_test_marshal_bstr_in"))
1845                 return 0;
1846         return 1;
1847 }
1848
1849 STDCALL int
1850 mono_test_marshal_bstr_out(BSTR* bstr)
1851 {
1852         *bstr = SysAllocString(L"mono_test_marshal_bstr_out");
1853         return 0;
1854 }
1855
1856 STDCALL int
1857 mono_test_marshal_variant_in_sbyte(VARIANT variant)
1858 {
1859         if (variant.vt == VT_I1 && variant.cVal == 100)
1860                 return 0;
1861         return 1;
1862 }
1863
1864 STDCALL int
1865 mono_test_marshal_variant_in_byte(VARIANT variant)
1866 {
1867         if (variant.vt == VT_UI1 && variant.bVal == 100)
1868                 return 0;
1869         return 1;
1870 }
1871
1872 STDCALL int
1873 mono_test_marshal_variant_in_short(VARIANT variant)
1874 {
1875         if (variant.vt == VT_I2 && variant.iVal == 314)
1876                 return 0;
1877         return 1;
1878 }
1879
1880 STDCALL int
1881 mono_test_marshal_variant_in_ushort(VARIANT variant)
1882 {
1883         if (variant.vt == VT_UI2 && variant.uiVal == 314)
1884                 return 0;
1885         return 1;
1886 }
1887
1888 STDCALL int
1889 mono_test_marshal_variant_in_int(VARIANT variant)
1890 {
1891         if (variant.vt == VT_I4 && variant.lVal == 314)
1892                 return 0;
1893         return 1;
1894 }
1895
1896 STDCALL int
1897 mono_test_marshal_variant_in_uint(VARIANT variant)
1898 {
1899         if (variant.vt == VT_UI4 && variant.ulVal == 314)
1900                 return 0;
1901         return 1;
1902 }
1903
1904 STDCALL int
1905 mono_test_marshal_variant_in_long(VARIANT variant)
1906 {
1907         if (variant.vt == VT_I8 && variant.llVal == 314)
1908                 return 0;
1909         return 1;
1910 }
1911
1912 STDCALL int
1913 mono_test_marshal_variant_in_ulong(VARIANT variant)
1914 {
1915         if (variant.vt == VT_UI8 && variant.ullVal == 314)
1916                 return 0;
1917         return 1;
1918 }
1919
1920 STDCALL int
1921 mono_test_marshal_variant_in_float(VARIANT variant)
1922 {
1923         if (variant.vt == VT_R4 && (variant.fltVal - 3.14)/3.14 < .001)
1924                 return 0;
1925         return 1;
1926 }
1927
1928 STDCALL int
1929 mono_test_marshal_variant_in_double(VARIANT variant)
1930 {
1931         if (variant.vt == VT_R8 && (variant.dblVal - 3.14)/3.14 < .001)
1932                 return 0;
1933         return 1;
1934 }
1935
1936 STDCALL int
1937 mono_test_marshal_variant_in_bstr(VARIANT variant)
1938 {
1939         if (variant.vt == VT_BSTR && !wcscmp(variant.bstrVal, L"PI"))
1940                 return 0;
1941         return 1;
1942 }
1943
1944 STDCALL int
1945 mono_test_marshal_variant_out_sbyte(VARIANT* variant)
1946 {
1947         variant->vt = VT_I1;
1948         variant->cVal = 100;
1949
1950         return 0;
1951 }
1952
1953 STDCALL int
1954 mono_test_marshal_variant_out_byte(VARIANT* variant)
1955 {
1956         variant->vt = VT_UI1;
1957         variant->bVal = 100;
1958
1959         return 0;
1960 }
1961
1962 STDCALL int
1963 mono_test_marshal_variant_out_short(VARIANT* variant)
1964 {
1965         variant->vt = VT_I2;
1966         variant->iVal = 314;
1967
1968         return 0;
1969 }
1970
1971 STDCALL int
1972 mono_test_marshal_variant_out_ushort(VARIANT* variant)
1973 {
1974         variant->vt = VT_UI2;
1975         variant->uiVal = 314;
1976
1977         return 0;
1978 }
1979
1980 STDCALL int
1981 mono_test_marshal_variant_out_int(VARIANT* variant)
1982 {
1983         variant->vt = VT_I4;
1984         variant->lVal = 314;
1985
1986         return 0;
1987 }
1988
1989 STDCALL int
1990 mono_test_marshal_variant_out_uint(VARIANT* variant)
1991 {
1992         variant->vt = VT_UI4;
1993         variant->ulVal = 314;
1994
1995         return 0;
1996 }
1997
1998 STDCALL int
1999 mono_test_marshal_variant_out_long(VARIANT* variant)
2000 {
2001         variant->vt = VT_I8;
2002         variant->llVal = 314;
2003
2004         return 0;
2005 }
2006
2007 STDCALL int
2008 mono_test_marshal_variant_out_ulong(VARIANT* variant)
2009 {
2010         variant->vt = VT_UI8;
2011         variant->ullVal = 314;
2012
2013         return 0;
2014 }
2015
2016 STDCALL int
2017 mono_test_marshal_variant_out_float(VARIANT* variant)
2018 {
2019         variant->vt = VT_R4;
2020         variant->fltVal = 3.14;
2021
2022         return 0;
2023 }
2024
2025 STDCALL int
2026 mono_test_marshal_variant_out_double(VARIANT* variant)
2027 {
2028         variant->vt = VT_R8;
2029         variant->dblVal = 3.14;
2030
2031         return 0;
2032 }
2033
2034 STDCALL int
2035 mono_test_marshal_variant_out_bstr(VARIANT* variant)
2036 {
2037         variant->vt = VT_BSTR;
2038         variant->bstrVal = SysAllocString(L"PI");
2039
2040         return 0;
2041 }
2042
2043 #endif
2044
2045 #ifdef NOT_YET
2046
2047 #ifdef _MSC_VER
2048 #define COM_STDCALL __stdcall
2049 #else
2050 #define COM_STDCALL __attribute__((stdcall))
2051 #endif
2052
2053 typedef struct MonoComObject MonoComObject;
2054
2055 typedef struct
2056 {
2057         int (COM_STDCALL *QueryInterface)(MonoComObject* pUnk, gpointer riid, gpointer* ppv);
2058         int (COM_STDCALL *AddRef)(MonoComObject* pUnk);
2059         int (COM_STDCALL *Release)(MonoComObject* pUnk);
2060         int (COM_STDCALL *Add)(MonoComObject* pUnk, int a, int b, int* c);
2061         int (COM_STDCALL *Subtract)(MonoComObject* pUnk, int a, int b, int* c);
2062 } MonoIUnknown;
2063
2064 struct MonoComObject
2065 {
2066         MonoIUnknown* vtbl;
2067         int m_ref;
2068 };
2069
2070 int COM_STDCALL MonoQueryInterface(MonoComObject* pUnk, gpointer riid, gpointer* ppv)
2071 {
2072         *ppv = pUnk;
2073         return 0;
2074 }
2075
2076 int COM_STDCALL MonoAddRef(MonoComObject* pUnk)
2077 {
2078         return ++(pUnk->m_ref);
2079 }
2080
2081 int COM_STDCALL MonoRelease(MonoComObject* pUnk)
2082 {
2083         return --(pUnk->m_ref);
2084 }
2085
2086 int COM_STDCALL Add(MonoComObject* pUnk, int a, int b, int* c)
2087 {
2088         *c = a + b;
2089         return 0;
2090 }
2091
2092 int COM_STDCALL Subtract(MonoComObject* pUnk, int a, int b, int* c)
2093 {
2094         *c = a - b;
2095         return 0;
2096 }
2097
2098 STDCALL int
2099 mono_test_marshal_com_object_create(MonoComObject* *pUnk)
2100 {
2101         *pUnk = g_new0 (MonoComObject, 1);
2102         (*pUnk)->vtbl = g_new0 (MonoIUnknown, 1);
2103
2104         (*pUnk)->m_ref = 1;
2105         (*pUnk)->vtbl->QueryInterface = MonoQueryInterface;
2106         (*pUnk)->vtbl->AddRef = MonoAddRef;
2107         (*pUnk)->vtbl->Release = MonoRelease;
2108         (*pUnk)->vtbl->Add = Add;
2109         (*pUnk)->vtbl->Subtract = Subtract;
2110
2111
2112         return 0;
2113 }
2114
2115 STDCALL int
2116 mono_test_marshal_com_object_destroy(MonoComObject *pUnk)
2117 {
2118         int ref = --(pUnk->m_ref);
2119         g_free(pUnk->vtbl);
2120         g_free(pUnk);
2121
2122         return ref;
2123 }
2124
2125 STDCALL int
2126 mono_test_marshal_com_object_ref_count(MonoComObject *pUnk)
2127 {
2128         return pUnk->m_ref;
2129 }
2130
2131 #endif //NOT_YET