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