src/nci_test.c

   1 /*
   2 Copyright (C) 2001-2007, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/nci_test.c - shared library used for testing the Native Call Interface
   8
   9 =head1 DESCRIPTION
  10
  11 From this code a shared library can be compiled and linked with a command like:
  12
  13    cc -shared -fpic nci_test.c -o libnci_test.so -g
  14
  15 For non-Unix platforms the above command has to be modified appropriately.
  16
  17 The resulting shared library should be copied to a location like:
  18
  19    parrot/runtime/parrot/dynext/libnci_test.so
  20
  21 At that location the shared library is loadable with the opcode 'loadlib'.
  22 The functions in the library are available with the opcode 'dlfunc'.
  23 The variables in the library are available with the opcode 'dlvar'.
  24
  25 =head2 Functions
  26
  27 The name of a test function is usually 'nci_<signature>'. E.g. the function
  28 'nci_ip' takes a 'pointer' and returns a 'int'.
  29
  30 =over 4
  31
  32 =cut
  33
  34 */
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <parrot/config.h>
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44
  45 /* Declarations of structs */
  46
  47 typedef struct Nested {
  48     int y;
  49 } Nested;
  50
  51 typedef struct Outer {
  52     int x;
  53     Nested *nested;
  54 } Outer;
  55
  56 typedef struct Rect_Like {
  57     int x, y;
  58     int w, h;
  59 } Rect_Like;
  60
  61 typedef struct Opaque {
  62     int x;
  63 } Opaque;
  64
  65 /* Function declarations.
  66
  67 *** If you add a new test function here,
  68 *** please update src/libnci_test.def and src/call_list.txt too. ***
  69
  70 */
  71
  72 PARROT_API int    call_back(const char *str);
  73 PARROT_API char   nci_c(void);
  74 PARROT_API char   nci_csc(short, char);
  75 PARROT_API double nci_d(void);
  76 PARROT_API double nci_dd(double);
  77 PARROT_API float  nci_f(void);
  78 PARROT_API float  nci_fff(float, float);
  79 PARROT_API int    nci_i(void);
  80 PARROT_API int    nci_ib(int *);
  81 PARROT_API int    nci_iiii(int, int, int);
  82 PARROT_API int    nci_ii3(int, int *);
  83 PARROT_API int    nci_ip(void *);
  84 PARROT_API int    nci_isc(short, char);
  85 PARROT_API int    nci_it(void *);
  86 PARROT_API int    nci_i33(int *, int *);
  87 PARROT_API int    nci_i4i(long *, int);
  88 PARROT_API long   nci_l(void);
  89 PARROT_API int *  nci_p(void);
  90 PARROT_API void * nci_pi(int);
  91 PARROT_API void * nci_pii(int, int);
  92 PARROT_API void * nci_piiii(int, int, int, int);
  93 PARROT_API void   nci_pip(int, Rect_Like *);
  94 PARROT_API void * nci_pp(void *);
  95 PARROT_API short  nci_s(void);
  96 PARROT_API short  nci_ssc(short, char);
  97 PARROT_API char * nci_t(void);
  98 PARROT_API char * nci_tb(void *);
  99 PARROT_API char * nci_tB(void **);
 100 PARROT_API char * nci_tt(void *);
 101 PARROT_API void   nci_v(void);
 102 PARROT_API void   nci_vP(void *);
 103 PARROT_API void   nci_vpii(Outer *, int, int);
 104 PARROT_API void   nci_vv(void);
 105 PARROT_API void   nci_vVi(Opaque**, int);
 106 PARROT_API void   nci_vp(Opaque*);
 107
 108
 109 /* Declarations for callback tests */
 110
 111 typedef void (*cb_C1_func)(const char*, void*);
 112 PARROT_API void nci_cb_C1(cb_C1_func, void*);
 113
 114 typedef void (*cb_C2_func)(int, void*);
 115 PARROT_API void nci_cb_C2(cb_C2_func, void*);
 116
 117 typedef void (*cb_C3_func)(void*, void*);
 118 PARROT_API void nci_cb_C3(cb_C3_func, void*);
 119
 120 typedef void (*cb_D1_func)(void*, const char*);
 121 PARROT_API void nci_cb_D1(cb_D1_func, void*);
 122
 123 typedef void (*cb_D2_func)(void*, int);
 124 PARROT_API void nci_cb_D2(cb_D2_func, void*);
 125
 126 typedef void (*cb_D3_func)(void*, void*);
 127 PARROT_API void nci_cb_D3(cb_D3_func, void*);
 128
 129 typedef void (*cb_D4_func)(void*, void*);
 130 PARROT_API void nci_cb_D4(cb_D4_func, void*);
 131
 132 /* Variable definitions */
 133
 134 PARROT_API int    int_cb_D4           = -55555;
 135 PARROT_API int    nci_dlvar_char      = 22;
 136 PARROT_API int    nci_dlvar_short     = 333;
 137 PARROT_API int    nci_dlvar_int       = -4444;
 138 PARROT_API long   nci_dlvar_long      = -7777777;
 139 PARROT_API float  nci_dlvar_float     = -333.0;
 140 PARROT_API double nci_dlvar_double    = -55555.55555;
 141 PARROT_API char   nci_dlvar_cstring[] = "This is a C-string.\n";
 142
 143
 144 /* Function definitions */
 145
 146 /*
 147
 148 =item C<PARROT_API char
 149 nci_c(void)>
 150
 151 RT#48260: Not yet documented!!!
 152
 153 =cut
 154
 155 */
 156
 157 PARROT_API char
 158 nci_c(void) {
 159     return nci_dlvar_char;
 160 }
 161
 162 /*
 163
 164 =item C<PARROT_API char
 165 nci_csc(short l1, char l2)>
 166
 167 RT#48260: Not yet documented!!!
 168
 169 =cut
 170
 171 */
 172
 173 PARROT_API char
 174 nci_csc(short l1, char l2)
 175 {
 176     return l1 * l2;
 177 }
 178
 179 /*
 180
 181 =item C<PARROT_API double
 182 nci_d(void)>
 183
 184 RT#48260: Not yet documented!!!
 185
 186 =cut
 187
 188 */
 189
 190 PARROT_API double
 191 nci_d(void)
 192 {
 193     nci_dlvar_double *= 10.0;
 194
 195     return nci_dlvar_double;
 196 }
 197
 198 /*
 199
 200 =item C<PARROT_API double
 201 nci_dd(double d)>
 202
 203 RT#48260: Not yet documented!!!
 204
 205 =cut
 206
 207 */
 208
 209 PARROT_API double
 210 nci_dd(double d)
 211 {
 212     return d * 2.0;
 213 }
 214
 215 /*
 216
 217 =item C<PARROT_API float
 218 nci_f(void)>
 219
 220 RT#48260: Not yet documented!!!
 221
 222 =cut
 223
 224 */
 225
 226 PARROT_API float
 227 nci_f(void)
 228 {
 229     nci_dlvar_float *= 10.0;
 230
 231     return nci_dlvar_float;
 232 }
 233
 234 /*
 235
 236 =item C<PARROT_API float
 237 nci_fff(float l1, float l2)>
 238
 239 RT#48260: Not yet documented!!!
 240
 241 =cut
 242
 243 */
 244
 245 PARROT_API float
 246 nci_fff(float l1, float l2)
 247 {
 248     return l1 / l2;
 249 }
 250
 251 /*
 252
 253 =item C<PARROT_API int
 254 nci_i(void)>
 255
 256 RT#48260: Not yet documented!!!
 257
 258 =cut
 259
 260 */
 261
 262 PARROT_API int
 263 nci_i(void)
 264 {
 265    return nci_dlvar_int;
 266 }
 267
 268 /*
 269
 270 =item C<PARROT_API int
 271 nci_isc(short l1, char l2)>
 272
 273 RT#48260: Not yet documented!!!
 274
 275 =cut
 276
 277 */
 278
 279 PARROT_API int
 280 nci_isc(short l1, char l2)
 281 {
 282     return l1 * l2;
 283 }
 284
 285 /*
 286
 287 =item C<PARROT_API int
 288 nci_ip(void *p)>
 289
 290 RT#48260: Not yet documented!!!
 291
 292 =cut
 293
 294 */
 295
 296 PARROT_API int
 297 nci_ip(void *p)
 298 {
 299     typedef struct _dfi {
 300         double d;
 301         float f;
 302         int i;
 303         char *s;
 304     } dfi;
 305     dfi *sp = (dfi*) p;
 306     puts(sp->s);
 307     fflush(stdout);
 308
 309     return (int) (sp->d + sp->f + sp->i);
 310 }
 311
 312 /*
 313
 314 =item C<PARROT_API int
 315 nci_it(void *p)>
 316
 317 test calls this with a string
 318
 319 =cut
 320
 321 */
 322
 323 PARROT_API int
 324 nci_it(void *p)
 325 {
 326     fprintf(stderr, "%c%c\n", ((char*) p)[1], ((char *) p)[0]);
 327     fflush(stderr);
 328
 329     return 2;
 330 }
 331
 332 /*
 333
 334 =item C<PARROT_API long
 335 nci_l(void)>
 336
 337 RT#48260: Not yet documented!!!
 338
 339 =cut
 340
 341 */
 342
 343 PARROT_API long
 344 nci_l(void)
 345 {
 346     return nci_dlvar_long;
 347 }
 348
 349 /*
 350
 351 =item C<PARROT_API int *
 352 nci_p(void)>
 353
 354 RT#48260: Not yet documented!!!
 355
 356 =cut
 357
 358 */
 359
 360 PARROT_API int *
 361 nci_p(void)
 362 {
 363     return &nci_dlvar_int;
 364 }
 365
 366 /*
 367
 368 =item C<PARROT_API char *
 369 nci_t(void)>
 370
 371 RT#48260: Not yet documented!!!
 372
 373 =cut
 374
 375 */
 376
 377 PARROT_API char *
 378 nci_t(void)
 379 {
 380     return nci_dlvar_cstring;
 381 }
 382
 383 /*
 384
 385 =item C<PARROT_API char *
 386 nci_tb(void *p)>
 387
 388 RT#48260: Not yet documented!!!
 389
 390 =cut
 391
 392 */
 393
 394 static char b[] = "xx worked\n";
 395
 396 PARROT_API char *
 397 nci_tb(void *p)
 398 {
 399     b[0] = ((char*) p)[1];
 400     b[1] = ((char*) p)[0];
 401
 402     return b;
 403 }
 404
 405 /*
 406
 407 =item C<PARROT_API char *
 408 nci_tt(void *p)>
 409
 410 RT#48260: Not yet documented!!!
 411
 412 =cut
 413
 414 */
 415
 416 static char s[] = "xx worked\n";
 417
 418 PARROT_API char *
 419 nci_tt(void *p)
 420 {
 421     s[0] = ((char*) p)[1];
 422     s[1] = ((char*) p)[0];
 423
 424     return s;
 425 }
 426
 427 /*
 428
 429 =item C<PARROT_API char *
 430 nci_tB(void **p)>
 431
 432 RT#48260: Not yet documented!!!
 433
 434 =cut
 435
 436 */
 437
 438 static char B[] = "xx done\n";
 439
 440 PARROT_API char *
 441 nci_tB(void **p)
 442 {
 443     B[0] = (*(char**) p)[1];
 444     B[1] = (*(char**) p)[0];
 445
 446     return B;
 447 }
 448
 449 /*
 450
 451 =item C<PARROT_API void *
 452 nci_pp(void *p)>
 453
 454 RT#48260: Not yet documented!!!
 455
 456 =cut
 457
 458 */
 459
 460 PARROT_API void *
 461 nci_pp(void *p)
 462 {
 463     return p;
 464 }
 465
 466 /*
 467
 468 =item C<PARROT_API int
 469 nci_iiii(int i1, int i2, int i3)>
 470
 471 RT#48260: Not yet documented!!!
 472
 473 =cut
 474
 475 */
 476
 477 PARROT_API int
 478 nci_iiii(int i1, int i2, int i3)
 479 {
 480     fprintf(stderr, "%d %d %d\n", i1, i2, i3);
 481     fflush(stderr);
 482
 483     return 2;
 484 }
 485
 486 /*
 487
 488 =item C<PARROT_API int
 489 nci_i4i(long * l, int i)>
 490
 491 RT#48260: Not yet documented!!!
 492
 493 =cut
 494
 495 */
 496
 497 PARROT_API int
 498 nci_i4i(long * l, int i)
 499 {
 500
 501     return (int) (*l * i);
 502 }
 503
 504 /*
 505
 506 =item C<PARROT_API int
 507 nci_ii3(int a, int *bp)>
 508
 509 RT#48260: Not yet documented!!!
 510
 511 =cut
 512
 513 */
 514
 515 PARROT_API int
 516 nci_ii3(int a, int *bp)
 517 {
 518     int r = a * *bp;
 519     *bp = 4711;
 520
 521     return r;
 522 }
 523
 524 /*
 525
 526 =item C<PARROT_API int
 527 call_back(const char *str)>
 528
 529 RT#48260: Not yet documented!!!
 530
 531 =cut
 532
 533 */
 534
 535 PARROT_API int
 536 call_back(const char *str)
 537 {
 538     puts(str);
 539     fflush(stdout);
 540
 541     return 4711;
 542 }
 543
 544 /*
 545
 546 =item C<PARROT_API void *
 547 nci_pi(int test)>
 548
 549 RT#48260: Not yet documented!!!
 550
 551 =cut
 552
 553 */
 554
 555 PARROT_API void *
 556 nci_pi(int test)
 557 {
 558     switch (test) {
 559         case 0:
 560             {
 561                 static struct {
 562                     int i[2];
 563                     char c;
 564                 } t = {
 565                     {42, 100},
 566                     'B'
 567                 };
 568                 return &t;
 569             }
 570         case 1:
 571             {
 572                 static struct {
 573                     float f[2];
 574                     double d;
 575                 } t = {
 576                     {42.0, 100.0},
 577                     47.11
 578                 };
 579                 return &t;
 580             }
 581         case 2:
 582             {
 583                 static struct {
 584                     char c;
 585                     int i;
 586                 } t = {
 587                      10,
 588                      20
 589                 };
 590                 return &t;
 591             }
 592         case 3:
 593             {
 594                 static struct {
 595                     const char *c;
 596                     int i;
 597                 } t = {
 598                      "hello",
 599                      20
 600                 };
 601                 return &t;
 602             }
 603         case 4:
 604             {
 605                 static struct _x {
 606                     int i;
 607                     int j;
 608                     double d;
 609                 } xx = { 100, 77, 200.0 };
 610                 static struct {
 611                     char c;
 612                     struct _x *x;
 613                 } t = {
 614                      10,
 615                      &xx
 616                 };
 617                 return &t;
 618             }
 619         case 5:
 620             {
 621                 static struct {
 622                     int (*f)(const char *);
 623                 } t = {
 624                      call_back
 625                 };
 626                 return &t;
 627             }
 628         case 6:
 629             {
 630                 static struct xt {
 631                     int x;
 632                     struct yt {
 633                         int i;
 634                         int  j;
 635                     } _y;
 636                     int z;
 637                 } _x = {
 638                     32,
 639                     { 127, 12345 },
 640                     33
 641                 };
 642                 return &_x;
 643             }
 644         case 7:
 645             {
 646                 static struct xt {
 647                     char x;
 648                     struct yt {
 649                         char i;
 650                         int  j;
 651                     } _y;
 652                     char z;
 653                 } _x = {
 654                     32,
 655                     { 127, 12345 },
 656                     33
 657                 };
 658                 return &_x;
 659             }
 660         case 8:
 661             {
 662                 static struct _z {
 663                     int i;
 664                     int j;
 665                 } zz = { 100, 77 };
 666                 static struct xt {
 667                     int x;
 668                     struct yt {
 669                         int i;
 670                         int j;
 671                         struct _z *z;
 672                     } _y;
 673                 } _x = {
 674                     32,
 675                     { 127, 12345, &zz },
 676                 };
 677                 return &_x;
 678             }
 679         case 9:
 680             {
 681                 static int i = 55555;
 682                 return &i;
 683             }
 684         default:
 685             fprintf(stderr, "unknown test number\n");
 686     }
 687
 688     return NULL;
 689 }
 690
 691 /*
 692
 693 =item C<PARROT_API short
 694 nci_s(void)>
 695
 696 RT#48260: Not yet documented!!!
 697
 698 =cut
 699
 700 */
 701
 702 PARROT_API short
 703 nci_s(void)
 704 {
 705     return nci_dlvar_short;
 706 }
 707
 708 /*
 709
 710 =item C<PARROT_API short
 711 nci_ssc(short l1, char l2)>
 712
 713 RT#48260: Not yet documented!!!
 714
 715 =cut
 716
 717 */
 718
 719 PARROT_API short
 720 nci_ssc(short l1, char l2)
 721 {
 722     return l1 * l2;
 723 }
 724
 725 /*
 726
 727 =item C<PARROT_API void
 728 nci_vP(void *pmc)>
 729
 730 RT#48260: Not yet documented!!!
 731
 732 =cut
 733
 734 */
 735
 736 PARROT_API void
 737 nci_vP(void *pmc)
 738 {
 739     if (pmc)
 740         puts("ok");
 741     else
 742         puts("got null");
 743 }
 744
 745
 746 /*
 747
 748 =back
 749
 750 =head2 Functions used for pdd16 tests
 751
 752 =over 4
 753
 754 =cut
 755
 756 */
 757
 758 /*
 759
 760 =item C<PARROT_API void
 761 nci_cb_C1(cb_C1_func cb, void* user_data)>
 762
 763 RT#48260: Not yet documented!!!
 764
 765 =cut
 766
 767 */
 768
 769 PARROT_API void
 770 nci_cb_C1(cb_C1_func cb, void* user_data)
 771 {
 772     const char *result = "succeeded";
 773     /* call the cb synchronously */
 774     (cb)(result, user_data);
 775
 776     return;
 777 }
 778
 779 /*
 780
 781 =item C<PARROT_API void
 782 nci_cb_C2(cb_C2_func cb, void* user_data)>
 783
 784 RT#48260: Not yet documented!!!
 785
 786 =cut
 787
 788 */
 789
 790 PARROT_API void
 791 nci_cb_C2(cb_C2_func cb, void* user_data)
 792 {
 793     /* call the cb synchronously */
 794     (cb)(77, user_data);
 795
 796     return;
 797 }
 798
 799 /*
 800
 801 =item C<PARROT_API void
 802 nci_cb_C3(cb_C3_func cb, void* user_data)>
 803
 804 RT#48260: Not yet documented!!!
 805
 806 =cut
 807
 808 */
 809
 810 static int int_cb_C3 = 99;
 811
 812 PARROT_API void
 813 nci_cb_C3(cb_C3_func cb, void* user_data)
 814 {
 815     /* call the cb synchronously */
 816     (cb)(&int_cb_C3, user_data);
 817
 818     return;
 819 }
 820
 821 /*
 822
 823 =item C<PARROT_API void
 824 nci_cb_D1(cb_D1_func cb, void* user_data)>
 825
 826 RT#48260: Not yet documented!!!
 827
 828 =cut
 829
 830 */
 831
 832 PARROT_API void
 833 nci_cb_D1(cb_D1_func cb, void* user_data)
 834 {
 835     const char *result = "succeeded";
 836     /* call the cb synchronously */
 837     (cb)(user_data, result);
 838
 839     return;
 840 }
 841
 842 /*
 843
 844 =item C<PARROT_API void
 845 nci_cb_D2(cb_D2_func cb, void* user_data)>
 846
 847 RT#48260: Not yet documented!!!
 848
 849 =cut
 850
 851 */
 852
 853 PARROT_API void
 854 nci_cb_D2(cb_D2_func cb, void* user_data)
 855 {
 856     /* call the cb synchronously */
 857     (cb)(user_data, 88);
 858
 859     return;
 860 }
 861
 862 /*
 863
 864 =item C<PARROT_API void
 865 nci_cb_D3(cb_D3_func cb, void* user_data)>
 866
 867 RT#48260: Not yet documented!!!
 868
 869 =cut
 870
 871 */
 872
 873 static int int_cb_D3 = 111;
 874
 875 PARROT_API void
 876 nci_cb_D3(cb_D3_func cb, void* user_data)
 877 {
 878     /* call the cb synchronously */
 879     (cb)(user_data, &int_cb_D3);
 880
 881     return;
 882 }
 883
 884 /*
 885
 886 =item C<PARROT_API void
 887 nci_cb_D4(cb_D4_func times_ten, void* user_data)>
 888
 889 RT#48260: Not yet documented!!!
 890
 891 =cut
 892
 893 */
 894
 895 PARROT_API void
 896 nci_cb_D4(cb_D4_func times_ten, void* user_data)
 897 {
 898     int cnt;
 899     for (cnt = 0; cnt < 9; cnt++)
 900     {
 901         (times_ten)(user_data, &int_cb_D4);
 902         int_cb_D4++;
 903     }
 904
 905     return;
 906 }
 907
 908 /*
 909
 910 =item C<PARROT_API void
 911 nci_pip(int count, Rect_Like *rects)>
 912
 913 RT#48260: Not yet documented!!!
 914
 915 =cut
 916
 917 */
 918
 919 PARROT_API void
 920 nci_pip(int count, Rect_Like *rects)
 921 {
 922     int i;
 923     printf("Count: %d\n", count);
 924     for (i = 0; i < 4; ++i)
 925         printf("X: %d\nY: %d\nW: %d\nH: %d\n",
 926         rects[i].x, rects[i].y, rects[i].w, rects[i].h);
 927 }
 928
 929 /*
 930
 931 =item C<PARROT_API int
 932 nci_i33(int *double_me, int *triple_me)>
 933
 934 RT#48260: Not yet documented!!!
 935
 936 =cut
 937
 938 */
 939
 940 PARROT_API int
 941 nci_i33(int *double_me, int *triple_me)
 942 {
 943     *double_me *= 2;
 944     *triple_me *= 3;
 945
 946     return (*double_me + *triple_me);
 947 }
 948
 949 /*
 950
 951 =item C<PARROT_API void
 952 nci_vpii(Outer *my_data, int my_x, int my_y)>
 953
 954 RT#48260: Not yet documented!!!
 955
 956 =cut
 957
 958 */
 959
 960 PARROT_API void
 961 nci_vpii(Outer *my_data, int my_x, int my_y)
 962 {
 963     my_data->x            = my_x;
 964     my_data->nested->y    = my_y;
 965 }
 966
 967 /*
 968
 969 =item C<PARROT_API void *
 970 nci_piiii(int alpha, int beta, int gamma, int delta)>
 971
 972 RT#48260: Not yet documented!!!
 973
 974 =cut
 975
 976 */
 977
 978 static int my_array[4];
 979
 980 PARROT_API void *
 981 nci_piiii(int alpha, int beta, int gamma, int delta)
 982 {
 983     static struct array_container
 984     {
 985         int   x;
 986         int *array;
 987     } container;
 988
 989     my_array[0] = alpha;
 990     my_array[1] = beta;
 991     my_array[2] = gamma;
 992     my_array[3] = delta;
 993
 994     container.x = 4;
 995     container.array = my_array;
 996
 997     return &container;
 998 }
 999
1000 /*
1001
1002 =item C<PARROT_API void *
1003 nci_pii(int fac1, int fac2)>
1004
1005 RT#48260: Not yet documented!!!
1006
1007 =cut
1008
1009 */
1010
1011 PARROT_API void *
1012 nci_pii(int fac1, int fac2)
1013 {
1014    nci_dlvar_int = fac1 * fac2;
1015
1016    return &nci_dlvar_int;
1017 }
1018
1019 /*
1020
1021 =item C<PARROT_API void
1022 nci_v(void)>
1023
1024 RT#48260: Not yet documented!!!
1025
1026 =cut
1027
1028 */
1029
1030 PARROT_API void
1031 nci_v(void)
1032 {
1033     nci_dlvar_int *= 10;
1034 }
1035
1036 /*
1037
1038 =item C<PARROT_API void
1039 nci_vv(void)>
1040
1041 RT#48260: Not yet documented!!!
1042
1043 =cut
1044
1045 */
1046
1047 PARROT_API void
1048 nci_vv(void)
1049 {
1050     nci_dlvar_int *= 3;
1051 }
1052
1053 /*
1054
1055 =item C<PARROT_API void
1056 nci_vVi(Opaque**, int)>
1057
1058 Test an NCI opaque struct out value.
1059
1060 =cut
1061
1062 */
1063
1064 PARROT_API void
1065 nci_vVi(Opaque **outOpaque, int x)
1066 {
1067     static Opaque opaque;
1068     opaque.x = x;
1069     *outOpaque = &opaque;
1070 }
1071
1072 /*
1073
1074 =item C<PARROT_API int
1075 nci_vp(Opaque*)>
1076
1077 Test that a previously generated opaque struct gets passed back
1078 to an NCI function correctly.
1079
1080 =cut
1081
1082 */
1083
1084 PARROT_API void
1085 nci_vp(Opaque *inOpaque)
1086 {
1087     if (inOpaque)
1088         printf("got %d\n", inOpaque->x);
1089     else
1090         printf("got null");
1091 }
1092
1093
1094 #ifdef TEST
1095
1096 char l2 = 4;
1097 float f2 = 4.0;
1098
1099 /*
1100
1101 =item C<int
1102 main(void)>
1103
1104 RT#48260: Not yet documented!!!
1105
1106 =cut
1107
1108 */
1109
1110 int
1111 main(void)
1112 {
1113     short l1 = 3;
1114     float f, f1 = 3.0;
1115     int l = nci_ssc(l1, l2);
1116     printf("%d\n", l);
1117     f = nci_fff(f1, f2);
1118     printf("%f\n", f);
1119
1120     return 0;
1121 }
1122
1123 #endif
1124
1125 #ifdef __cplusplus
1126 }
1127 #endif
1128
1129 /*
1130
1131 =back
1132
1133 =head1 SEE ALSO:
1134
1135   F<docs/pdds/pdd16_native_call.pod>
1136   F<config/gen/makefiles/root.in>
1137   F<t/pmc/nci.t>
1138
1139 =cut
1140
1141 */
1142
1143
1144 /*
1145  * Local variables:
1146  *   c-file-style: "parrot"
1147  * End:
1148  * vim: expandtab shiftwidth=4:
1149  */