ext/B/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 #define PERL_NO_GET_CONTEXT
  11 #include "EXTERN.h"
  12 #include "perl.h"
  13 #include "XSUB.h"
  14
  15 #ifdef PerlIO
  16 typedef PerlIO * InputStream;
  17 #else
  18 typedef FILE * InputStream;
  19 #endif
  20
  21
  22 static char *svclassnames[] = {
  23     "B::NULL",
  24     "B::IV",
  25     "B::NV",
  26     "B::RV",
  27     "B::PV",
  28     "B::PVIV",
  29     "B::PVNV",
  30     "B::PVMG",
  31     "B::BM",
  32 #if PERL_VERSION >= 9
  33     "B::GV",
  34 #endif
  35     "B::PVLV",
  36     "B::AV",
  37     "B::HV",
  38     "B::CV",
  39 #if PERL_VERSION <= 8
  40     "B::GV",
  41 #endif
  42     "B::FM",
  43     "B::IO",
  44 };
  45
  46 typedef enum {
  47     OPc_NULL,   /* 0 */
  48     OPc_BASEOP, /* 1 */
  49     OPc_UNOP,   /* 2 */
  50     OPc_BINOP,  /* 3 */
  51     OPc_LOGOP,  /* 4 */
  52     OPc_LISTOP, /* 5 */
  53     OPc_PMOP,   /* 6 */
  54     OPc_SVOP,   /* 7 */
  55     OPc_PADOP,  /* 8 */
  56     OPc_PVOP,   /* 9 */
  57     OPc_LOOP,   /* 10 */
  58     OPc_COP     /* 11 */
  59 } opclass;
  60
  61 static char *opclassnames[] = {
  62     "B::NULL",
  63     "B::OP",
  64     "B::UNOP",
  65     "B::BINOP",
  66     "B::LOGOP",
  67     "B::LISTOP",
  68     "B::PMOP",
  69     "B::SVOP",
  70     "B::PADOP",
  71     "B::PVOP",
  72     "B::LOOP",
  73     "B::COP"
  74 };
  75
  76 static size_t opsizes[] = {
  77     0,
  78     sizeof(OP),
  79     sizeof(UNOP),
  80     sizeof(BINOP),
  81     sizeof(LOGOP),
  82     sizeof(LISTOP),
  83     sizeof(PMOP),
  84     sizeof(SVOP),
  85     sizeof(PADOP),
  86     sizeof(PVOP),
  87     sizeof(LOOP),
  88     sizeof(COP)
  89 };
  90
  91 #define MY_CXT_KEY "B::_guts" XS_VERSION
  92
  93 typedef struct {
  94     int         x_walkoptree_debug;     /* Flag for walkoptree debug hook */
  95     SV *        x_specialsv_list[7];
  96 } my_cxt_t;
  97
  98 START_MY_CXT
  99
 100 #define walkoptree_debug        (MY_CXT.x_walkoptree_debug)
 101 #define specialsv_list          (MY_CXT.x_specialsv_list)
 102
 103 static opclass
 104 cc_opclass(pTHX_ OP *o)
 105 {
 106     if (!o)
 107         return OPc_NULL;
 108
 109     if (o->op_type == 0)
 110         return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
 111
 112     if (o->op_type == OP_SASSIGN)
 113         return ((o->op_private & OPpASSIGN_BACKWARDS) ? OPc_UNOP : OPc_BINOP);
 114
 115 #ifdef USE_ITHREADS
 116     if (o->op_type == OP_GV || o->op_type == OP_GVSV ||
 117         o->op_type == OP_AELEMFAST || o->op_type == OP_RCATLINE)
 118         return OPc_PADOP;
 119 #endif
 120
 121     switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
 122     case OA_BASEOP:
 123         return OPc_BASEOP;
 124
 125     case OA_UNOP:
 126         return OPc_UNOP;
 127
 128     case OA_BINOP:
 129         return OPc_BINOP;
 130
 131     case OA_LOGOP:
 132         return OPc_LOGOP;
 133
 134     case OA_LISTOP:
 135         return OPc_LISTOP;
 136
 137     case OA_PMOP:
 138         return OPc_PMOP;
 139
 140     case OA_SVOP:
 141         return OPc_SVOP;
 142
 143     case OA_PADOP:
 144         return OPc_PADOP;
 145
 146     case OA_PVOP_OR_SVOP:
 147         /*
 148          * Character translations (tr///) are usually a PVOP, keeping a
 149          * pointer to a table of shorts used to look up translations.
 150          * Under utf8, however, a simple table isn't practical; instead,
 151          * the OP is an SVOP, and the SV is a reference to a swash
 152          * (i.e., an RV pointing to an HV).
 153          */
 154         return (o->op_private & (OPpTRANS_TO_UTF|OPpTRANS_FROM_UTF))
 155                 ? OPc_SVOP : OPc_PVOP;
 156
 157     case OA_LOOP:
 158         return OPc_LOOP;
 159
 160     case OA_COP:
 161         return OPc_COP;
 162
 163     case OA_BASEOP_OR_UNOP:
 164         /*
 165          * UNI(OP_foo) in toke.c returns token UNI or FUNC1 depending on
 166          * whether parens were seen. perly.y uses OPf_SPECIAL to
 167          * signal whether a BASEOP had empty parens or none.
 168          * Some other UNOPs are created later, though, so the best
 169          * test is OPf_KIDS, which is set in newUNOP.
 170          */
 171         return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
 172
 173     case OA_FILESTATOP:
 174         /*
 175          * The file stat OPs are created via UNI(OP_foo) in toke.c but use
 176          * the OPf_REF flag to distinguish between OP types instead of the
 177          * usual OPf_SPECIAL flag. As usual, if OPf_KIDS is set, then we
 178          * return OPc_UNOP so that walkoptree can find our children. If
 179          * OPf_KIDS is not set then we check OPf_REF. Without OPf_REF set
 180          * (no argument to the operator) it's an OP; with OPf_REF set it's
 181          * an SVOP (and op_sv is the GV for the filehandle argument).
 182          */
 183         return ((o->op_flags & OPf_KIDS) ? OPc_UNOP :
 184 #ifdef USE_ITHREADS
 185                 (o->op_flags & OPf_REF) ? OPc_PADOP : OPc_BASEOP);
 186 #else
 187                 (o->op_flags & OPf_REF) ? OPc_SVOP : OPc_BASEOP);
 188 #endif
 189     case OA_LOOPEXOP:
 190         /*
 191          * next, last, redo, dump and goto use OPf_SPECIAL to indicate that a
 192          * label was omitted (in which case it's a BASEOP) or else a term was
 193          * seen. In this last case, all except goto are definitely PVOP but
 194          * goto is either a PVOP (with an ordinary constant label), an UNOP
 195          * with OPf_STACKED (with a non-constant non-sub) or an UNOP for
 196          * OP_REFGEN (with goto &sub) in which case OPf_STACKED also seems to
 197          * get set.
 198          */
 199         if (o->op_flags & OPf_STACKED)
 200             return OPc_UNOP;
 201         else if (o->op_flags & OPf_SPECIAL)
 202             return OPc_BASEOP;
 203         else
 204             return OPc_PVOP;
 205     }
 206     warn("can't determine class of operator %s, assuming BASEOP\n",
 207          PL_op_name[o->op_type]);
 208     return OPc_BASEOP;
 209 }
 210
 211 static char *
 212 cc_opclassname(pTHX_ OP *o)
 213 {
 214     return opclassnames[cc_opclass(aTHX_ o)];
 215 }
 216
 217 static SV *
 218 make_sv_object(pTHX_ SV *arg, SV *sv)
 219 {
 220     char *type = 0;
 221     IV iv;
 222     dMY_CXT;
 223
 224     for (iv = 0; iv < sizeof(specialsv_list)/sizeof(SV*); iv++) {
 225         if (sv == specialsv_list[iv]) {
 226             type = "B::SPECIAL";
 227             break;
 228         }
 229     }
 230     if (!type) {
 231         type = svclassnames[SvTYPE(sv)];
 232         iv = PTR2IV(sv);
 233     }
 234     sv_setiv(newSVrv(arg, type), iv);
 235     return arg;
 236 }
 237
 238 static SV *
 239 make_mg_object(pTHX_ SV *arg, MAGIC *mg)
 240 {
 241     sv_setiv(newSVrv(arg, "B::MAGIC"), PTR2IV(mg));
 242     return arg;
 243 }
 244
 245 static SV *
 246 cstring(pTHX_ SV *sv, bool perlstyle)
 247 {
 248     SV *sstr = newSVpvn("", 0);
 249     STRLEN len;
 250     char *s;
 251     char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
 252
 253     if (!SvOK(sv))
 254         sv_setpvn(sstr, "0", 1);
 255     else if (perlstyle && SvUTF8(sv))
 256     {
 257         SV *tmpsv = sv_newmortal(); /* Temporary SV to feed sv_uni_display */
 258         len = SvCUR(sv);
 259         s = sv_uni_display(tmpsv, sv, 8*len, UNI_DISPLAY_QQ);
 260         sv_setpv(sstr,"\"");
 261         while (*s)
 262         {
 263             if (*s == '"')
 264                 sv_catpv(sstr, "\\\"");
 265             else if (*s == '$')
 266                 sv_catpv(sstr, "\\$");
 267             else if (*s == '@')
 268                 sv_catpv(sstr, "\\@");
 269             else if (*s == '\\')
 270             {
 271                 if (strchr("nrftax\\",*(s+1)))
 272                     sv_catpvn(sstr, s++, 2);
 273                 else
 274                     sv_catpv(sstr, "\\\\");
 275             }
 276             else /* should always be printable */
 277                 sv_catpvn(sstr, s, 1);
 278             ++s;
 279         }
 280         sv_catpv(sstr, "\"");
 281         return sstr;
 282     }
 283     else
 284     {
 285         /* XXX Optimise? */
 286         s = SvPV(sv, len);
 287         sv_catpv(sstr, "\"");
 288         for (; len; len--, s++)
 289         {
 290             /* At least try a little for readability */
 291             if (*s == '"')
 292                 sv_catpv(sstr, "\\\"");
 293             else if (*s == '\\')
 294                 sv_catpv(sstr, "\\\\");
 295             /* trigraphs - bleagh */
 296             else if (!perlstyle && *s == '?' && len>=3 && s[1] == '?')
 297             {
 298                 sprintf(escbuff, "\\%03o", '?');
 299                 sv_catpv(sstr, escbuff);
 300             }
 301             else if (perlstyle && *s == '$')
 302                 sv_catpv(sstr, "\\$");
 303             else if (perlstyle && *s == '@')
 304                 sv_catpv(sstr, "\\@");
 305 #ifdef EBCDIC
 306             else if (isPRINT(*s))
 307 #else
 308             else if (*s >= ' ' && *s < 127)
 309 #endif /* EBCDIC */
 310                 sv_catpvn(sstr, s, 1);
 311             else if (*s == '\n')
 312                 sv_catpv(sstr, "\\n");
 313             else if (*s == '\r')
 314                 sv_catpv(sstr, "\\r");
 315             else if (*s == '\t')
 316                 sv_catpv(sstr, "\\t");
 317             else if (*s == '\a')
 318                 sv_catpv(sstr, "\\a");
 319             else if (*s == '\b')
 320                 sv_catpv(sstr, "\\b");
 321             else if (*s == '\f')
 322                 sv_catpv(sstr, "\\f");
 323             else if (!perlstyle && *s == '\v')
 324                 sv_catpv(sstr, "\\v");
 325             else
 326             {
 327                 /* Don't want promotion of a signed -1 char in sprintf args */
 328                 unsigned char c = (unsigned char) *s;
 329                 sprintf(escbuff, "\\%03o", c);
 330                 sv_catpv(sstr, escbuff);
 331             }
 332             /* XXX Add line breaks if string is long */
 333         }
 334         sv_catpv(sstr, "\"");
 335     }
 336     return sstr;
 337 }
 338
 339 static SV *
 340 cchar(pTHX_ SV *sv)
 341 {
 342     SV *sstr = newSVpvn("'", 1);
 343     STRLEN n_a;
 344     char *s = SvPV(sv, n_a);
 345
 346     if (*s == '\'')
 347         sv_catpv(sstr, "\\'");
 348     else if (*s == '\\')
 349         sv_catpv(sstr, "\\\\");
 350 #ifdef EBCDIC
 351     else if (isPRINT(*s))
 352 #else
 353     else if (*s >= ' ' && *s < 127)
 354 #endif /* EBCDIC */
 355         sv_catpvn(sstr, s, 1);
 356     else if (*s == '\n')
 357         sv_catpv(sstr, "\\n");
 358     else if (*s == '\r')
 359         sv_catpv(sstr, "\\r");
 360     else if (*s == '\t')
 361         sv_catpv(sstr, "\\t");
 362     else if (*s == '\a')
 363         sv_catpv(sstr, "\\a");
 364     else if (*s == '\b')
 365         sv_catpv(sstr, "\\b");
 366     else if (*s == '\f')
 367         sv_catpv(sstr, "\\f");
 368     else if (*s == '\v')
 369         sv_catpv(sstr, "\\v");
 370     else
 371     {
 372         /* no trigraph support */
 373         char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
 374         /* Don't want promotion of a signed -1 char in sprintf args */
 375         unsigned char c = (unsigned char) *s;
 376         sprintf(escbuff, "\\%03o", c);
 377         sv_catpv(sstr, escbuff);
 378     }
 379     sv_catpv(sstr, "'");
 380     return sstr;
 381 }
 382
 383 void
 384 walkoptree(pTHX_ SV *opsv, char *method)
 385 {
 386     dSP;
 387     OP *o, *kid;
 388     dMY_CXT;
 389
 390     if (!SvROK(opsv))
 391         croak("opsv is not a reference");
 392     opsv = sv_mortalcopy(opsv);
 393     o = INT2PTR(OP*,SvIV((SV*)SvRV(opsv)));
 394     if (walkoptree_debug) {
 395         PUSHMARK(sp);
 396         XPUSHs(opsv);
 397         PUTBACK;
 398         perl_call_method("walkoptree_debug", G_DISCARD);
 399     }
 400     PUSHMARK(sp);
 401     XPUSHs(opsv);
 402     PUTBACK;
 403     perl_call_method(method, G_DISCARD);
 404     if (o && (o->op_flags & OPf_KIDS)) {
 405         for (kid = ((UNOP*)o)->op_first; kid; kid = kid->op_sibling) {
 406             /* Use the same opsv. Rely on methods not to mess it up. */
 407             sv_setiv(newSVrv(opsv, cc_opclassname(aTHX_ kid)), PTR2IV(kid));
 408             walkoptree(aTHX_ opsv, method);
 409         }
 410     }
 411     if (o && (cc_opclass(aTHX_ o) == OPc_PMOP)
 412             && (kid = cPMOPo->op_pmreplroot))
 413     {
 414         sv_setiv(newSVrv(opsv, opclassnames[OPc_PMOP]), PTR2IV(kid));
 415         walkoptree(aTHX_ opsv, method);
 416     }
 417 }
 418
 419 SV **
 420 oplist(pTHX_ OP *o, SV **SP)
 421 {
 422     for(; o; o = o->op_next) {
 423         SV *opsv;
 424 #if PERL_VERSION >= 9
 425         if (o->op_opt == 0)
 426             break;
 427         o->op_opt = 0;
 428 #else
 429         if (o->op_seq == 0)
 430             break;
 431         o->op_seq = 0;
 432 #endif
 433         opsv = sv_newmortal();
 434         sv_setiv(newSVrv(opsv, cc_opclassname(aTHX_ (OP*)o)), PTR2IV(o));
 435         XPUSHs(opsv);
 436         switch (o->op_type) {
 437         case OP_SUBST:
 438             SP = oplist(aTHX_ cPMOPo->op_pmreplstart, SP);
 439             continue;
 440         case OP_SORT:
 441             if (o->op_flags & OPf_STACKED && o->op_flags & OPf_SPECIAL) {
 442                 OP *kid = cLISTOPo->op_first->op_sibling;   /* pass pushmark */
 443                 kid = kUNOP->op_first;                      /* pass rv2gv */
 444                 kid = kUNOP->op_first;                      /* pass leave */
 445                 SP = oplist(aTHX_ kid->op_next, SP);
 446             }
 447             continue;
 448         }
 449         switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
 450         case OA_LOGOP:
 451             SP = oplist(aTHX_ cLOGOPo->op_other, SP);
 452             break;
 453         case OA_LOOP:
 454             SP = oplist(aTHX_ cLOOPo->op_lastop, SP);
 455             SP = oplist(aTHX_ cLOOPo->op_nextop, SP);
 456             SP = oplist(aTHX_ cLOOPo->op_redoop, SP);
 457             break;
 458         }
 459     }
 460     return SP;
 461 }
 462
 463 typedef OP      *B__OP;
 464 typedef UNOP    *B__UNOP;
 465 typedef BINOP   *B__BINOP;
 466 typedef LOGOP   *B__LOGOP;
 467 typedef LISTOP  *B__LISTOP;
 468 typedef PMOP    *B__PMOP;
 469 typedef SVOP    *B__SVOP;
 470 typedef PADOP   *B__PADOP;
 471 typedef PVOP    *B__PVOP;
 472 typedef LOOP    *B__LOOP;
 473 typedef COP     *B__COP;
 474
 475 typedef SV      *B__SV;
 476 typedef SV      *B__IV;
 477 typedef SV      *B__PV;
 478 typedef SV      *B__NV;
 479 typedef SV      *B__PVMG;
 480 typedef SV      *B__PVLV;
 481 typedef SV      *B__BM;
 482 typedef SV      *B__RV;
 483 typedef SV      *B__FM;
 484 typedef AV      *B__AV;
 485 typedef HV      *B__HV;
 486 typedef CV      *B__CV;
 487 typedef GV      *B__GV;
 488 typedef IO      *B__IO;
 489
 490 typedef MAGIC   *B__MAGIC;
 491
 492 MODULE = B      PACKAGE = B     PREFIX = B_
 493
 494 PROTOTYPES: DISABLE
 495
 496 BOOT:
 497 {
 498     HV *stash = gv_stashpvn("B", 1, TRUE);
 499     AV *export_ok = perl_get_av("B::EXPORT_OK",TRUE);
 500     MY_CXT_INIT;
 501     specialsv_list[0] = Nullsv;
 502     specialsv_list[1] = &PL_sv_undef;
 503     specialsv_list[2] = &PL_sv_yes;
 504     specialsv_list[3] = &PL_sv_no;
 505     specialsv_list[4] = pWARN_ALL;
 506     specialsv_list[5] = pWARN_NONE;
 507     specialsv_list[6] = pWARN_STD;
 508 #if PERL_VERSION <= 9
 509 #  define CVf_ASSERTION 0
 510 #endif
 511 #include "defsubs.h"
 512 }
 513
 514 #define B_main_cv()     PL_main_cv
 515 #define B_init_av()     PL_initav
 516 #define B_inc_gv()      PL_incgv
 517 #define B_check_av()    PL_checkav_save
 518 #define B_begin_av()    PL_beginav_save
 519 #define B_end_av()      PL_endav
 520 #define B_main_root()   PL_main_root
 521 #define B_main_start()  PL_main_start
 522 #define B_amagic_generation()   PL_amagic_generation
 523 #define B_defstash()    PL_defstash
 524 #define B_curstash()    PL_curstash
 525 #define B_dowarn()      PL_dowarn
 526 #define B_comppadlist() (PL_main_cv ? CvPADLIST(PL_main_cv) : CvPADLIST(PL_compcv))
 527 #define B_sv_undef()    &PL_sv_undef
 528 #define B_sv_yes()      &PL_sv_yes
 529 #define B_sv_no()       &PL_sv_no
 530 #define B_formfeed()    PL_formfeed
 531 #ifdef USE_ITHREADS
 532 #define B_regex_padav() PL_regex_padav
 533 #endif
 534
 535 B::AV
 536 B_init_av()
 537
 538 B::AV
 539 B_check_av()
 540
 541 B::AV
 542 B_begin_av()
 543
 544 B::AV
 545 B_end_av()
 546
 547 B::GV
 548 B_inc_gv()
 549
 550 #ifdef USE_ITHREADS
 551
 552 B::AV
 553 B_regex_padav()
 554
 555 #endif
 556
 557 B::CV
 558 B_main_cv()
 559
 560 B::OP
 561 B_main_root()
 562
 563 B::OP
 564 B_main_start()
 565
 566 long
 567 B_amagic_generation()
 568
 569 B::AV
 570 B_comppadlist()
 571
 572 B::SV
 573 B_sv_undef()
 574
 575 B::SV
 576 B_sv_yes()
 577
 578 B::SV
 579 B_sv_no()
 580
 581 B::HV
 582 B_curstash()
 583
 584 B::HV
 585 B_defstash()
 586
 587 U8
 588 B_dowarn()
 589
 590 B::SV
 591 B_formfeed()
 592
 593 void
 594 B_warnhook()
 595     CODE:
 596         ST(0) = make_sv_object(aTHX_ sv_newmortal(), PL_warnhook);
 597
 598 void
 599 B_diehook()
 600     CODE:
 601         ST(0) = make_sv_object(aTHX_ sv_newmortal(), PL_diehook);
 602
 603 MODULE = B      PACKAGE = B
 604
 605 void
 606 walkoptree(opsv, method)
 607         SV *    opsv
 608         char *  method
 609     CODE:
 610         walkoptree(aTHX_ opsv, method);
 611
 612 int
 613 walkoptree_debug(...)
 614     CODE:
 615         dMY_CXT;
 616         RETVAL = walkoptree_debug;
 617         if (items > 0 && SvTRUE(ST(1)))
 618             walkoptree_debug = 1;
 619     OUTPUT:
 620         RETVAL
 621
 622 #define address(sv) PTR2IV(sv)
 623
 624 IV
 625 address(sv)
 626         SV *    sv
 627
 628 B::SV
 629 svref_2object(sv)
 630         SV *    sv
 631     CODE:
 632         if (!SvROK(sv))
 633             croak("argument is not a reference");
 634         RETVAL = (SV*)SvRV(sv);
 635     OUTPUT:
 636         RETVAL
 637
 638 void
 639 opnumber(name)
 640 char *  name
 641 CODE:
 642 {
 643  int i;
 644  IV  result = -1;
 645  ST(0) = sv_newmortal();
 646  if (strncmp(name,"pp_",3) == 0)
 647    name += 3;
 648  for (i = 0; i < PL_maxo; i++)
 649   {
 650    if (strcmp(name, PL_op_name[i]) == 0)
 651     {
 652      result = i;
 653      break;
 654     }
 655   }
 656  sv_setiv(ST(0),result);
 657 }
 658
 659 void
 660 ppname(opnum)
 661         int     opnum
 662     CODE:
 663         ST(0) = sv_newmortal();
 664         if (opnum >= 0 && opnum < PL_maxo) {
 665             sv_setpvn(ST(0), "pp_", 3);
 666             sv_catpv(ST(0), PL_op_name[opnum]);
 667         }
 668
 669 void
 670 hash(sv)
 671         SV *    sv
 672     CODE:
 673         char *s;
 674         STRLEN len;
 675         U32 hash = 0;
 676         char hexhash[19]; /* must fit "0xffffffffffffffff" plus trailing \0 */
 677         s = SvPV(sv, len);
 678         PERL_HASH(hash, s, len);
 679         sprintf(hexhash, "0x%"UVxf, (UV)hash);
 680         ST(0) = sv_2mortal(newSVpv(hexhash, 0));
 681
 682 #define cast_I32(foo) (I32)foo
 683 IV
 684 cast_I32(i)
 685         IV      i
 686
 687 void
 688 minus_c()
 689     CODE:
 690         PL_minus_c = TRUE;
 691
 692 void
 693 save_BEGINs()
 694     CODE:
 695         PL_savebegin = TRUE;
 696
 697 SV *
 698 cstring(sv)
 699         SV *    sv
 700     CODE:
 701         RETVAL = cstring(aTHX_ sv, 0);
 702     OUTPUT:
 703         RETVAL
 704
 705 SV *
 706 perlstring(sv)
 707         SV *    sv
 708     CODE:
 709         RETVAL = cstring(aTHX_ sv, 1);
 710     OUTPUT:
 711         RETVAL
 712
 713 SV *
 714 cchar(sv)
 715         SV *    sv
 716     CODE:
 717         RETVAL = cchar(aTHX_ sv);
 718     OUTPUT:
 719         RETVAL
 720
 721 void
 722 threadsv_names()
 723     PPCODE:
 724
 725
 726 #define OP_next(o)      o->op_next
 727 #define OP_sibling(o)   o->op_sibling
 728 #define OP_desc(o)      PL_op_desc[o->op_type]
 729 #define OP_targ(o)      o->op_targ
 730 #define OP_type(o)      o->op_type
 731 #if PERL_VERSION >= 9
 732 #  define OP_opt(o)     o->op_opt
 733 #  define OP_static(o)  o->op_static
 734 #else
 735 #  define OP_seq(o)     o->op_seq
 736 #endif
 737 #define OP_flags(o)     o->op_flags
 738 #define OP_private(o)   o->op_private
 739 #define OP_spare(o)     o->op_spare
 740
 741 MODULE = B      PACKAGE = B::OP         PREFIX = OP_
 742
 743 size_t
 744 OP_size(o)
 745         B::OP           o
 746     CODE:
 747         RETVAL = opsizes[cc_opclass(aTHX_ o)];
 748     OUTPUT:
 749         RETVAL
 750
 751 B::OP
 752 OP_next(o)
 753         B::OP           o
 754
 755 B::OP
 756 OP_sibling(o)
 757         B::OP           o
 758
 759 char *
 760 OP_name(o)
 761         B::OP           o
 762     CODE:
 763         RETVAL = PL_op_name[o->op_type];
 764     OUTPUT:
 765         RETVAL
 766
 767
 768 void
 769 OP_ppaddr(o)
 770         B::OP           o
 771     PREINIT:
 772         int i;
 773         SV *sv = sv_newmortal();
 774     CODE:
 775         sv_setpvn(sv, "PL_ppaddr[OP_", 13);
 776         sv_catpv(sv, PL_op_name[o->op_type]);
 777         for (i=13; (STRLEN)i < SvCUR(sv); ++i)
 778             SvPVX(sv)[i] = toUPPER(SvPVX(sv)[i]);
 779         sv_catpv(sv, "]");
 780         ST(0) = sv;
 781
 782 char *
 783 OP_desc(o)
 784         B::OP           o
 785
 786 PADOFFSET
 787 OP_targ(o)
 788         B::OP           o
 789
 790 U16
 791 OP_type(o)
 792         B::OP           o
 793
 794 #if PERL_VERSION >= 9
 795
 796 U8
 797 OP_opt(o)
 798         B::OP           o
 799
 800 U8
 801 OP_static(o)
 802         B::OP           o
 803
 804 #else
 805
 806 U16
 807 OP_seq(o)
 808         B::OP           o
 809
 810 #endif
 811
 812 U8
 813 OP_flags(o)
 814         B::OP           o
 815
 816 U8
 817 OP_private(o)
 818         B::OP           o
 819
 820 #if PERL_VERSION >= 9
 821
 822 U8
 823 OP_spare(o)
 824         B::OP           o
 825
 826 #endif
 827
 828 void
 829 OP_oplist(o)
 830         B::OP           o
 831     PPCODE:
 832         SP = oplist(aTHX_ o, SP);
 833
 834 #define UNOP_first(o)   o->op_first
 835
 836 MODULE = B      PACKAGE = B::UNOP               PREFIX = UNOP_
 837
 838 B::OP
 839 UNOP_first(o)
 840         B::UNOP o
 841
 842 #define BINOP_last(o)   o->op_last
 843
 844 MODULE = B      PACKAGE = B::BINOP              PREFIX = BINOP_
 845
 846 B::OP
 847 BINOP_last(o)
 848         B::BINOP        o
 849
 850 #define LOGOP_other(o)  o->op_other
 851
 852 MODULE = B      PACKAGE = B::LOGOP              PREFIX = LOGOP_
 853
 854 B::OP
 855 LOGOP_other(o)
 856         B::LOGOP        o
 857
 858 MODULE = B      PACKAGE = B::LISTOP             PREFIX = LISTOP_
 859
 860 U32
 861 LISTOP_children(o)
 862         B::LISTOP       o
 863         OP *            kid = NO_INIT
 864         int             i = NO_INIT
 865     CODE:
 866         i = 0;
 867         for (kid = o->op_first; kid; kid = kid->op_sibling)
 868             i++;
 869         RETVAL = i;
 870     OUTPUT:
 871         RETVAL
 872
 873 #define PMOP_pmreplroot(o)      o->op_pmreplroot
 874 #define PMOP_pmreplstart(o)     o->op_pmreplstart
 875 #define PMOP_pmnext(o)          o->op_pmnext
 876 #define PMOP_pmregexp(o)        PM_GETRE(o)
 877 #ifdef USE_ITHREADS
 878 #define PMOP_pmoffset(o)        o->op_pmoffset
 879 #define PMOP_pmstashpv(o)       o->op_pmstashpv
 880 #else
 881 #define PMOP_pmstash(o)         o->op_pmstash
 882 #endif
 883 #define PMOP_pmflags(o)         o->op_pmflags
 884 #define PMOP_pmpermflags(o)     o->op_pmpermflags
 885 #define PMOP_pmdynflags(o)      o->op_pmdynflags
 886
 887 MODULE = B      PACKAGE = B::PMOP               PREFIX = PMOP_
 888
 889 void
 890 PMOP_pmreplroot(o)
 891         B::PMOP         o
 892         OP *            root = NO_INIT
 893     CODE:
 894         ST(0) = sv_newmortal();
 895         root = o->op_pmreplroot;
 896         /* OP_PUSHRE stores an SV* instead of an OP* in op_pmreplroot */
 897         if (o->op_type == OP_PUSHRE) {
 898 #ifdef USE_ITHREADS
 899             sv_setiv(ST(0), INT2PTR(PADOFFSET,root) );
 900 #else
 901             sv_setiv(newSVrv(ST(0), root ?
 902                              svclassnames[SvTYPE((SV*)root)] : "B::SV"),
 903                      PTR2IV(root));
 904 #endif
 905         }
 906         else {
 907             sv_setiv(newSVrv(ST(0), cc_opclassname(aTHX_ root)), PTR2IV(root));
 908         }
 909
 910 B::OP
 911 PMOP_pmreplstart(o)
 912         B::PMOP         o
 913
 914 B::PMOP
 915 PMOP_pmnext(o)
 916         B::PMOP         o
 917
 918 #ifdef USE_ITHREADS
 919
 920 IV
 921 PMOP_pmoffset(o)
 922         B::PMOP         o
 923
 924 char*
 925 PMOP_pmstashpv(o)
 926         B::PMOP         o
 927
 928 #else
 929
 930 B::HV
 931 PMOP_pmstash(o)
 932         B::PMOP         o
 933
 934 #endif
 935
 936 U32
 937 PMOP_pmflags(o)
 938         B::PMOP         o
 939
 940 U32
 941 PMOP_pmpermflags(o)
 942         B::PMOP         o
 943
 944 U8
 945 PMOP_pmdynflags(o)
 946         B::PMOP         o
 947
 948 void
 949 PMOP_precomp(o)
 950         B::PMOP         o
 951         REGEXP *        rx = NO_INIT
 952     CODE:
 953         ST(0) = sv_newmortal();
 954         rx = PM_GETRE(o);
 955         if (rx)
 956             sv_setpvn(ST(0), rx->precomp, rx->prelen);
 957
 958 #define SVOP_sv(o)     cSVOPo->op_sv
 959 #define SVOP_gv(o)     ((GV*)cSVOPo->op_sv)
 960
 961 MODULE = B      PACKAGE = B::SVOP               PREFIX = SVOP_
 962
 963 B::SV
 964 SVOP_sv(o)
 965         B::SVOP o
 966
 967 B::GV
 968 SVOP_gv(o)
 969         B::SVOP o
 970
 971 #define PADOP_padix(o)  o->op_padix
 972 #define PADOP_sv(o)     (o->op_padix ? PAD_SVl(o->op_padix) : Nullsv)
 973 #define PADOP_gv(o)     ((o->op_padix \
 974                           && SvTYPE(PAD_SVl(o->op_padix)) == SVt_PVGV) \
 975                          ? (GV*)PAD_SVl(o->op_padix) : Nullgv)
 976
 977 MODULE = B      PACKAGE = B::PADOP              PREFIX = PADOP_
 978
 979 PADOFFSET
 980 PADOP_padix(o)
 981         B::PADOP o
 982
 983 B::SV
 984 PADOP_sv(o)
 985         B::PADOP o
 986
 987 B::GV
 988 PADOP_gv(o)
 989         B::PADOP o
 990
 991 MODULE = B      PACKAGE = B::PVOP               PREFIX = PVOP_
 992
 993 void
 994 PVOP_pv(o)
 995         B::PVOP o
 996     CODE:
 997         /*
 998          * OP_TRANS uses op_pv to point to a table of 256 or >=258 shorts
 999          * whereas other PVOPs point to a null terminated string.
1000          */
1001         if (o->op_type == OP_TRANS &&
1002                 (o->op_private & OPpTRANS_COMPLEMENT) &&
1003                 !(o->op_private & OPpTRANS_DELETE))
1004         {
1005             short* tbl = (short*)o->op_pv;
1006             short entries = 257 + tbl[256];
1007             ST(0) = sv_2mortal(newSVpv(o->op_pv, entries * sizeof(short)));
1008         }
1009         else if (o->op_type == OP_TRANS) {
1010             ST(0) = sv_2mortal(newSVpv(o->op_pv, 256 * sizeof(short)));
1011         }
1012         else
1013             ST(0) = sv_2mortal(newSVpv(o->op_pv, 0));
1014
1015 #define LOOP_redoop(o)  o->op_redoop
1016 #define LOOP_nextop(o)  o->op_nextop
1017 #define LOOP_lastop(o)  o->op_lastop
1018
1019 MODULE = B      PACKAGE = B::LOOP               PREFIX = LOOP_
1020
1021
1022 B::OP
1023 LOOP_redoop(o)
1024         B::LOOP o
1025
1026 B::OP
1027 LOOP_nextop(o)
1028         B::LOOP o
1029
1030 B::OP
1031 LOOP_lastop(o)
1032         B::LOOP o
1033
1034 #define COP_label(o)    o->cop_label
1035 #define COP_stashpv(o)  CopSTASHPV(o)
1036 #define COP_stash(o)    CopSTASH(o)
1037 #define COP_file(o)     CopFILE(o)
1038 #define COP_filegv(o)   CopFILEGV(o)
1039 #define COP_cop_seq(o)  o->cop_seq
1040 #define COP_arybase(o)  o->cop_arybase
1041 #define COP_line(o)     CopLINE(o)
1042 #define COP_warnings(o) o->cop_warnings
1043 #define COP_io(o)       o->cop_io
1044
1045 MODULE = B      PACKAGE = B::COP                PREFIX = COP_
1046
1047 char *
1048 COP_label(o)
1049         B::COP  o
1050
1051 char *
1052 COP_stashpv(o)
1053         B::COP  o
1054
1055 B::HV
1056 COP_stash(o)
1057         B::COP  o
1058
1059 char *
1060 COP_file(o)
1061         B::COP  o
1062
1063 B::GV
1064 COP_filegv(o)
1065        B::COP  o
1066
1067
1068 U32
1069 COP_cop_seq(o)
1070         B::COP  o
1071
1072 I32
1073 COP_arybase(o)
1074         B::COP  o
1075
1076 U32
1077 COP_line(o)
1078         B::COP  o
1079
1080 B::SV
1081 COP_warnings(o)
1082         B::COP  o
1083
1084 B::SV
1085 COP_io(o)
1086         B::COP  o
1087
1088 MODULE = B      PACKAGE = B::SV
1089
1090 U32
1091 SvTYPE(sv)
1092         B::SV   sv
1093
1094 #define object_2svref(sv)       sv
1095 #define SVREF SV *
1096
1097 SVREF
1098 object_2svref(sv)
1099         B::SV   sv
1100
1101 MODULE = B      PACKAGE = B::SV         PREFIX = Sv
1102
1103 U32
1104 SvREFCNT(sv)
1105         B::SV   sv
1106
1107 U32
1108 SvFLAGS(sv)
1109         B::SV   sv
1110
1111 U32
1112 SvPOK(sv)
1113         B::SV   sv
1114
1115 U32
1116 SvROK(sv)
1117         B::SV   sv
1118
1119 U32
1120 SvMAGICAL(sv)
1121         B::SV   sv
1122
1123 MODULE = B      PACKAGE = B::IV         PREFIX = Sv
1124
1125 IV
1126 SvIV(sv)
1127         B::IV   sv
1128
1129 IV
1130 SvIVX(sv)
1131         B::IV   sv
1132
1133 UV
1134 SvUVX(sv)
1135         B::IV   sv
1136
1137
1138 MODULE = B      PACKAGE = B::IV
1139
1140 #define needs64bits(sv) ((I32)SvIVX(sv) != SvIVX(sv))
1141
1142 int
1143 needs64bits(sv)
1144         B::IV   sv
1145
1146 void
1147 packiv(sv)
1148         B::IV   sv
1149     CODE:
1150         if (sizeof(IV) == 8) {
1151             U32 wp[2];
1152             IV iv = SvIVX(sv);
1153             /*
1154              * The following way of spelling 32 is to stop compilers on
1155              * 32-bit architectures from moaning about the shift count
1156              * being >= the width of the type. Such architectures don't
1157              * reach this code anyway (unless sizeof(IV) > 8 but then
1158              * everything else breaks too so I'm not fussed at the moment).
1159              */
1160 #ifdef UV_IS_QUAD
1161             wp[0] = htonl(((UV)iv) >> (sizeof(UV)*4));
1162 #else
1163             wp[0] = htonl(((U32)iv) >> (sizeof(UV)*4));
1164 #endif
1165             wp[1] = htonl(iv & 0xffffffff);
1166             ST(0) = sv_2mortal(newSVpvn((char *)wp, 8));
1167         } else {
1168             U32 w = htonl((U32)SvIVX(sv));
1169             ST(0) = sv_2mortal(newSVpvn((char *)&w, 4));
1170         }
1171
1172 MODULE = B      PACKAGE = B::NV         PREFIX = Sv
1173
1174 NV
1175 SvNV(sv)
1176         B::NV   sv
1177
1178 NV
1179 SvNVX(sv)
1180         B::NV   sv
1181
1182 MODULE = B      PACKAGE = B::RV         PREFIX = Sv
1183
1184 B::SV
1185 SvRV(sv)
1186         B::RV   sv
1187
1188 MODULE = B      PACKAGE = B::PV         PREFIX = Sv
1189
1190 char*
1191 SvPVX(sv)
1192         B::PV   sv
1193
1194 B::SV
1195 SvRV(sv)
1196         B::PV   sv
1197     CODE:
1198         if( SvROK(sv) ) {
1199             RETVAL = SvRV(sv);
1200         }
1201         else {
1202             croak( "argument is not SvROK" );
1203         }
1204     OUTPUT:
1205         RETVAL
1206
1207 void
1208 SvPV(sv)
1209         B::PV   sv
1210     CODE:
1211         ST(0) = sv_newmortal();
1212         if( SvPOK(sv) ) {
1213             sv_setpvn(ST(0), SvPVX(sv), SvCUR(sv));
1214             SvFLAGS(ST(0)) |= SvUTF8(sv);
1215         }
1216         else {
1217             /* XXX for backward compatibility, but should fail */
1218             /* croak( "argument is not SvPOK" ); */
1219             sv_setpvn(ST(0), NULL, 0);
1220         }
1221
1222 void
1223 SvPVBM(sv)
1224         B::PV   sv
1225     CODE:
1226         ST(0) = sv_newmortal();
1227         sv_setpvn(ST(0), SvPVX(sv),
1228             SvCUR(sv) + (SvTYPE(sv) == SVt_PVBM ? 257 : 0));
1229
1230
1231 STRLEN
1232 SvLEN(sv)
1233         B::PV   sv
1234
1235 STRLEN
1236 SvCUR(sv)
1237         B::PV   sv
1238
1239 MODULE = B      PACKAGE = B::PVMG       PREFIX = Sv
1240
1241 void
1242 SvMAGIC(sv)
1243         B::PVMG sv
1244         MAGIC * mg = NO_INIT
1245     PPCODE:
1246         for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic)
1247             XPUSHs(make_mg_object(aTHX_ sv_newmortal(), mg));
1248
1249 MODULE = B      PACKAGE = B::PVMG
1250
1251 B::HV
1252 SvSTASH(sv)
1253         B::PVMG sv
1254
1255 #define MgMOREMAGIC(mg) mg->mg_moremagic
1256 #define MgPRIVATE(mg) mg->mg_private
1257 #define MgTYPE(mg) mg->mg_type
1258 #define MgFLAGS(mg) mg->mg_flags
1259 #define MgOBJ(mg) mg->mg_obj
1260 #define MgLENGTH(mg) mg->mg_len
1261 #define MgREGEX(mg) PTR2IV(mg->mg_obj)
1262
1263 MODULE = B      PACKAGE = B::MAGIC      PREFIX = Mg
1264
1265 B::MAGIC
1266 MgMOREMAGIC(mg)
1267         B::MAGIC        mg
1268      CODE:
1269         if( MgMOREMAGIC(mg) ) {
1270             RETVAL = MgMOREMAGIC(mg);
1271         }
1272         else {
1273             XSRETURN_UNDEF;
1274         }
1275      OUTPUT:
1276         RETVAL
1277
1278 U16
1279 MgPRIVATE(mg)
1280         B::MAGIC        mg
1281
1282 char
1283 MgTYPE(mg)
1284         B::MAGIC        mg
1285
1286 U8
1287 MgFLAGS(mg)
1288         B::MAGIC        mg
1289
1290 B::SV
1291 MgOBJ(mg)
1292         B::MAGIC        mg
1293
1294 IV
1295 MgREGEX(mg)
1296         B::MAGIC        mg
1297     CODE:
1298         if( mg->mg_type == 'r' ) {
1299             RETVAL = MgREGEX(mg);
1300         }
1301         else {
1302             croak( "REGEX is only meaningful on r-magic" );
1303         }
1304     OUTPUT:
1305         RETVAL
1306
1307 SV*
1308 precomp(mg)
1309         B::MAGIC        mg
1310     CODE:
1311         if (mg->mg_type == 'r') {
1312             REGEXP* rx = (REGEXP*)mg->mg_obj;
1313             if( rx )
1314                 RETVAL = newSVpvn( rx->precomp, rx->prelen );
1315         }
1316         else {
1317             croak( "precomp is only meaningful on r-magic" );
1318         }
1319     OUTPUT:
1320         RETVAL
1321
1322 I32
1323 MgLENGTH(mg)
1324         B::MAGIC        mg
1325
1326 void
1327 MgPTR(mg)
1328         B::MAGIC        mg
1329     CODE:
1330         ST(0) = sv_newmortal();
1331         if (mg->mg_ptr){
1332                 if (mg->mg_len >= 0){
1333                         sv_setpvn(ST(0), mg->mg_ptr, mg->mg_len);
1334                 } else if (mg->mg_len == HEf_SVKEY) {
1335                         ST(0) = make_sv_object(aTHX_
1336                                     sv_newmortal(), (SV*)mg->mg_ptr);
1337                 }
1338         }
1339
1340 MODULE = B      PACKAGE = B::PVLV       PREFIX = Lv
1341
1342 U32
1343 LvTARGOFF(sv)
1344         B::PVLV sv
1345
1346 U32
1347 LvTARGLEN(sv)
1348         B::PVLV sv
1349
1350 char
1351 LvTYPE(sv)
1352         B::PVLV sv
1353
1354 B::SV
1355 LvTARG(sv)
1356         B::PVLV sv
1357
1358 MODULE = B      PACKAGE = B::BM         PREFIX = Bm
1359
1360 I32
1361 BmUSEFUL(sv)
1362         B::BM   sv
1363
1364 U16
1365 BmPREVIOUS(sv)
1366         B::BM   sv
1367
1368 U8
1369 BmRARE(sv)
1370         B::BM   sv
1371
1372 void
1373 BmTABLE(sv)
1374         B::BM   sv
1375         STRLEN  len = NO_INIT
1376         char *  str = NO_INIT
1377     CODE:
1378         str = SvPV(sv, len);
1379         /* Boyer-Moore table is just after string and its safety-margin \0 */
1380         ST(0) = sv_2mortal(newSVpvn(str + len + 1, 256));
1381
1382 MODULE = B      PACKAGE = B::GV         PREFIX = Gv
1383
1384 void
1385 GvNAME(gv)
1386         B::GV   gv
1387     CODE:
1388         ST(0) = sv_2mortal(newSVpvn(GvNAME(gv), GvNAMELEN(gv)));
1389
1390 bool
1391 is_empty(gv)
1392         B::GV   gv
1393     CODE:
1394         RETVAL = GvGP(gv) == Null(GP*);
1395     OUTPUT:
1396         RETVAL
1397
1398 void*
1399 GvGP(gv)
1400         B::GV   gv
1401
1402 B::HV
1403 GvSTASH(gv)
1404         B::GV   gv
1405
1406 B::SV
1407 GvSV(gv)
1408         B::GV   gv
1409
1410 B::IO
1411 GvIO(gv)
1412         B::GV   gv
1413
1414 B::FM
1415 GvFORM(gv)
1416         B::GV   gv
1417     CODE:
1418         RETVAL = (SV*)GvFORM(gv);
1419     OUTPUT:
1420         RETVAL
1421
1422 B::AV
1423 GvAV(gv)
1424         B::GV   gv
1425
1426 B::HV
1427 GvHV(gv)
1428         B::GV   gv
1429
1430 B::GV
1431 GvEGV(gv)
1432         B::GV   gv
1433
1434 B::CV
1435 GvCV(gv)
1436         B::GV   gv
1437
1438 U32
1439 GvCVGEN(gv)
1440         B::GV   gv
1441
1442 U32
1443 GvLINE(gv)
1444         B::GV   gv
1445
1446 char *
1447 GvFILE(gv)
1448         B::GV   gv
1449
1450 B::GV
1451 GvFILEGV(gv)
1452         B::GV   gv
1453
1454 MODULE = B      PACKAGE = B::GV
1455
1456 U32
1457 GvREFCNT(gv)
1458         B::GV   gv
1459
1460 U8
1461 GvFLAGS(gv)
1462         B::GV   gv
1463
1464 MODULE = B      PACKAGE = B::IO         PREFIX = Io
1465
1466 long
1467 IoLINES(io)
1468         B::IO   io
1469
1470 long
1471 IoPAGE(io)
1472         B::IO   io
1473
1474 long
1475 IoPAGE_LEN(io)
1476         B::IO   io
1477
1478 long
1479 IoLINES_LEFT(io)
1480         B::IO   io
1481
1482 char *
1483 IoTOP_NAME(io)
1484         B::IO   io
1485
1486 B::GV
1487 IoTOP_GV(io)
1488         B::IO   io
1489
1490 char *
1491 IoFMT_NAME(io)
1492         B::IO   io
1493
1494 B::GV
1495 IoFMT_GV(io)
1496         B::IO   io
1497
1498 char *
1499 IoBOTTOM_NAME(io)
1500         B::IO   io
1501
1502 B::GV
1503 IoBOTTOM_GV(io)
1504         B::IO   io
1505
1506 short
1507 IoSUBPROCESS(io)
1508         B::IO   io
1509
1510 bool
1511 IsSTD(io,name)
1512         B::IO   io
1513         char*   name
1514     PREINIT:
1515         PerlIO* handle = 0;
1516     CODE:
1517         if( strEQ( name, "stdin" ) ) {
1518             handle = PerlIO_stdin();
1519         }
1520         else if( strEQ( name, "stdout" ) ) {
1521             handle = PerlIO_stdout();
1522         }
1523         else if( strEQ( name, "stderr" ) ) {
1524             handle = PerlIO_stderr();
1525         }
1526         else {
1527             croak( "Invalid value '%s'", name );
1528         }
1529         RETVAL = handle == IoIFP(io);
1530     OUTPUT:
1531         RETVAL
1532
1533 MODULE = B      PACKAGE = B::IO
1534
1535 char
1536 IoTYPE(io)
1537         B::IO   io
1538
1539 U8
1540 IoFLAGS(io)
1541         B::IO   io
1542
1543 MODULE = B      PACKAGE = B::AV         PREFIX = Av
1544
1545 SSize_t
1546 AvFILL(av)
1547         B::AV   av
1548
1549 SSize_t
1550 AvMAX(av)
1551         B::AV   av
1552
1553 #define AvOFF(av) ((XPVAV*)SvANY(av))->xof_off
1554
1555 IV
1556 AvOFF(av)
1557         B::AV   av
1558
1559 void
1560 AvARRAY(av)
1561         B::AV   av
1562     PPCODE:
1563         if (AvFILL(av) >= 0) {
1564             SV **svp = AvARRAY(av);
1565             I32 i;
1566             for (i = 0; i <= AvFILL(av); i++)
1567                 XPUSHs(make_sv_object(aTHX_ sv_newmortal(), svp[i]));
1568         }
1569
1570 void
1571 AvARRAYelt(av, idx)
1572         B::AV   av
1573         int     idx
1574     PPCODE:
1575         if (idx >= 0 && AvFILL(av) >= 0 && idx <= AvFILL(av))
1576             XPUSHs(make_sv_object(aTHX_ sv_newmortal(), (AvARRAY(av)[idx])));
1577         else
1578             XPUSHs(make_sv_object(aTHX_ sv_newmortal(), NULL));
1579
1580
1581 MODULE = B      PACKAGE = B::AV
1582
1583 U8
1584 AvFLAGS(av)
1585         B::AV   av
1586
1587 MODULE = B      PACKAGE = B::FM         PREFIX = Fm
1588
1589 IV
1590 FmLINES(form)
1591         B::FM   form
1592
1593 MODULE = B      PACKAGE = B::CV         PREFIX = Cv
1594
1595 U32
1596 CvCONST(cv)
1597         B::CV   cv
1598
1599 B::HV
1600 CvSTASH(cv)
1601         B::CV   cv
1602
1603 B::OP
1604 CvSTART(cv)
1605         B::CV   cv
1606
1607 B::OP
1608 CvROOT(cv)
1609         B::CV   cv
1610
1611 B::GV
1612 CvGV(cv)
1613         B::CV   cv
1614
1615 char *
1616 CvFILE(cv)
1617         B::CV   cv
1618
1619 long
1620 CvDEPTH(cv)
1621         B::CV   cv
1622
1623 B::AV
1624 CvPADLIST(cv)
1625         B::CV   cv
1626
1627 B::CV
1628 CvOUTSIDE(cv)
1629         B::CV   cv
1630
1631 U32
1632 CvOUTSIDE_SEQ(cv)
1633         B::CV   cv
1634
1635 void
1636 CvXSUB(cv)
1637         B::CV   cv
1638     CODE:
1639         ST(0) = sv_2mortal(newSViv(PTR2IV(CvXSUB(cv))));
1640
1641
1642 void
1643 CvXSUBANY(cv)
1644         B::CV   cv
1645     CODE:
1646         ST(0) = CvCONST(cv) ?
1647             make_sv_object(aTHX_ sv_newmortal(),CvXSUBANY(cv).any_ptr) :
1648             sv_2mortal(newSViv(CvXSUBANY(cv).any_iv));
1649
1650 MODULE = B    PACKAGE = B::CV
1651
1652 U16
1653 CvFLAGS(cv)
1654       B::CV   cv
1655
1656 MODULE = B      PACKAGE = B::CV         PREFIX = cv_
1657
1658 B::SV
1659 cv_const_sv(cv)
1660         B::CV   cv
1661
1662
1663 MODULE = B      PACKAGE = B::HV         PREFIX = Hv
1664
1665 STRLEN
1666 HvFILL(hv)
1667         B::HV   hv
1668
1669 STRLEN
1670 HvMAX(hv)
1671         B::HV   hv
1672
1673 I32
1674 HvKEYS(hv)
1675         B::HV   hv
1676
1677 I32
1678 HvRITER(hv)
1679         B::HV   hv
1680
1681 char *
1682 HvNAME(hv)
1683         B::HV   hv
1684
1685 B::PMOP
1686 HvPMROOT(hv)
1687         B::HV   hv
1688
1689 void
1690 HvARRAY(hv)
1691         B::HV   hv
1692     PPCODE:
1693         if (HvKEYS(hv) > 0) {
1694             SV *sv;
1695             char *key;
1696             I32 len;
1697             (void)hv_iterinit(hv);
1698             EXTEND(sp, HvKEYS(hv) * 2);
1699             while ((sv = hv_iternextsv(hv, &key, &len))) {
1700                 PUSHs(newSVpvn(key, len));
1701                 PUSHs(make_sv_object(aTHX_ sv_newmortal(), sv));
1702             }
1703         }