src/extend.c

   1 /*
   2 Copyright (C) 2001-2007, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/extend.c - Parrot extension interface
   8
   9 =head1 DESCRIPTION
  10
  11 These are the functions that parrot extensions (i.e. parrot subroutines
  12 written in C, or some other compiled language, rather than in parrot
  13 bytecode) may access.
  14
  15 There is a deliberate distancing from the internals here. Don't go
  16 peeking inside -- you've as much access as bytecode does, but no more,
  17 so we can provide backwards compatibility for as long as we possibly
  18 can.
  19
  20 =head2 Functions
  21
  22 =over 4
  23
  24 =cut
  25
  26 */
  27
  28 /* Some internal notes. Parrot will die a horrible and bizarre death
  29    if the stack start pointer's not set and a DOD run is
  30    triggered. The pointer *will* be set by the interpreter if the
  31    interpreter calls code which calls these functions, so most
  32    extension code is safe, no problem.
  33
  34    The problem comes in if these routines are called from *outside*
  35    an interpreter. This happens when an embedding application calls
  36    them to do stuff with PMCs, STRINGS, interpreter contents, and
  37    suchlike things. This is perfectly legal -- in fact it's what
  38    we've documented should be done -- but the problem is that the
  39    stack base pointer will be NULL. This is Very Bad.
  40
  41    To deal with this there are two macros that are defined to handle
  42    the problem.
  43
  44    PARROT_CALLIN_START(interp) will figure out if the stack
  45    anchor needs setting and, if so, will set it. It must *always*
  46    come immediately after the last variable declared in the block
  47    making the calls into the interpreter, as it declares a variable
  48    and has some code.
  49
  50    PARROT_CALLIN_END(interp) will put the stack anchor back to
  51    the way it was, and should always be the last statement before a
  52    return. (If you have multiple returns have it in multiple times)
  53
  54    Not doing this is a good way to introduce bizarre heisenbugs, so
  55    just do it. This is the only place they ought to have to be put
  56    in, and most of the functions are already written, so it's not
  57    like it's an onerous requirement.
  58
  59 */
  60
  61 #include "parrot/parrot.h"
  62 #include "parrot/extend.h"
  63
  64 /*
  65
  66 =item C<Parrot_String
  67 Parrot_PMC_get_string_intkey(Parrot_Interp interp, Parrot_PMC pmc,
  68                              Parrot_Int key)>
  69
  70 Return the integer keyed string value of the passed-in PMC
  71
  72 =cut
  73
  74 */
  75
  76 PARROT_API Parrot_String
  77 Parrot_PMC_get_string_intkey(Parrot_Interp interp,
  78                              Parrot_PMC pmc, Parrot_Int key) {
  79     Parrot_String retval;
  80     PARROT_CALLIN_START(interp);
  81     retval = VTABLE_get_string_keyed_int(interp, pmc, key);
  82     PARROT_CALLIN_END(interp);
  83     return retval;
  84 }
  85
  86
  87 /*
  88
  89 =item C<void *
  90 Parrot_PMC_get_pointer_intkey(Parrot_Interp interp, Parrot_PMC pmc,
  91                               Parrot_Int key)>
  92
  93 Return the keyed, signed integer value of the value in the PMC.
  94
  95 =cut
  96
  97 */
  98
  99 PARROT_API void *
 100 Parrot_PMC_get_pointer_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 101                               Parrot_Int key) {
 102     void *retval;
 103     PARROT_CALLIN_START(interp);
 104     retval = VTABLE_get_pointer_keyed_int(interp, pmc, key);
 105     PARROT_CALLIN_END(interp);
 106     return retval;
 107 }
 108
 109 /*
 110
 111 =item C<Parrot_PMC
 112 Parrot_PMC_get_pmc_intkey(Parrot_Interp interp, Parrot_PMC pmc, Parrot_Int key)>
 113
 114 Return the integer keyed PMC value of the passed-in PMC
 115
 116 =cut
 117
 118 */
 119
 120 PARROT_API Parrot_PMC
 121 Parrot_PMC_get_pmc_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 122                                      Parrot_Int key) {
 123     Parrot_PMC retval;
 124     PARROT_CALLIN_START(interp);
 125     retval = VTABLE_get_pmc_keyed_int(interp, pmc, key);
 126     PARROT_CALLIN_END(interp);
 127     return retval;
 128 }
 129
 130 /*
 131
 132 =item C<Parrot_Int
 133 Parrot_PMC_get_intval(Parrot_Interp interp, Parrot_PMC pmc)>
 134
 135 Return the signed integer value of the value in the PMC.
 136
 137 =cut
 138
 139 */
 140
 141 PARROT_API Parrot_Int
 142 Parrot_PMC_get_intval(Parrot_Interp interp, Parrot_PMC pmc) {
 143     Parrot_Int retval;
 144     PARROT_CALLIN_START(interp);
 145     retval = VTABLE_get_integer(interp, pmc);
 146     PARROT_CALLIN_END(interp);
 147     return retval;
 148 }
 149
 150 /*
 151
 152 =item C<Parrot_Int
 153 Parrot_PMC_get_intval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 154                              Parrot_Int key)>
 155
 156 Return the keyed, signed integer value of the value in the PMC.
 157
 158 =cut
 159
 160 */
 161
 162 PARROT_API Parrot_Int
 163 Parrot_PMC_get_intval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 164                                         Parrot_Int key) {
 165     Parrot_Int retval;
 166     PARROT_CALLIN_START(interp);
 167     retval = VTABLE_get_integer_keyed_int(interp, pmc, key);
 168     PARROT_CALLIN_END(interp);
 169     return retval;
 170 }
 171
 172 /*
 173
 174 =item C<Parrot_Int
 175 Parrot_PMC_get_intval_pmckey(Parrot_Interp interp, Parrot_PMC pmc,
 176                              Parrot_PMC key)>
 177
 178 Return the keyed, signed integer value of the value in the PMC.
 179
 180 =cut
 181
 182 */
 183
 184 PARROT_API Parrot_Int
 185 Parrot_PMC_get_intval_pmckey(Parrot_Interp interp, Parrot_PMC pmc,
 186                                         Parrot_PMC key) {
 187     Parrot_Int retval;
 188     PARROT_CALLIN_START(interp);
 189     retval = VTABLE_get_integer_keyed(interp, pmc, key);
 190     PARROT_CALLIN_END(interp);
 191     return retval;
 192 }
 193
 194 /*
 195
 196 =item C<Parrot_Float
 197 Parrot_PMC_get_numval(Parrot_Interp interp, Parrot_PMC pmc)>
 198
 199 Return the floating-point value of the PMC.
 200
 201 =cut
 202
 203 */
 204
 205 PARROT_API Parrot_Float
 206 Parrot_PMC_get_numval(Parrot_Interp interp, Parrot_PMC pmc) {
 207     Parrot_Float retval;
 208     PARROT_CALLIN_START(interp);
 209     retval =  VTABLE_get_number(interp, pmc);
 210     PARROT_CALLIN_END(interp);
 211     return retval;
 212 }
 213
 214 /*
 215
 216 =item C<Parrot_Float
 217 Parrot_PMC_get_numval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 218                              Parrot_Int key)>
 219
 220 Return the keyed, signed integer value of the value in the PMC.
 221
 222 =cut
 223
 224 */
 225
 226 PARROT_API Parrot_Float
 227 Parrot_PMC_get_numval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 228                                           Parrot_Int key) {
 229     Parrot_Float retval;
 230     PARROT_CALLIN_START(interp);
 231     retval =  VTABLE_get_number_keyed_int(interp, pmc, key);
 232     PARROT_CALLIN_END(interp);
 233     return retval;
 234 }
 235
 236 /*
 237
 238 =item C<char *
 239 Parrot_PMC_get_cstring_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 240                               Parrot_Int key)>
 241
 242 Return a null-terminated string that represents the string value of the PMC.
 243
 244 Note that you must free this string with C<string_cstring_free()>!
 245
 246 =cut
 247
 248 */
 249
 250 PARROT_API char *
 251 Parrot_PMC_get_cstring_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 252                                     Parrot_Int key) {
 253     STRING *intermediate;
 254     char   *retval;
 255
 256     PARROT_CALLIN_START(interp);
 257     intermediate = VTABLE_get_string_keyed_int(interp, pmc, key);
 258     retval       = string_to_cstring(interp, intermediate);
 259     PARROT_CALLIN_END(interp);
 260
 261     return retval;
 262 }
 263
 264 /*
 265
 266 =item C<char *Parrot_PMC_get_cstring(Parrot_Interp interp, Parrot_PMC pmc)>
 267
 268 Return a null-terminated string that represents the string value of the PMC.
 269
 270 Note that you must free this string with C<string_cstring_free()>!
 271
 272 =cut
 273
 274 */
 275
 276 PARROT_API char *
 277 Parrot_PMC_get_cstring(Parrot_Interp interp, Parrot_PMC pmc) {
 278     STRING *intermediate;
 279     char   *retval;
 280
 281     PARROT_CALLIN_START(interp);
 282     intermediate = VTABLE_get_string(interp, pmc);
 283     retval       = string_to_cstring(interp, intermediate);
 284     PARROT_CALLIN_END(interp);
 285
 286     return retval;
 287 }
 288
 289 /*
 290
 291 =item C<char *
 292 Parrot_PMC_get_cstringn(Parrot_Interp interp, Parrot_PMC pmc,
 293                         Parrot_Int *length)>
 294
 295 Return a null-terminated string for the PMC, along with the length.
 296
 297 Yes, right now this is a bit of a cheat. It needs fixing, but without
 298 disturbing the interface.
 299
 300 Note that you must free the string with C<string_cstring_free()>.
 301
 302 =cut
 303
 304 */
 305
 306 PARROT_API char *
 307 Parrot_PMC_get_cstringn(Parrot_Interp interp, Parrot_PMC pmc,
 308                               Parrot_Int *length) {
 309     char *retval;
 310
 311     PARROT_CALLIN_START(interp);
 312     retval  = string_to_cstring(interp, VTABLE_get_string(interp, pmc));
 313     *length = strlen(retval);
 314     PARROT_CALLIN_END(interp);
 315
 316     return retval;
 317 }
 318
 319 /*
 320
 321 =item C<char *
 322 Parrot_PMC_get_cstringn_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 323                                Parrot_Int *length, Parrot_Int key)>
 324
 325 Return a null-terminated string for the PMC, along with the length.
 326
 327 Yes, right now this is a bit of a cheat. It needs fixing, but without
 328 disturbing the interface.
 329
 330 Note that you must free this string with C<string_cstring_free()>.
 331
 332 =cut
 333
 334 */
 335
 336 PARROT_API char *
 337 Parrot_PMC_get_cstringn_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 338                                      Parrot_Int *length, Parrot_Int key) {
 339     char *retval;
 340
 341     PARROT_CALLIN_START(interp);
 342     retval  = string_to_cstring(interp,
 343                                VTABLE_get_string_keyed_int(interp, pmc, key));
 344     *length = strlen(retval);
 345     PARROT_CALLIN_END(interp);
 346
 347     return retval;
 348 }
 349
 350 /*
 351
 352 =item C<void
 353 Parrot_PMC_set_string(Parrot_Interp interp, Parrot_PMC pmc,
 354                       Parrot_String value)>
 355
 356 Assign the passed-in Parrot string to the passed-in PMC.
 357
 358 =cut
 359
 360 */
 361
 362 PARROT_API void
 363 Parrot_PMC_set_string(Parrot_Interp interp, Parrot_PMC pmc,
 364                       Parrot_String value) {
 365     PARROT_CALLIN_START(interp);
 366     VTABLE_set_string_native(interp, pmc, value);
 367     PARROT_CALLIN_END(interp);
 368 }
 369
 370 /*
 371
 372 =item C<void
 373 Parrot_PMC_set_string_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 374                               Parrot_Int key, Parrot_String value)>
 375
 376 Assign the passed-in Parrot string to the passed-in PMC.
 377
 378 =cut
 379
 380 */
 381
 382 PARROT_API void
 383 Parrot_PMC_set_string_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 384                                   Parrot_Int key, Parrot_String value)
 385 {
 386     PARROT_CALLIN_START(interp);
 387     VTABLE_set_string_keyed_int(interp, pmc, key, value);
 388     PARROT_CALLIN_END(interp);
 389 }
 390
 391 /*
 392
 393 =item C<void
 394 Parrot_PMC_set_pmc_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 395                            Parrot_Int key, Parrot_PMC value)>
 396
 397 Assign the passed-in pmc to the passed-in slot of the passed-in PMC.
 398
 399 =cut
 400
 401 */
 402
 403 PARROT_API void
 404 Parrot_PMC_set_pmc_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 405                                Parrot_Int key, Parrot_PMC value) {
 406     PARROT_CALLIN_START(interp);
 407     VTABLE_set_pmc_keyed_int(interp, pmc, key, value);
 408     PARROT_CALLIN_END(interp);
 409 }
 410
 411 /*
 412
 413 =item C<void
 414 Parrot_PMC_set_pmc_pmckey(Parrot_Interp interp, Parrot_PMC pmc,
 415                            Parrot_PMC key, Parrot_PMC value)>
 416
 417 Assign the passed-in pmc to the passed-in slot of the passed-in PMC.
 418
 419 =cut
 420
 421 */
 422
 423 PARROT_API void
 424 Parrot_PMC_set_pmc_pmckey(Parrot_Interp interp, Parrot_PMC pmc,
 425                                Parrot_PMC key, Parrot_PMC value) {
 426     PARROT_CALLIN_START(interp);
 427     VTABLE_set_pmc_keyed(interp, pmc, key, value);
 428     PARROT_CALLIN_END(interp);
 429 }
 430
 431 /*
 432
 433 =item C<void
 434 Parrot_PMC_set_pointer_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 435                               Parrot_Int key, void *value)>
 436
 437 Assign the passed-in pointer to the passed-in PMC.
 438
 439 =cut
 440
 441 */
 442
 443 PARROT_API void
 444 Parrot_PMC_set_pointer_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 445                                    Parrot_Int key, void *value) {
 446     PARROT_CALLIN_START(interp);
 447     VTABLE_set_pointer_keyed_int(interp, pmc, key, value);
 448     PARROT_CALLIN_END(interp);
 449 }
 450
 451 /*
 452
 453 =item C<void
 454 Parrot_PMC_set_intval(Parrot_Interp interp, Parrot_PMC pmc, Parrot_Int value)>
 455
 456 Assign the passed-in Parrot integer to the passed-in PMC.
 457
 458 =cut
 459
 460 */
 461
 462 PARROT_API void
 463 Parrot_PMC_set_intval(Parrot_Interp interp, Parrot_PMC pmc, Parrot_Int value) {
 464     PARROT_CALLIN_START(interp);
 465     VTABLE_set_integer_native(interp, pmc, value);
 466     PARROT_CALLIN_END(interp);
 467 }
 468
 469 /*
 470
 471 =item C<void
 472 Parrot_PMC_set_intval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 473                              Parrot_Int key, Parrot_Int value)>
 474
 475 Assign the passed-in Parrot integer to the passed-in PMC.
 476
 477 =cut
 478
 479 */
 480
 481 PARROT_API void
 482 Parrot_PMC_set_intval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 483                                   Parrot_Int key, Parrot_Int value) {
 484     PARROT_CALLIN_START(interp);
 485     VTABLE_set_integer_keyed_int(interp, pmc, key, value);
 486     PARROT_CALLIN_END(interp);
 487 }
 488
 489 /*
 490
 491 =item C<void
 492 Parrot_PMC_set_numval(Parrot_Interp interp, Parrot_PMC pmc, Parrot_Float value)>
 493
 494 Assign the passed-in Parrot number to the passed-in PMC.
 495
 496 =cut
 497
 498 */
 499
 500 PARROT_API void
 501 Parrot_PMC_set_numval(Parrot_Interp interp, Parrot_PMC pmc, Parrot_Float value){
 502     PARROT_CALLIN_START(interp);
 503     VTABLE_set_number_native(interp, pmc, value);
 504     PARROT_CALLIN_END(interp);
 505 }
 506
 507 /*
 508
 509 =item C<void
 510 Parrot_PMC_set_numval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 511                              Parrot_Int key, Parrot_Float value)>
 512
 513 Assign the passed-in Parrot number to the passed-in PMC.
 514
 515 =cut
 516
 517 */
 518
 519 PARROT_API void
 520 Parrot_PMC_set_numval_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 521                                   Parrot_Int key, Parrot_Float value) {
 522     PARROT_CALLIN_START(interp);
 523     VTABLE_set_number_keyed_int(interp, pmc, key, value);
 524     PARROT_CALLIN_END(interp);
 525 }
 526
 527 /*
 528
 529 =item C<void
 530 Parrot_PMC_set_cstring(Parrot_Interp interp, Parrot_PMC pmc, const char *value)>
 531
 532 Assign the passed-in null-terminated C string to the passed-in PMC.
 533
 534 =cut
 535
 536 */
 537
 538 PARROT_API void
 539 Parrot_PMC_set_cstring(Parrot_Interp interp, Parrot_PMC pmc, const char *value){
 540     PARROT_CALLIN_START(interp);
 541     VTABLE_set_string_native(interp, pmc,
 542                              string_from_cstring(interp, value, 0));
 543     PARROT_CALLIN_END(interp);
 544 }
 545
 546 /*
 547
 548 =item C<void
 549 Parrot_PMC_set_cstring_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 550                               Parrot_Int key, const char *value)>
 551
 552 Assign the passed-in null-terminated C string to the passed-in PMC.
 553
 554 =cut
 555
 556 */
 557
 558 PARROT_API void
 559 Parrot_PMC_set_cstring_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 560                                    Parrot_Int key, const char *value) {
 561     PARROT_CALLIN_START(interp);
 562     VTABLE_set_string_keyed_int(interp, pmc, key,
 563                                 string_from_cstring(interp, value, 0));
 564     PARROT_CALLIN_END(interp);
 565 }
 566
 567 /*
 568
 569 =item C<void
 570 Parrot_PMC_set_cstringn(Parrot_Interp interp, Parrot_PMC pmc,
 571                         const char *value, Parrot_Int length)>
 572
 573 Assign the passed-in length-noted string to the passed-in PMC.
 574
 575 =cut
 576
 577 */
 578
 579 PARROT_API void
 580 Parrot_PMC_set_cstringn(Parrot_Interp interp, Parrot_PMC pmc,
 581                         const char *value, Parrot_Int length) {
 582     PARROT_CALLIN_START(interp);
 583     VTABLE_set_string_native(interp, pmc,
 584                              string_from_cstring(interp, value, length));
 585     PARROT_CALLIN_END(interp);
 586 }
 587
 588 /*
 589
 590 =item C<void
 591 Parrot_PMC_push_intval(Parrot_Interp interp, Parrot_PMC pmc,
 592                             Parrot_Int value)>
 593
 594 Push the passed-in Parrot integer onto the passed in PMC
 595
 596 =cut
 597
 598 */
 599
 600 PARROT_API void
 601 Parrot_PMC_push_intval(Parrot_Interp interp, Parrot_PMC pmc,
 602                        Parrot_Int value) {
 603     PARROT_CALLIN_START(interp);
 604     VTABLE_push_integer(interp, pmc, value);
 605     PARROT_CALLIN_END(interp);
 606 }
 607
 608 /*
 609
 610 =item C<void
 611 Parrot_PMC_push_numval(Parrot_Interp interp, Parrot_PMC pmc,
 612                             Parrot_Float value)>
 613
 614 Push the passed-in Parrot number onto the passed in PMC
 615
 616 =cut
 617
 618 */
 619
 620 PARROT_API void
 621 Parrot_PMC_push_numval(Parrot_Interp interp, Parrot_PMC pmc,
 622                        Parrot_Float value) {
 623     PARROT_CALLIN_START(interp);
 624     VTABLE_push_float(interp, pmc, value);
 625     PARROT_CALLIN_END(interp);
 626 }
 627
 628 /*
 629
 630 =item C<void
 631 Parrot_PMC_delete_pmckey(Parrot_Interp interp, Parrot_PMC pmc,
 632                          Parrot_PMC key)>
 633
 634 Deletes the value associated with the passed-in PMC from the PMC.
 635
 636 =cut
 637
 638 */
 639
 640 PARROT_API void
 641 Parrot_PMC_delete_pmckey(Parrot_Interp interp, Parrot_PMC pmc,
 642                               Parrot_PMC key) {
 643     PARROT_CALLIN_START(interp);
 644     VTABLE_delete_keyed(interp, pmc, key);
 645     PARROT_CALLIN_END(interp);
 646 }
 647
 648 /*
 649
 650 =item C<void
 651 Parrot_PMC_set_cstringn_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 652                                Parrot_Int key,
 653                                const char *value, Parrot_Int length)>
 654
 655 Assign the passed-in length-noted string to the passed-in PMC.
 656
 657 =cut
 658
 659 */
 660
 661 PARROT_API void
 662 Parrot_PMC_set_cstringn_intkey(Parrot_Interp interp, Parrot_PMC pmc,
 663                                Parrot_Int key,
 664                                const char *value, Parrot_Int length) {
 665     PARROT_CALLIN_START(interp);
 666     VTABLE_set_string_keyed_int(interp, pmc, key,
 667                                 string_from_cstring(interp, value, length));
 668     PARROT_CALLIN_END(interp);
 669 }
 670
 671 /*
 672
 673 =item C<Parrot_PMC Parrot_PMC_new(Parrot_Interp interp, Parrot_Int type)>
 674
 675 Create and return a new PMC.
 676
 677 =cut
 678
 679 */
 680
 681 PARROT_API Parrot_PMC
 682 Parrot_PMC_new(Parrot_Interp interp, Parrot_Int type) {
 683     Parrot_PMC newpmc;
 684     PARROT_CALLIN_START(interp);
 685     newpmc = pmc_new_noinit(interp, type);
 686     VTABLE_init(interp, newpmc);
 687     PARROT_CALLIN_END(interp);
 688     return newpmc;
 689 }
 690
 691 /*
 692
 693 =item C<Parrot_Int Parrot_PMC_typenum(Parrot_Interp interp, const char *_class)>
 694
 695 Returns the internal identifier that represents the named class.
 696
 697 =cut
 698
 699 */
 700
 701 PARROT_API Parrot_Int
 702 Parrot_PMC_typenum(Parrot_Interp interp, const char *_class) {
 703     Parrot_Int retval;
 704     PARROT_CALLIN_START(interp);
 705     retval = pmc_type(interp, string_from_cstring(interp, _class, 0));
 706     PARROT_CALLIN_END(interp);
 707     return retval;
 708 }
 709
 710 /*
 711
 712 =item C<Parrot_PMC Parrot_PMC_null()>
 713
 714 Returns the special C<NULL> PMC.
 715
 716 =cut
 717
 718 */
 719
 720 PARROT_API Parrot_PMC
 721 Parrot_PMC_null(void) {
 722     return PMCNULL;
 723 }
 724
 725 /*
 726
 727 =item C<void Parrot_free_cstring(char *string)>
 728
 729 Deallocate a C string that the interpreter has handed to you.
 730
 731 =cut
 732
 733 */
 734
 735 PARROT_API void
 736 Parrot_free_cstring(char *string) {
 737     string_cstring_free(string);
 738 }
 739
 740 /*
 741
 742 =item C<void*
 743 Parrot_call_sub(Parrot_Interp interp, Parrot_PMC sub,
 744             const char *signature, ...)>
 745
 746 Call a parrot subroutine with the given function signature. The first char in
 747 C<signature> denotes the return value. Next chars are arguments.
 748
 749 The return value of this function can be void or a pointer type.
 750
 751 Signature chars are:
 752
 753     v ... void return
 754     I ... Parrot_Int
 755     N ... Parrot_Float
 756     S ... Parrot_String
 757     P ... Parrot_PMC
 758
 759 =item C<Parrot_Int>
 760 Parrot_call_sub_ret_int(Parrot_Interp interp, Parrot_PMC sub,
 761             const char *signature, ...)>
 762
 763 =item C<Parrot_Float>
 764 Parrot_call_sub_ret_float(Parrot_Interp interp, Parrot_PMC sub,
 765             const char *signature, ...)>
 766
 767 Like above, with Parrot_Int or Parrot_Float return result.
 768
 769 =cut
 770
 771 */
 772
 773 PARROT_API void*
 774 Parrot_call_sub(Parrot_Interp interp, Parrot_PMC sub,
 775                  const char *signature, ...)
 776 {
 777     va_list ap;
 778     void *result;
 779
 780     PARROT_CALLIN_START(interp);
 781
 782     va_start(ap, signature);
 783     CONTEXT(interp->ctx)->constants =
 784         PMC_sub(sub)->seg->const_table->constants;
 785     result = Parrot_runops_fromc_arglist(interp, sub, signature, ap);
 786     va_end(ap);
 787
 788     PARROT_CALLIN_END(interp);
 789     return result;
 790 }
 791
 792 PARROT_API Parrot_Int
 793 Parrot_call_sub_ret_int(Parrot_Interp interp, Parrot_PMC sub,
 794                  const char *signature, ...)
 795 {
 796     va_list ap;
 797     Parrot_Int result;
 798
 799     PARROT_CALLIN_START(interp);
 800
 801     va_start(ap, signature);
 802     CONTEXT(interp->ctx)->constants =
 803         PMC_sub(sub)->seg->const_table->constants;
 804     result = Parrot_runops_fromc_arglist_reti(interp, sub, signature, ap);
 805     va_end(ap);
 806
 807     PARROT_CALLIN_END(interp);
 808     return result;
 809 }
 810
 811 PARROT_API Parrot_Float
 812 Parrot_call_sub_ret_float(Parrot_Interp interp, Parrot_PMC sub,
 813                  const char *signature, ...)
 814 {
 815     va_list ap;
 816     Parrot_Float result;
 817
 818     PARROT_CALLIN_START(interp);
 819
 820     va_start(ap, signature);
 821     CONTEXT(interp->ctx)->constants =
 822         PMC_sub(sub)->seg->const_table->constants;
 823     result = Parrot_runops_fromc_arglist_retf(interp, sub, signature, ap);
 824     va_end(ap);
 825
 826     PARROT_CALLIN_END(interp);
 827     return result;
 828 }
 829
 830 /*
 831
 832 =item C<void* Parrot_call_method(Parrot_Interp interp, Parrot_PMC sub,
 833         Parrot_PMC object, Parrot_String method, const char *signature, ...)>
 834
 835 =item C<Parrot_Int Parrot_call_method_ret_int(Parrot_Interp interp,
 836     Parrot_PMC sub, Parrot_PMC object, Parrot_String method,
 837     const char *signature, ...)>
 838
 839 =item C<Parrot_Float Parrot_call_method_ret_float(Parrot_Interp interp,
 840     Parrot_PMC sub, Parrot_PMC object, Parrot_String method,
 841     const char *signature, ...)>
 842
 843 Call a parrot method for the given object.
 844
 845 =cut
 846
 847 */
 848
 849 PARROT_API void *
 850 Parrot_call_method(Parrot_Interp interp, Parrot_PMC sub, Parrot_PMC obj,
 851                         Parrot_String method, const char *signature, ...)
 852 {
 853     void *result;
 854     va_list ap;
 855
 856     PARROT_CALLIN_START(interp);
 857     va_start(ap, signature);
 858     result = Parrot_run_meth_fromc_arglist(interp, sub,
 859             obj, method, signature, ap);
 860     va_end(ap);
 861     PARROT_CALLIN_END(interp);
 862     return result;
 863 }
 864
 865 PARROT_API Parrot_Int
 866 Parrot_call_method_ret_int(Parrot_Interp interp, Parrot_PMC sub,
 867         Parrot_PMC obj, Parrot_String method, const char *signature, ...)
 868 {
 869     Parrot_Int result;
 870     va_list ap;
 871
 872     PARROT_CALLIN_START(interp);
 873     va_start(ap, signature);
 874     result = Parrot_run_meth_fromc_arglist_reti(interp, sub,
 875             obj, method, signature, ap);
 876     va_end(ap);
 877     PARROT_CALLIN_END(interp);
 878     return result;
 879 }
 880
 881 PARROT_API Parrot_Float
 882 Parrot_call_method_ret_float(Parrot_Interp interp, Parrot_PMC sub,
 883         Parrot_PMC obj, Parrot_String method, const char *signature, ...)
 884 {
 885     Parrot_Float result;
 886     va_list ap;
 887
 888     PARROT_CALLIN_START(interp);
 889     va_start(ap, signature);
 890     result = Parrot_run_meth_fromc_arglist_retf(interp, sub,
 891             obj, method, signature, ap);
 892     va_end(ap);
 893     PARROT_CALLIN_END(interp);
 894     return result;
 895 }
 896
 897 /*
 898
 899 =item C<Parrot_Int
 900 Parrot_get_intreg(Parrot_Interp interp, Parrot_Int regnum)>
 901
 902 Return the value of an integer register.
 903
 904 =cut
 905
 906 */
 907
 908 PARROT_API Parrot_Int
 909 Parrot_get_intreg(Parrot_Interp interp, Parrot_Int regnum)
 910 {
 911     return REG_INT(regnum);
 912 }
 913
 914 /*
 915
 916 =item C<Parrot_Float
 917 Parrot_get_numreg(Parrot_Interp interp, Parrot_Int regnum)>
 918
 919 Return the value of a numeric register.
 920
 921 =cut
 922
 923 */
 924
 925 PARROT_API Parrot_Float
 926 Parrot_get_numreg(Parrot_Interp interp, Parrot_Int regnum)
 927 {
 928     return REG_NUM(regnum);
 929 }
 930
 931 /*
 932
 933 =item C<Parrot_String
 934 Parrot_get_strreg(Parrot_Interp interp, Parrot_Int regnum)>
 935
 936 Return the value of a string register.
 937
 938 =cut
 939
 940 */
 941
 942 PARROT_API Parrot_String
 943 Parrot_get_strreg(Parrot_Interp interp, Parrot_Int regnum)
 944 {
 945     return REG_STR(regnum);
 946 }
 947
 948 /*
 949
 950 =item C<Parrot_PMC
 951 Parrot_get_pmcreg(Parrot_Interp interp, Parrot_Int regnum)>
 952
 953 Return the value of a PMC register.
 954
 955 =cut
 956
 957 */
 958
 959 PARROT_API Parrot_PMC
 960 Parrot_get_pmcreg(Parrot_Interp interp, Parrot_Int regnum)
 961 {
 962     return REG_PMC(regnum);
 963 }
 964
 965 /*
 966
 967 =item C<void
 968 Parrot_set_intreg(Parrot_Interp interp, Parrot_Int regnum,
 969                   Parrot_Int value)>
 970
 971 Set the value of an I register.
 972
 973 =cut
 974
 975 */
 976
 977 PARROT_API void
 978 Parrot_set_intreg(Parrot_Interp interp, Parrot_Int regnum,
 979                   Parrot_Int value)
 980 {
 981     REG_INT(regnum) = value;
 982 }
 983
 984 /*
 985
 986 =item C<void
 987 Parrot_set_numreg(Parrot_Interp interp, Parrot_Int regnum,
 988                   Parrot_Float value)>
 989
 990 Set the value of an N register.
 991
 992 =cut
 993
 994 */
 995
 996 PARROT_API void
 997 Parrot_set_numreg(Parrot_Interp interp, Parrot_Int regnum,
 998                   Parrot_Float value)
 999 {
1000     REG_NUM(regnum) = value;
1001 }
1002
1003 /*
1004
1005 =item C<void
1006 Parrot_set_strreg(Parrot_Interp interp, Parrot_Int regnum,
1007                   Parrot_String value)>
1008
1009 Set the value of an S register.
1010
1011 =cut
1012
1013 */
1014
1015 PARROT_API void
1016 Parrot_set_strreg(Parrot_Interp interp, Parrot_Int regnum,
1017                   Parrot_String value)
1018 {
1019     REG_STR(regnum) = value;
1020 }
1021
1022 /*
1023
1024 =item C<void
1025 Parrot_set_pmcreg(Parrot_Interp interp, Parrot_Int regnum,
1026                   Parrot_PMC value) >
1027
1028 Set the value of a P register.
1029
1030 =cut
1031
1032 */
1033
1034 PARROT_API void
1035 Parrot_set_pmcreg(Parrot_Interp interp, Parrot_Int regnum,
1036                   Parrot_PMC value)
1037 {
1038     REG_PMC(regnum) = value;
1039 }
1040
1041 /*=for api extend Parrot_new_string
1042  *
1043  */
1044 /*
1045
1046 =item C<Parrot_String Parrot_new_string(Parrot_Interp interp,
1047                                 char *buffer, int length,
1048                                 const char * const encoding_name,
1049                                 Parrot_Int flags)>
1050
1051 Create a new Parrot string from a passed-in buffer. Pass in a 0 for
1052 flags for right now.
1053
1054 A copy of the buffer is made.
1055
1056 =cut
1057
1058 */
1059
1060 PARROT_API Parrot_String
1061 Parrot_new_string(Parrot_Interp interp,
1062                                 char *buffer, int length,
1063                                 const char * const encoding_name,
1064                                 Parrot_Int flags)
1065 {
1066     Parrot_String retval;
1067     PARROT_CALLIN_START(interp);
1068     retval = string_make(interp, buffer, length, encoding_name, flags);
1069     PARROT_CALLIN_END(interp);
1070     return retval;
1071 }
1072
1073 /*
1074
1075 =item C<Parrot_Const_Encoding
1076 Parrot_find_encoding(Parrot_Interp interp, char *encoding_name)>
1077
1078 Find the magic token for an encoding, by name.
1079
1080 =cut
1081
1082 */
1083 /*
1084 PARROT_API Parrot_Const_Encoding
1085 Parrot_find_encoding(Parrot_Interp interp,
1086                                            char *encoding_name) {
1087     return Parrot_encoding_lookup(encoding_name);
1088 }
1089 */
1090 /*
1091
1092 =item C<Parrot_Language
1093 Parrot_find_language(Parrot_Interp interp, char *language)>
1094
1095 Find the magic language token for a language, by language name.
1096
1097 =cut
1098
1099 */
1100
1101 PARROT_API Parrot_Language
1102 Parrot_find_language(Parrot_Interp interp, char *language)
1103 {
1104     return 0;
1105 }
1106
1107 /*
1108
1109 =item C<void
1110 Parrot_register_pmc(Parrot_Interp interp, Parrot_PMC pmc)>
1111
1112 Add a reference of the PMC to the interpreters DOD registry. This
1113 prevents PMCs only known to extension from getting destroyed during DOD
1114 runs.
1115
1116 =cut
1117
1118 */
1119
1120 PARROT_API void
1121 Parrot_register_pmc(Parrot_Interp interp, Parrot_PMC pmc)
1122 {
1123     PARROT_CALLIN_START(interp);
1124     dod_register_pmc(interp, pmc);
1125     PARROT_CALLIN_END(interp);
1126 }
1127
1128 /*
1129
1130 =item C<void
1131 Parrot_unregister_pmc(Parrot_Interp interp, Parrot_PMC pmc)>
1132
1133 Remove a reference of the PMC from the interpreters DOD registry. If the
1134 reference count reaches zero, the PMC will be destroyed during the next
1135 DOD run.
1136
1137 =item C<Parrot_PMC Parrot_get_dod_registry(Parrot_Interp)>
1138
1139 Return Parrot's internal DOD registry PMC.
1140 See also: F<src/pmc/addrregistry.pmc>.
1141
1142 =cut
1143
1144 */
1145
1146 PARROT_API void
1147 Parrot_unregister_pmc(Parrot_Interp interp, Parrot_PMC pmc)
1148 {
1149     PARROT_CALLIN_START(interp);
1150     dod_unregister_pmc(interp, pmc);
1151     PARROT_CALLIN_END(interp);
1152 }
1153
1154 PARROT_API Parrot_PMC
1155 Parrot_get_dod_registry(Parrot_Interp interp)
1156 {
1157     PMC *registry = interp->DOD_registry;
1158     PARROT_CALLIN_START(interp);
1159     if (!registry) {
1160         registry = interp->DOD_registry =
1161             pmc_new(interp, enum_class_AddrRegistry);
1162     }
1163     PARROT_CALLIN_END(interp);
1164     return registry;
1165 }
1166
1167 /*
1168
1169 =item C<void
1170 Parrot_pmc_set_vtable(Parrot_Interp interp, Parrot_PMC pmc,
1171                       Parrot_VTABLE vtable)>
1172
1173 Replaces the vtable of the PMC.
1174
1175 =cut
1176
1177 */
1178
1179 PARROT_API void
1180 Parrot_PMC_set_vtable(Parrot_Interp interp, Parrot_PMC pmc,
1181                       Parrot_VTABLE vtable)
1182 {
1183     pmc->vtable = vtable;
1184 }
1185
1186 /*
1187
1188 =item C<Parrot_VTABLE
1189 Parrot_get_vtable(Parrot_Interp interp, Parrot_Int id)>
1190
1191 Returns the vtable corresponding to the given PMC ID.
1192
1193 =cut
1194
1195 */
1196
1197 PARROT_API Parrot_VTABLE
1198 Parrot_get_vtable(Parrot_Interp interp, Parrot_Int id)
1199 {
1200     return interp->vtables[id];
1201 }
1202
1203 /*
1204
1205 =back
1206
1207 =head1 SEE ALSO
1208
1209 See F<include/parrot/extend.h> and F<docs/pdds/pdd11_extending.pod>.
1210
1211 =head1 HISTORY
1212
1213 Initial version by Dan Sugalski.
1214
1215 =cut
1216
1217 */
1218
1219
1220 /*
1221  * Local variables:
1222  *   c-file-style: "parrot"
1223  * End:
1224  * vim: expandtab shiftwidth=4:
1225  */