src/nci_test.c

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