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