B.xs

   1 /*      B.xs
   2  *
   3  *      Copyright (c) 1996 Malcolm Beattie
   4  *
   5  *      You may distribute under the terms of either the GNU General Public
   6  *      License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 #include "EXTERN.h"
  11 #include "perl.h"
  12 #include "XSUB.h"
  13 #include "INTERN.h"
  14 #include "bytecode.h"
  15 #include "byterun.h"
  16 #include "ccop.h"
  17
  18 static char *svclassnames[] = {
  19     "B::NULL",
  20     "B::IV",
  21     "B::NV",
  22     "B::RV",
  23     "B::PV",
  24     "B::PVIV",
  25     "B::PVNV",
  26     "B::PVMG",
  27     "B::BM",
  28     "B::PVLV",
  29     "B::AV",
  30     "B::HV",
  31     "B::CV",
  32     "B::GV",
  33     "B::FM",
  34     "B::IO",
  35 };
  36
  37 static SV *
  38 make_sv_object(arg, sv)
  39 SV *arg;
  40 SV *sv;
  41 {
  42     char *type = 0;
  43     IV iv;
  44
  45     for (iv = 0; iv < sizeof(specialsv_list)/sizeof(SV*); iv++) {
  46         if (sv == specialsv_list[iv]) {
  47             type = "B::SPECIAL";
  48             break;
  49         }
  50     }
  51     if (!type) {
  52         type = svclassnames[SvTYPE(sv)];
  53         iv = (IV)sv;
  54     }
  55     sv_setiv(newSVrv(arg, type), iv);
  56     return arg;
  57 }
  58
  59 static SV *
  60 make_mg_object(arg, mg)
  61 SV *arg;
  62 MAGIC *mg;
  63 {
  64     sv_setiv(newSVrv(arg, "B::MAGIC"), (IV)mg);
  65     return arg;
  66 }
  67
  68 static SV *
  69 cstring(sv)
  70 SV *sv;
  71 {
  72     SV *sstr = newSVpv("", 0);
  73     STRLEN len;
  74     char *s;
  75
  76     if (!SvOK(sv))
  77         sv_setpvn(sstr, "0", 1);
  78     else
  79     {
  80         /* XXX Optimise? */
  81         s = SvPV(sv, len);
  82         sv_catpv(sstr, "\"");
  83         for (; len; len--, s++)
  84         {
  85             /* At least try a little for readability */
  86             if (*s == '"')
  87                 sv_catpv(sstr, "\\\"");
  88             else if (*s == '\\')
  89                 sv_catpv(sstr, "\\\\");
  90             else if (*s >= ' ' && *s < 127) /* XXX not portable */
  91                 sv_catpvn(sstr, s, 1);
  92             else if (*s == '\n')
  93                 sv_catpv(sstr, "\\n");
  94             else if (*s == '\r')
  95                 sv_catpv(sstr, "\\r");
  96             else if (*s == '\t')
  97                 sv_catpv(sstr, "\\t");
  98             else if (*s == '\a')
  99                 sv_catpv(sstr, "\\a");
 100             else if (*s == '\b')
 101                 sv_catpv(sstr, "\\b");
 102             else if (*s == '\f')
 103                 sv_catpv(sstr, "\\f");
 104             else if (*s == '\v')
 105                 sv_catpv(sstr, "\\v");
 106             else
 107             {
 108                 /* no trigraph support */
 109                 char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
 110                 /* Don't want promotion of a signed -1 char in sprintf args */
 111                 unsigned char c = (unsigned char) *s;
 112                 sprintf(escbuff, "\\%03o", c);
 113                 sv_catpv(sstr, escbuff);
 114             }
 115             /* XXX Add line breaks if string is long */
 116         }
 117         sv_catpv(sstr, "\"");
 118     }
 119     return sstr;
 120 }
 121
 122 static SV *
 123 cchar(sv)
 124 SV *sv;
 125 {
 126     SV *sstr = newSVpv("'", 0);
 127     char *s = SvPV(sv, na);
 128
 129     if (*s == '\'')
 130         sv_catpv(sstr, "\\'");
 131     else if (*s == '\\')
 132         sv_catpv(sstr, "\\\\");
 133     else if (*s >= ' ' && *s < 127) /* XXX not portable */
 134         sv_catpvn(sstr, s, 1);
 135     else if (*s == '\n')
 136         sv_catpv(sstr, "\\n");
 137     else if (*s == '\r')
 138         sv_catpv(sstr, "\\r");
 139     else if (*s == '\t')
 140         sv_catpv(sstr, "\\t");
 141     else if (*s == '\a')
 142         sv_catpv(sstr, "\\a");
 143     else if (*s == '\b')
 144         sv_catpv(sstr, "\\b");
 145     else if (*s == '\f')
 146         sv_catpv(sstr, "\\f");
 147     else if (*s == '\v')
 148         sv_catpv(sstr, "\\v");
 149     else
 150     {
 151         /* no trigraph support */
 152         char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
 153         /* Don't want promotion of a signed -1 char in sprintf args */
 154         unsigned char c = (unsigned char) *s;
 155         sprintf(escbuff, "\\%03o", c);
 156         sv_catpv(sstr, escbuff);
 157     }
 158     sv_catpv(sstr, "'");
 159     return sstr;
 160 }
 161
 162 void *
 163 bset_obj_store(obj, ix)
 164 void *obj;
 165 I32 ix;
 166 {
 167     if (ix > obj_list_fill) {
 168         if (obj_list_fill == -1)
 169             New(666, obj_list, ix + 1, void*);
 170         else
 171             Renew(obj_list, ix + 1, void*);
 172         obj_list_fill = ix;
 173     }
 174     obj_list[ix] = obj;
 175     return obj;
 176 }
 177
 178 #ifdef INDIRECT_BGET_MACROS
 179 void freadpv(len, data)
 180 U32 len;
 181 void *data;
 182 {
 183     New(666, pv.xpv_pv, len, char);
 184     fread(pv.xpv_pv, 1, len, (FILE*)data);
 185     pv.xpv_len = len;
 186     pv.xpv_cur = len - 1;
 187 }
 188
 189 void byteload_fh(fp)
 190 FILE *fp;
 191 {
 192     struct bytestream bs;
 193     bs.data = fp;
 194     bs.fgetc = (int(*) _((void*)))fgetc;
 195     bs.fread = (int(*) _((char*,size_t,size_t,void*)))fread;
 196     bs.freadpv = freadpv;
 197     byterun(bs);
 198 }
 199
 200 static int fgetc_fromstring(data)
 201 void *data;
 202 {
 203     char **strp = (char **)data;
 204     return *(*strp)++;
 205 }
 206
 207 static int fread_fromstring(argp, elemsize, nelem, data)
 208 char *argp;
 209 size_t elemsize;
 210 size_t nelem;
 211 void *data;
 212 {
 213     char **strp = (char **)data;
 214     size_t len = elemsize * nelem;
 215
 216     memcpy(argp, *strp, len);
 217     *strp += len;
 218     return (int)len;
 219 }
 220
 221 static void freadpv_fromstring(len, data)
 222 U32 len;
 223 void *data;
 224 {
 225     char **strp = (char **)data;
 226
 227     New(666, pv.xpv_pv, len, char);
 228     memcpy(pv.xpv_pv, *strp, len);
 229     pv.xpv_len = len;
 230     pv.xpv_cur = len - 1;
 231     *strp += len;
 232 }
 233
 234 void byteload_string(str)
 235 char *str;
 236 {
 237     struct bytestream bs;
 238     bs.data = &str;
 239     bs.fgetc = fgetc_fromstring;
 240     bs.fread = fread_fromstring;
 241     bs.freadpv = freadpv_fromstring;
 242     byterun(bs);
 243 }
 244 #else
 245 void byteload_fh(fp)
 246 FILE *fp;
 247 {
 248     byterun(fp);
 249 }
 250
 251 void byteload_string(str)
 252 char *str;
 253 {
 254     croak("Must compile with -DINDIRECT_BGET_MACROS for byteload_string");
 255 }
 256 #endif /* INDIRECT_BGET_MACROS */
 257
 258
 259 typedef OP      *B__OP;
 260 typedef UNOP    *B__UNOP;
 261 typedef BINOP   *B__BINOP;
 262 typedef LOGOP   *B__LOGOP;
 263 typedef CONDOP  *B__CONDOP;
 264 typedef LISTOP  *B__LISTOP;
 265 typedef PMOP    *B__PMOP;
 266 typedef SVOP    *B__SVOP;
 267 typedef GVOP    *B__GVOP;
 268 typedef PVOP    *B__PVOP;
 269 typedef LOOP    *B__LOOP;
 270 typedef COP     *B__COP;
 271
 272 typedef SV      *B__SV;
 273 typedef SV      *B__IV;
 274 typedef SV      *B__PV;
 275 typedef SV      *B__NV;
 276 typedef SV      *B__PVMG;
 277 typedef SV      *B__PVLV;
 278 typedef SV      *B__BM;
 279 typedef SV      *B__RV;
 280 typedef AV      *B__AV;
 281 typedef HV      *B__HV;
 282 typedef CV      *B__CV;
 283 typedef GV      *B__GV;
 284 typedef IO      *B__IO;
 285
 286 typedef MAGIC   *B__MAGIC;
 287
 288 MODULE = B      PACKAGE = B     PREFIX = B_
 289
 290 PROTOTYPES: DISABLE
 291
 292 #define B_main_cv()     main_cv
 293 #define B_main_root()   main_root
 294 #define B_main_start()  main_start
 295 #define B_comppadlist() (main_cv ? CvPADLIST(main_cv) : CvPADLIST(compcv))
 296 #define B_sv_undef()    &sv_undef
 297 #define B_sv_yes()      &sv_yes
 298 #define B_sv_no()       &sv_no
 299
 300 B::CV
 301 B_main_cv()
 302
 303 B::OP
 304 B_main_root()
 305
 306 B::OP
 307 B_main_start()
 308
 309 B::AV
 310 B_comppadlist()
 311
 312 B::SV
 313 B_sv_undef()
 314
 315 B::SV
 316 B_sv_yes()
 317
 318 B::SV
 319 B_sv_no()
 320
 321 MODULE = B      PACKAGE = B
 322
 323
 324 void
 325 byteload_fh(fp)
 326         FILE *  fp
 327
 328 void
 329 byteload_string(str)
 330         char *  str
 331
 332 #define address(sv) (IV)sv
 333
 334 IV
 335 address(sv)
 336         SV *    sv
 337
 338 B::SV
 339 svref_2object(sv)
 340         SV *    sv
 341     CODE:
 342         if (!SvROK(sv))
 343             croak("argument is not a reference");
 344         RETVAL = (SV*)SvRV(sv);
 345     OUTPUT:
 346         RETVAL
 347
 348 void
 349 ppname(opnum)
 350         int     opnum
 351     CODE:
 352         ST(0) = sv_newmortal();
 353         if (opnum >= 0 && opnum < sizeof(ppnames)/sizeof(char*))
 354             sv_setpv(ST(0), ppnames[opnum]);
 355
 356 void
 357 hash(sv)
 358         SV *    sv
 359     CODE:
 360         char *s;
 361         STRLEN len;
 362         U32 hash = 0;
 363         char hexhash[11]; /* must fit "0xffffffff" plus trailing \0 */
 364         s = SvPV(sv, len);
 365         while (len--)
 366             hash = hash * 33 + *s++;
 367         sprintf(hexhash, "0x%x", hash);
 368         ST(0) = sv_2mortal(newSVpv(hexhash, 0));
 369
 370 #define cast_I32(foo) (I32)foo
 371 IV
 372 cast_I32(i)
 373         IV      i
 374
 375 void
 376 minus_c()
 377     CODE:
 378         minus_c = TRUE;
 379
 380 SV *
 381 cstring(sv)
 382         SV *    sv
 383
 384 SV *
 385 cchar(sv)
 386         SV *    sv
 387
 388 #define OP_next(o)      o->op_next
 389 #define OP_sibling(o)   o->op_sibling
 390 #define OP_ppaddr(o)    ppnames[o->op_type]
 391 #define OP_targ(o)      o->op_targ
 392 #define OP_type(o)      o->op_type
 393 #define OP_seq(o)       o->op_seq
 394 #define OP_flags(o)     o->op_flags
 395 #define OP_private(o)   o->op_private
 396
 397 MODULE = B      PACKAGE = B::OP         PREFIX = OP_
 398
 399 B::OP
 400 OP_next(o)
 401         B::OP           o
 402
 403 B::OP
 404 OP_sibling(o)
 405         B::OP           o
 406
 407 char *
 408 OP_ppaddr(o)
 409         B::OP           o
 410
 411 U16
 412 OP_targ(o)
 413         B::OP           o
 414
 415 U16
 416 OP_type(o)
 417         B::OP           o
 418
 419 U16
 420 OP_seq(o)
 421         B::OP           o
 422
 423 U8
 424 OP_flags(o)
 425         B::OP           o
 426
 427 U8
 428 OP_private(o)
 429         B::OP           o
 430
 431 #define UNOP_first(o)   o->op_first
 432
 433 MODULE = B      PACKAGE = B::UNOP               PREFIX = UNOP_
 434
 435 B::OP
 436 UNOP_first(o)
 437         B::UNOP o
 438
 439 #define BINOP_last(o)   o->op_last
 440
 441 MODULE = B      PACKAGE = B::BINOP              PREFIX = BINOP_
 442
 443 B::OP
 444 BINOP_last(o)
 445         B::BINOP        o
 446
 447 #define LOGOP_other(o)  o->op_other
 448
 449 MODULE = B      PACKAGE = B::LOGOP              PREFIX = LOGOP_
 450
 451 B::OP
 452 LOGOP_other(o)
 453         B::LOGOP        o
 454
 455 #define CONDOP_true(o)  o->op_true
 456 #define CONDOP_false(o) o->op_false
 457
 458 MODULE = B      PACKAGE = B::CONDOP             PREFIX = CONDOP_
 459
 460 B::OP
 461 CONDOP_true(o)
 462         B::CONDOP       o
 463
 464 B::OP
 465 CONDOP_false(o)
 466         B::CONDOP       o
 467
 468 #define LISTOP_children(o)      o->op_children
 469
 470 MODULE = B      PACKAGE = B::LISTOP             PREFIX = LISTOP_
 471
 472 U32
 473 LISTOP_children(o)
 474         B::LISTOP       o
 475
 476 #define PMOP_pmreplroot(o)      o->op_pmreplroot
 477 #define PMOP_pmreplstart(o)     o->op_pmreplstart
 478 #define PMOP_pmnext(o)          o->op_pmnext
 479 #define PMOP_pmregexp(o)        o->op_pmregexp
 480 #define PMOP_pmshort(o)         o->op_pmshort
 481 #define PMOP_pmflags(o)         o->op_pmflags
 482 #define PMOP_pmpermflags(o)     o->op_pmpermflags
 483 #define PMOP_pmslen(o)          o->op_pmslen
 484
 485 MODULE = B      PACKAGE = B::PMOP               PREFIX = PMOP_
 486
 487 void
 488 PMOP_pmreplroot(o)
 489         B::PMOP         o
 490         OP *            root = NO_INIT
 491     CODE:
 492         ST(0) = sv_newmortal();
 493         root = o->op_pmreplroot;
 494         /* OP_PUSHRE stores an SV* instead of an OP* in op_pmreplroot */
 495         if (o->op_type == OP_PUSHRE) {
 496             sv_setiv(newSVrv(ST(0), root ?
 497                              svclassnames[SvTYPE((SV*)root)] : "B::SV"),
 498                      (IV)root);
 499         }
 500         else {
 501             sv_setiv(newSVrv(ST(0), cc_opclassname(root)), (IV)root);
 502         }
 503
 504 B::OP
 505 PMOP_pmreplstart(o)
 506         B::PMOP         o
 507
 508 B::PMOP
 509 PMOP_pmnext(o)
 510         B::PMOP         o
 511
 512 B::SV
 513 PMOP_pmshort(o)
 514         B::PMOP         o
 515
 516 U16
 517 PMOP_pmflags(o)
 518         B::PMOP         o
 519
 520 U16
 521 PMOP_pmpermflags(o)
 522         B::PMOP         o
 523
 524 U8
 525 PMOP_pmslen(o)
 526         B::PMOP         o
 527
 528 void
 529 PMOP_precomp(o)
 530         B::PMOP         o
 531         REGEXP *        rx = NO_INIT
 532     CODE:
 533         ST(0) = sv_newmortal();
 534         rx = o->op_pmregexp;
 535         if (rx)
 536             sv_setpvn(ST(0), rx->precomp, rx->prelen);
 537
 538 #define SVOP_sv(o)      o->op_sv
 539
 540 MODULE = B      PACKAGE = B::SVOP               PREFIX = SVOP_
 541
 542
 543 B::SV
 544 SVOP_sv(o)
 545         B::SVOP o
 546
 547 #define GVOP_gv(o)      o->op_gv
 548
 549 MODULE = B      PACKAGE = B::GVOP               PREFIX = GVOP_
 550
 551
 552 B::GV
 553 GVOP_gv(o)
 554         B::GVOP o
 555
 556 MODULE = B      PACKAGE = B::PVOP               PREFIX = PVOP_
 557
 558 void
 559 PVOP_pv(o)
 560         B::PVOP o
 561     CODE:
 562         /*
 563          * OP_TRANS uses op_pv to point to a table of 256 shorts
 564          * whereas other PVOPs point to a null terminated string.
 565          */
 566         ST(0) = sv_2mortal(newSVpv(o->op_pv, (o->op_type == OP_TRANS) ?
 567                                    256 * sizeof(short) : 0));
 568
 569 #define LOOP_redoop(o)  o->op_redoop
 570 #define LOOP_nextop(o)  o->op_nextop
 571 #define LOOP_lastop(o)  o->op_lastop
 572
 573 MODULE = B      PACKAGE = B::LOOP               PREFIX = LOOP_
 574
 575
 576 B::OP
 577 LOOP_redoop(o)
 578         B::LOOP o
 579
 580 B::OP
 581 LOOP_nextop(o)
 582         B::LOOP o
 583
 584 B::OP
 585 LOOP_lastop(o)
 586         B::LOOP o
 587
 588 #define COP_label(o)    o->cop_label
 589 #define COP_stash(o)    o->cop_stash
 590 #define COP_filegv(o)   o->cop_filegv
 591 #define COP_cop_seq(o)  o->cop_seq
 592 #define COP_arybase(o)  o->cop_arybase
 593 #define COP_line(o)     o->cop_line
 594
 595 MODULE = B      PACKAGE = B::COP                PREFIX = COP_
 596
 597 char *
 598 COP_label(o)
 599         B::COP  o
 600
 601 B::HV
 602 COP_stash(o)
 603         B::COP  o
 604
 605 B::GV
 606 COP_filegv(o)
 607         B::COP  o
 608
 609 U32
 610 COP_cop_seq(o)
 611         B::COP  o
 612
 613 I32
 614 COP_arybase(o)
 615         B::COP  o
 616
 617 U16
 618 COP_line(o)
 619         B::COP  o
 620
 621 MODULE = B      PACKAGE = B::SV         PREFIX = Sv
 622
 623 U32
 624 SvREFCNT(sv)
 625         B::SV   sv
 626
 627 U32
 628 SvFLAGS(sv)
 629         B::SV   sv
 630
 631 MODULE = B      PACKAGE = B::IV         PREFIX = Sv
 632
 633 IV
 634 SvIV(sv)
 635         B::IV   sv
 636
 637 IV
 638 SvIVX(sv)
 639         B::IV   sv
 640
 641 MODULE = B      PACKAGE = B::IV
 642
 643 #define needs64bits(sv) ((I32)SvIVX(sv) != SvIVX(sv))
 644
 645 int
 646 needs64bits(sv)
 647         B::IV   sv
 648
 649 void
 650 packiv(sv)
 651         B::IV   sv
 652     CODE:
 653         if (sizeof(IV) == 8) {
 654             U32 wp[2];
 655             IV iv = SvIVX(sv);
 656             /*
 657              * The following way of spelling 32 is to stop compilers on
 658              * 32-bit architectures from moaning about the shift count
 659              * being >= the width of the type. Such architectures don't
 660              * reach this code anyway (unless sizeof(IV) > 8 but then
 661              * everything else breaks too so I'm not fussed at the moment).
 662              */
 663             wp[0] = htonl(((U32)iv) >> (sizeof(IV)*4));
 664             wp[1] = htonl(iv & 0xffffffff);
 665             ST(0) = sv_2mortal(newSVpv((char *)wp, 8));
 666         } else {
 667             U32 w = htonl((U32)SvIVX(sv));
 668             ST(0) = sv_2mortal(newSVpv((char *)&w, 4));
 669         }
 670
 671 MODULE = B      PACKAGE = B::NV         PREFIX = Sv
 672
 673 double
 674 SvNV(sv)
 675         B::NV   sv
 676
 677 double
 678 SvNVX(sv)
 679         B::NV   sv
 680
 681 MODULE = B      PACKAGE = B::RV         PREFIX = Sv
 682
 683 B::SV
 684 SvRV(sv)
 685         B::RV   sv
 686
 687 MODULE = B      PACKAGE = B::PV         PREFIX = Sv
 688
 689 void
 690 SvPV(sv)
 691         B::PV   sv
 692     CODE:
 693         ST(0) = sv_newmortal();
 694         sv_setpvn(ST(0), SvPVX(sv), SvCUR(sv));
 695
 696 MODULE = B      PACKAGE = B::PVMG       PREFIX = Sv
 697
 698 void
 699 SvMAGIC(sv)
 700         B::PVMG sv
 701         MAGIC * mg = NO_INIT
 702     PPCODE:
 703         for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic)
 704             XPUSHs(make_mg_object(sv_newmortal(), mg));
 705
 706 MODULE = B      PACKAGE = B::PVMG
 707
 708 B::HV
 709 SvSTASH(sv)
 710         B::PVMG sv
 711
 712 #define MgMOREMAGIC(mg) mg->mg_moremagic
 713 #define MgPRIVATE(mg) mg->mg_private
 714 #define MgTYPE(mg) mg->mg_type
 715 #define MgFLAGS(mg) mg->mg_flags
 716 #define MgOBJ(mg) mg->mg_obj
 717
 718 MODULE = B      PACKAGE = B::MAGIC      PREFIX = Mg
 719
 720 B::MAGIC
 721 MgMOREMAGIC(mg)
 722         B::MAGIC        mg
 723
 724 U16
 725 MgPRIVATE(mg)
 726         B::MAGIC        mg
 727
 728 char
 729 MgTYPE(mg)
 730         B::MAGIC        mg
 731
 732 U8
 733 MgFLAGS(mg)
 734         B::MAGIC        mg
 735
 736 B::SV
 737 MgOBJ(mg)
 738         B::MAGIC        mg
 739
 740 void
 741 MgPTR(mg)
 742         B::MAGIC        mg
 743     CODE:
 744         ST(0) = sv_newmortal();
 745         if (mg->mg_ptr)
 746             sv_setpvn(ST(0), mg->mg_ptr, mg->mg_len);
 747
 748 MODULE = B      PACKAGE = B::PVLV       PREFIX = Lv
 749
 750 U32
 751 LvTARGOFF(sv)
 752         B::PVLV sv
 753
 754 U32
 755 LvTARGLEN(sv)
 756         B::PVLV sv
 757
 758 char
 759 LvTYPE(sv)
 760         B::PVLV sv
 761
 762 B::SV
 763 LvTARG(sv)
 764         B::PVLV sv
 765
 766 MODULE = B      PACKAGE = B::BM         PREFIX = Bm
 767
 768 I32
 769 BmUSEFUL(sv)
 770         B::BM   sv
 771
 772 U16
 773 BmPREVIOUS(sv)
 774         B::BM   sv
 775
 776 U8
 777 BmRARE(sv)
 778         B::BM   sv
 779
 780 void
 781 BmTABLE(sv)
 782         B::BM   sv
 783         STRLEN  len = NO_INIT
 784         char *  str = NO_INIT
 785     CODE:
 786         str = SvPV(sv, len);
 787         /* Boyer-Moore table is just after string and its safety-margin \0 */
 788         ST(0) = sv_2mortal(newSVpv(str + len + 1, 256));
 789
 790 MODULE = B      PACKAGE = B::GV         PREFIX = Gv
 791
 792 void
 793 GvNAME(gv)
 794         B::GV   gv
 795     CODE:
 796         ST(0) = sv_2mortal(newSVpv(GvNAME(gv), GvNAMELEN(gv)));
 797
 798 B::HV
 799 GvSTASH(gv)
 800         B::GV   gv
 801
 802 B::SV
 803 GvSV(gv)
 804         B::GV   gv
 805
 806 B::IO
 807 GvIO(gv)
 808         B::GV   gv
 809
 810 B::CV
 811 GvFORM(gv)
 812         B::GV   gv
 813
 814 B::AV
 815 GvAV(gv)
 816         B::GV   gv
 817
 818 B::HV
 819 GvHV(gv)
 820         B::GV   gv
 821
 822 B::GV
 823 GvEGV(gv)
 824         B::GV   gv
 825
 826 B::CV
 827 GvCV(gv)
 828         B::GV   gv
 829
 830 U32
 831 GvCVGEN(gv)
 832         B::GV   gv
 833
 834 U16
 835 GvLINE(gv)
 836         B::GV   gv
 837
 838 B::GV
 839 GvFILEGV(gv)
 840         B::GV   gv
 841
 842 MODULE = B      PACKAGE = B::GV
 843
 844 U32
 845 GvREFCNT(gv)
 846         B::GV   gv
 847
 848 U8
 849 GvFLAGS(gv)
 850         B::GV   gv
 851
 852 MODULE = B      PACKAGE = B::IO         PREFIX = Io
 853
 854 long
 855 IoLINES(io)
 856         B::IO   io
 857
 858 long
 859 IoPAGE(io)
 860         B::IO   io
 861
 862 long
 863 IoPAGE_LEN(io)
 864         B::IO   io
 865
 866 long
 867 IoLINES_LEFT(io)
 868         B::IO   io
 869
 870 char *
 871 IoTOP_NAME(io)
 872         B::IO   io
 873
 874 B::GV
 875 IoTOP_GV(io)
 876         B::IO   io
 877
 878 char *
 879 IoFMT_NAME(io)
 880         B::IO   io
 881
 882 B::GV
 883 IoFMT_GV(io)
 884         B::IO   io
 885
 886 char *
 887 IoBOTTOM_NAME(io)
 888         B::IO   io
 889
 890 B::GV
 891 IoBOTTOM_GV(io)
 892         B::IO   io
 893
 894 short
 895 IoSUBPROCESS(io)
 896         B::IO   io
 897
 898 MODULE = B      PACKAGE = B::IO
 899
 900 char
 901 IoTYPE(io)
 902         B::IO   io
 903
 904 U8
 905 IoFLAGS(io)
 906         B::IO   io
 907
 908 MODULE = B      PACKAGE = B::AV         PREFIX = Av
 909
 910 SSize_t
 911 AvFILL(av)
 912         B::AV   av
 913
 914 SSize_t
 915 AvMAX(av)
 916         B::AV   av
 917
 918 #define AvOFF(av) ((XPVAV*)SvANY(av))->xof_off
 919
 920 IV
 921 AvOFF(av)
 922         B::AV   av
 923
 924 void
 925 AvARRAY(av)
 926         B::AV   av
 927     PPCODE:
 928         if (AvFILL(av) >= 0) {
 929             SV **svp = AvARRAY(av);
 930             I32 i;
 931             for (i = 0; i <= AvFILL(av); i++)
 932                 XPUSHs(make_sv_object(sv_newmortal(), svp[i]));
 933         }
 934
 935 MODULE = B      PACKAGE = B::AV
 936
 937 U8
 938 AvFLAGS(av)
 939         B::AV   av
 940
 941 MODULE = B      PACKAGE = B::CV         PREFIX = Cv
 942
 943 B::HV
 944 CvSTASH(cv)
 945         B::CV   cv
 946
 947 B::OP
 948 CvSTART(cv)
 949         B::CV   cv
 950
 951 B::OP
 952 CvROOT(cv)
 953         B::CV   cv
 954
 955 B::GV
 956 CvGV(cv)
 957         B::CV   cv
 958
 959 B::GV
 960 CvFILEGV(cv)
 961         B::CV   cv
 962
 963 long
 964 CvDEPTH(cv)
 965         B::CV   cv
 966
 967 B::AV
 968 CvPADLIST(cv)
 969         B::CV   cv
 970
 971 B::CV
 972 CvOUTSIDE(cv)
 973         B::CV   cv
 974
 975 void
 976 CvXSUB(cv)
 977         B::CV   cv
 978     CODE:
 979         ST(0) = sv_2mortal(newSViv((IV)CvXSUB(cv)));
 980
 981
 982 void
 983 CvXSUBANY(cv)
 984         B::CV   cv
 985     CODE:
 986         ST(0) = sv_2mortal(newSViv(CvXSUBANY(cv).any_iv));
 987
 988 MODULE = B      PACKAGE = B::HV         PREFIX = Hv
 989
 990 STRLEN
 991 HvFILL(hv)
 992         B::HV   hv
 993
 994 STRLEN
 995 HvMAX(hv)
 996         B::HV   hv
 997
 998 I32
 999 HvKEYS(hv)
1000         B::HV   hv
1001
1002 I32
1003 HvRITER(hv)
1004         B::HV   hv
1005
1006 char *
1007 HvNAME(hv)
1008         B::HV   hv
1009
1010 B::PMOP
1011 HvPMROOT(hv)
1012         B::HV   hv
1013
1014 void
1015 HvARRAY(hv)
1016         B::HV   hv
1017     PPCODE:
1018         if (HvKEYS(hv) > 0) {
1019             SV *sv;
1020             char *key;
1021             I32 len;
1022             (void)hv_iterinit(hv);
1023             EXTEND(sp, HvKEYS(hv) * 2);
1024             while (sv = hv_iternextsv(hv, &key, &len)) {
1025                 PUSHs(newSVpv(key, len));
1026                 PUSHs(make_sv_object(sv_newmortal(), sv));
1027             }
1028         }