src/nci_test.c

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