ext/B/B.pm

   1 #      B.pm
   2 #
   3 #      Copyright (c) 1996, 1997, 1998 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 package B;
   9
  10 our $VERSION = '1.01';
  11
  12 use XSLoader ();
  13 require Exporter;
  14 @ISA = qw(Exporter);
  15
  16 # walkoptree_slow comes from B.pm (you are there),
  17 # walkoptree comes from B.xs
  18 @EXPORT_OK = qw(minus_c ppname save_BEGINs
  19                 class peekop cast_I32 cstring cchar hash threadsv_names
  20                 main_root main_start main_cv svref_2object opnumber
  21                 amagic_generation perlstring
  22                 walkoptree_slow walkoptree walkoptree_exec walksymtable
  23                 parents comppadlist sv_undef compile_stats timing_info
  24                 begin_av init_av check_av end_av regex_padav);
  25
  26 sub OPf_KIDS ();
  27 use strict;
  28 @B::SV::ISA = 'B::OBJECT';
  29 @B::NULL::ISA = 'B::SV';
  30 @B::PV::ISA = 'B::SV';
  31 @B::IV::ISA = 'B::SV';
  32 @B::NV::ISA = 'B::IV';
  33 @B::RV::ISA = 'B::SV';
  34 @B::PVIV::ISA = qw(B::PV B::IV);
  35 @B::PVNV::ISA = qw(B::PV B::NV);
  36 @B::PVMG::ISA = 'B::PVNV';
  37 @B::PVLV::ISA = 'B::PVMG';
  38 @B::BM::ISA = 'B::PVMG';
  39 @B::AV::ISA = 'B::PVMG';
  40 @B::GV::ISA = 'B::PVMG';
  41 @B::HV::ISA = 'B::PVMG';
  42 @B::CV::ISA = 'B::PVMG';
  43 @B::IO::ISA = 'B::PVMG';
  44 @B::FM::ISA = 'B::CV';
  45
  46 @B::OP::ISA = 'B::OBJECT';
  47 @B::UNOP::ISA = 'B::OP';
  48 @B::BINOP::ISA = 'B::UNOP';
  49 @B::LOGOP::ISA = 'B::UNOP';
  50 @B::LISTOP::ISA = 'B::BINOP';
  51 @B::SVOP::ISA = 'B::OP';
  52 @B::PADOP::ISA = 'B::OP';
  53 @B::PVOP::ISA = 'B::OP';
  54 @B::CVOP::ISA = 'B::OP';
  55 @B::LOOP::ISA = 'B::LISTOP';
  56 @B::PMOP::ISA = 'B::LISTOP';
  57 @B::COP::ISA = 'B::OP';
  58
  59 @B::SPECIAL::ISA = 'B::OBJECT';
  60
  61 {
  62     # Stop "-w" from complaining about the lack of a real B::OBJECT class
  63     package B::OBJECT;
  64 }
  65
  66 sub B::GV::SAFENAME {
  67   my $name = (shift())->NAME;
  68
  69   # The regex below corresponds to the isCONTROLVAR macro
  70   # from toke.c
  71
  72   $name =~ s/^([\cA-\cZ\c\\c[\c]\c?\c_\c^])/"^".
  73         chr( utf8::unicode_to_native( 64 ^ ord($1) ))/e;
  74
  75   # When we say unicode_to_native we really mean ascii_to_native,
  76   # which matters iff this is a non-ASCII platform (EBCDIC).
  77
  78   return $name;
  79 }
  80
  81 sub B::IV::int_value {
  82   my ($self) = @_;
  83   return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV);
  84 }
  85
  86 sub B::NULL::as_string() {""}
  87 sub B::IV::as_string()   {goto &B::IV::int_value}
  88 sub B::PV::as_string()   {goto &B::PV::PV}
  89
  90 my $debug;
  91 my $op_count = 0;
  92 my @parents = ();
  93
  94 sub debug {
  95     my ($class, $value) = @_;
  96     $debug = $value;
  97     walkoptree_debug($value);
  98 }
  99
 100 sub class {
 101     my $obj = shift;
 102     my $name = ref $obj;
 103     $name =~ s/^.*:://;
 104     return $name;
 105 }
 106
 107 sub parents { \@parents }
 108
 109 # For debugging
 110 sub peekop {
 111     my $op = shift;
 112     return sprintf("%s (0x%x) %s", class($op), $$op, $op->name);
 113 }
 114
 115 sub walkoptree_slow {
 116     my($op, $method, $level) = @_;
 117     $op_count++; # just for statistics
 118     $level ||= 0;
 119     warn(sprintf("walkoptree: %d. %s\n", $level, peekop($op))) if $debug;
 120     $op->$method($level);
 121     if ($$op && ($op->flags & OPf_KIDS)) {
 122         my $kid;
 123         unshift(@parents, $op);
 124         for ($kid = $op->first; $$kid; $kid = $kid->sibling) {
 125             walkoptree_slow($kid, $method, $level + 1);
 126         }
 127         shift @parents;
 128     }
 129     if (class($op) eq 'PMOP' && $op->pmreplroot && ${$op->pmreplroot}) {
 130         unshift(@parents, $op);
 131         walkoptree_slow($op->pmreplroot, $method, $level + 1);
 132         shift @parents;
 133     }
 134 }
 135
 136 sub compile_stats {
 137     return "Total number of OPs processed: $op_count\n";
 138 }
 139
 140 sub timing_info {
 141     my ($sec, $min, $hr) = localtime;
 142     my ($user, $sys) = times;
 143     sprintf("%02d:%02d:%02d user=$user sys=$sys",
 144             $hr, $min, $sec, $user, $sys);
 145 }
 146
 147 my %symtable;
 148
 149 sub clearsym {
 150     %symtable = ();
 151 }
 152
 153 sub savesym {
 154     my ($obj, $value) = @_;
 155 #    warn(sprintf("savesym: sym_%x => %s\n", $$obj, $value)); # debug
 156     $symtable{sprintf("sym_%x", $$obj)} = $value;
 157 }
 158
 159 sub objsym {
 160     my $obj = shift;
 161     return $symtable{sprintf("sym_%x", $$obj)};
 162 }
 163
 164 sub walkoptree_exec {
 165     my ($op, $method, $level) = @_;
 166     $level ||= 0;
 167     my ($sym, $ppname);
 168     my $prefix = "    " x $level;
 169     for (; $$op; $op = $op->next) {
 170         $sym = objsym($op);
 171         if (defined($sym)) {
 172             print $prefix, "goto $sym\n";
 173             return;
 174         }
 175         savesym($op, sprintf("%s (0x%lx)", class($op), $$op));
 176         $op->$method($level);
 177         $ppname = $op->name;
 178         if ($ppname =~
 179             /^(d?or(assign)?|and(assign)?|mapwhile|grepwhile|entertry|range|cond_expr)$/)
 180         {
 181             print $prefix, uc($1), " => {\n";
 182             walkoptree_exec($op->other, $method, $level + 1);
 183             print $prefix, "}\n";
 184         } elsif ($ppname eq "match" || $ppname eq "subst") {
 185             my $pmreplstart = $op->pmreplstart;
 186             if ($$pmreplstart) {
 187                 print $prefix, "PMREPLSTART => {\n";
 188                 walkoptree_exec($pmreplstart, $method, $level + 1);
 189                 print $prefix, "}\n";
 190             }
 191         } elsif ($ppname eq "substcont") {
 192             print $prefix, "SUBSTCONT => {\n";
 193             walkoptree_exec($op->other->pmreplstart, $method, $level + 1);
 194             print $prefix, "}\n";
 195             $op = $op->other;
 196         } elsif ($ppname eq "enterloop") {
 197             print $prefix, "REDO => {\n";
 198             walkoptree_exec($op->redoop, $method, $level + 1);
 199             print $prefix, "}\n", $prefix, "NEXT => {\n";
 200             walkoptree_exec($op->nextop, $method, $level + 1);
 201             print $prefix, "}\n", $prefix, "LAST => {\n";
 202             walkoptree_exec($op->lastop,  $method, $level + 1);
 203             print $prefix, "}\n";
 204         } elsif ($ppname eq "subst") {
 205             my $replstart = $op->pmreplstart;
 206             if ($$replstart) {
 207                 print $prefix, "SUBST => {\n";
 208                 walkoptree_exec($replstart, $method, $level + 1);
 209                 print $prefix, "}\n";
 210             }
 211         }
 212     }
 213 }
 214
 215 sub walksymtable {
 216     my ($symref, $method, $recurse, $prefix) = @_;
 217     my $sym;
 218     my $ref;
 219     my $fullname;
 220     no strict 'refs';
 221     $prefix = '' unless defined $prefix;
 222     while (($sym, $ref) = each %$symref) {
 223         $fullname = "*main::".$prefix.$sym;
 224         if ($sym =~ /::$/) {
 225             $sym = $prefix . $sym;
 226             if ($sym ne "main::" && $sym ne "<none>::" && &$recurse($sym)) {
 227                walksymtable(\%$fullname, $method, $recurse, $sym);
 228             }
 229         } else {
 230            svref_2object(\*$fullname)->$method();
 231         }
 232     }
 233 }
 234
 235 {
 236     package B::Section;
 237     my $output_fh;
 238     my %sections;
 239
 240     sub new {
 241         my ($class, $section, $symtable, $default) = @_;
 242         $output_fh ||= FileHandle->new_tmpfile;
 243         my $obj = bless [-1, $section, $symtable, $default], $class;
 244         $sections{$section} = $obj;
 245         return $obj;
 246     }
 247
 248     sub get {
 249         my ($class, $section) = @_;
 250         return $sections{$section};
 251     }
 252
 253     sub add {
 254         my $section = shift;
 255         while (defined($_ = shift)) {
 256             print $output_fh "$section->[1]\t$_\n";
 257             $section->[0]++;
 258         }
 259     }
 260
 261     sub index {
 262         my $section = shift;
 263         return $section->[0];
 264     }
 265
 266     sub name {
 267         my $section = shift;
 268         return $section->[1];
 269     }
 270
 271     sub symtable {
 272         my $section = shift;
 273         return $section->[2];
 274     }
 275
 276     sub default {
 277         my $section = shift;
 278         return $section->[3];
 279     }
 280
 281     sub output {
 282         my ($section, $fh, $format) = @_;
 283         my $name = $section->name;
 284         my $sym = $section->symtable || {};
 285         my $default = $section->default;
 286
 287         seek($output_fh, 0, 0);
 288         while (<$output_fh>) {
 289             chomp;
 290             s/^(.*?)\t//;
 291             if ($1 eq $name) {
 292                 s{(s\\_[0-9a-f]+)} {
 293                     exists($sym->{$1}) ? $sym->{$1} : $default;
 294                 }ge;
 295                 printf $fh $format, $_;
 296             }
 297         }
 298     }
 299 }
 300
 301 XSLoader::load 'B';
 302
 303 1;
 304
 305 __END__
 306
 307 =head1 NAME
 308
 309 B - The Perl Compiler
 310
 311 =head1 SYNOPSIS
 312
 313         use B;
 314
 315 =head1 DESCRIPTION
 316
 317 The C<B> module supplies classes which allow a Perl program to delve
 318 into its own innards. It is the module used to implement the
 319 "backends" of the Perl compiler. Usage of the compiler does not
 320 require knowledge of this module: see the F<O> module for the
 321 user-visible part. The C<B> module is of use to those who want to
 322 write new compiler backends. This documentation assumes that the
 323 reader knows a fair amount about perl's internals including such
 324 things as SVs, OPs and the internal symbol table and syntax tree
 325 of a program.
 326
 327 =head1 OVERVIEW
 328
 329 The C<B> module contains a set of utility functions for querying the
 330 current state of the Perl interpreter; typically these functions
 331 return objects from the B::SV and B::OP classes, or their derived
 332 classes.  These classes in turn define methods for querying the
 333 resulting objects about their own internal state.
 334
 335 =head1 Utility Functions
 336
 337 The C<B> module exports a variety of functions: some are simple
 338 utility functions, others provide a Perl program with a way to
 339 get an initial "handle" on an internal object.
 340
 341 =head2 Functions Returning C<B::SV>, C<B::AV>, C<B::HV>, and C<B::CV> objects
 342
 343 For descriptions of the class hierachy of these objects and the
 344 methods that can be called on them, see below, L<"OVERVIEW OF
 345 CLASSES"> and L<"SV-RELATED CLASSES">.
 346
 347 =over 4
 348
 349 =item sv_undef
 350
 351 Returns the SV object corresponding to the C variable C<sv_undef>.
 352
 353 =item sv_yes
 354
 355 Returns the SV object corresponding to the C variable C<sv_yes>.
 356
 357 =item sv_no
 358
 359 Returns the SV object corresponding to the C variable C<sv_no>.
 360
 361 =item svref_2object(SVREF)
 362
 363 Takes a reference to any Perl value, and turns the referred-to value
 364 into an object in the appropriate B::OP-derived or B::SV-derived
 365 class. Apart from functions such as C<main_root>, this is the primary
 366 way to get an initial "handle" on an internal perl data structure
 367 which can then be followed with the other access methods.
 368
 369 =item amagic_generation
 370
 371 Returns the SV object corresponding to the C variable C<amagic_generation>.
 372
 373 =item C<init_av>
 374
 375 Returns the AV object (i.e. in class B::AV) representing INIT blocks.
 376
 377 =item check_av
 378
 379 Returns the AV object (i.e. in class B::AV) representing CHECK blocks.
 380
 381 =item begin_av
 382
 383 Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
 384
 385 =item end_av
 386
 387 Returns the AV object (i.e. in class B::AV) representing END blocks.
 388
 389 =item comppadlist
 390
 391 Returns the AV object (i.e. in class B::AV) of the global comppadlist.
 392
 393 =item regex_padav
 394
 395 Only when perl was compiled with ithreads.
 396
 397 =item C<main_cv>
 398
 399 Return the (faked) CV corresponding to the main part of the Perl
 400 program.
 401
 402 =back
 403
 404 =head2 Functions for Examining the Symbol Table
 405
 406 =over 4
 407
 408 =item walksymtable(SYMREF, METHOD, RECURSE, PREFIX)
 409
 410 Walk the symbol table starting at SYMREF and call METHOD on each
 411 symbol (a B::GV object) visited.  When the walk reaches package
 412 symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
 413 name, and only recurses into the package if that sub returns true.
 414
 415 PREFIX is the name of the SYMREF you're walking.
 416
 417 For example:
 418
 419   # Walk CGI's symbol table calling print_subs on each symbol.
 420   # Recurse only into CGI::Util::
 421   walksymtable(\%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' },
 422                'CGI::');
 423
 424 print_subs() is a B::GV method you have declared. Also see L<"B::GV
 425 Methods">, below.
 426
 427 =back
 428
 429 =head2 Functions Returning C<B::OP> objects or for walking op trees
 430
 431 For descriptions of the class hierachy of these objects and the
 432 methods that can be called on them, see below, L<"OVERVIEW OF
 433 CLASSES"> and L<"OP-RELATED CLASSES">.
 434
 435 =over 4
 436
 437 =item main_root
 438
 439 Returns the root op (i.e. an object in the appropriate B::OP-derived
 440 class) of the main part of the Perl program.
 441
 442 =item main_start
 443
 444 Returns the starting op of the main part of the Perl program.
 445
 446 =item walkoptree(OP, METHOD)
 447
 448 Does a tree-walk of the syntax tree based at OP and calls METHOD on
 449 each op it visits. Each node is visited before its children. If
 450 C<walkoptree_debug> (see below) has been called to turn debugging on then
 451 the method C<walkoptree_debug> is called on each op before METHOD is
 452 called.
 453
 454 =item walkoptree_debug(DEBUG)
 455
 456 Returns the current debugging flag for C<walkoptree>. If the optional
 457 DEBUG argument is non-zero, it sets the debugging flag to that. See
 458 the description of C<walkoptree> above for what the debugging flag
 459 does.
 460
 461 =back
 462
 463 =head2 Miscellaneous Utility Functions
 464
 465 =over 4
 466
 467 =item ppname(OPNUM)
 468
 469 Return the PP function name (e.g. "pp_add") of op number OPNUM.
 470
 471 =item hash(STR)
 472
 473 Returns a string in the form "0x..." representing the value of the
 474 internal hash function used by perl on string STR.
 475
 476 =item cast_I32(I)
 477
 478 Casts I to the internal I32 type used by that perl.
 479
 480 =item minus_c
 481
 482 Does the equivalent of the C<-c> command-line option. Obviously, this
 483 is only useful in a BEGIN block or else the flag is set too late.
 484
 485 =item cstring(STR)
 486
 487 Returns a double-quote-surrounded escaped version of STR which can
 488 be used as a string in C source code.
 489
 490 =item perlstring(STR)
 491
 492 Returns a double-quote-surrounded escaped version of STR which can
 493 be used as a string in Perl source code.
 494
 495 =item class(OBJ)
 496
 497 Returns the class of an object without the part of the classname
 498 preceding the first C<"::">. This is used to turn C<"B::UNOP"> into
 499 C<"UNOP"> for example.
 500
 501 =item threadsv_names
 502
 503 In a perl compiled for threads, this returns a list of the special
 504 per-thread threadsv variables.
 505
 506 =back
 507
 508
 509
 510
 511 =head1 OVERVIEW OF CLASSES
 512
 513 The C structures used by Perl's internals to hold SV and OP
 514 information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
 515 class hierarchy and the C<B> module gives access to them via a true
 516 object hierarchy. Structure fields which point to other objects
 517 (whether types of SV or types of OP) are represented by the C<B>
 518 module as Perl objects of the appropriate class.
 519
 520 The bulk of the C<B> module is the methods for accessing fields of
 521 these structures.
 522
 523 Note that all access is read-only.  You cannot modify the internals by
 524 using this module.
 525
 526 =head2 SV-RELATED CLASSES
 527
 528 B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
 529 B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
 530 the obvious way to the underlying C structures of similar names. The
 531 inheritance hierarchy mimics the underlying C "inheritance":
 532
 533                              B::SV
 534                                |
 535                 +--------------+----------------------+
 536                 |              |                      |
 537               B::PV          B::IV                  B::RV
 538                 |  \        /     \
 539                 |   \      /       \
 540                 |   B::PVIV         B::NV
 541                  \                 /
 542                   \____         __/
 543                        \       /
 544                         B::PVNV
 545                            |
 546                            |
 547                         B::PVMG
 548                            |
 549          +------+-----+----+------+-----+-----+
 550          |      |     |    |      |     |     |
 551       B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO
 552                                         |
 553                                         |
 554                                       B::FM
 555
 556
 557 Access methods correspond to the underlying C macros for field access,
 558 usually with the leading "class indication" prefix removed (Sv, Av,
 559 Hv, ...). The leading prefix is only left in cases where its removal
 560 would cause a clash in method name. For example, C<GvREFCNT> stays
 561 as-is since its abbreviation would clash with the "superclass" method
 562 C<REFCNT> (corresponding to the C function C<SvREFCNT>).
 563
 564 =head2 B::SV Methods
 565
 566 =over 4
 567
 568 =item REFCNT
 569
 570 =item FLAGS
 571
 572 =back
 573
 574 =head2 B::IV Methods
 575
 576 =over 4
 577
 578 =item IV
 579
 580 Returns the value of the IV, I<interpreted as
 581 a signed integer>. This will be misleading
 582 if C<FLAGS & SVf_IVisUV>. Perhaps you want the
 583 C<int_value> method instead?
 584
 585 =item IVX
 586
 587 =item UVX
 588
 589 =item int_value
 590
 591 This method returns the value of the IV as an integer.
 592 It differs from C<IV> in that it returns the correct
 593 value regardless of whether it's stored signed or
 594 unsigned.
 595
 596 =item needs64bits
 597
 598 =item packiv
 599
 600 =back
 601
 602 =head2 B::NV Methods
 603
 604 =over 4
 605
 606 =item NV
 607
 608 =item NVX
 609
 610 =back
 611
 612 =head2 B::RV Methods
 613
 614 =over 4
 615
 616 =item RV
 617
 618 =back
 619
 620 =head2 B::PV Methods
 621
 622 =over 4
 623
 624 =item PV
 625
 626 This method is the one you usually want. It constructs a
 627 string using the length and offset information in the struct:
 628 for ordinary scalars it will return the string that you'd see
 629 from Perl, even if it contains null characters.
 630
 631 =item RV
 632
 633 Same as B::RV::RV, except that it will die() if the PV isn't
 634 a reference.
 635
 636 =item PVX
 637
 638 This method is less often useful. It assumes that the string
 639 stored in the struct is null-terminated, and disregards the
 640 length information.
 641
 642 It is the appropriate method to use if you need to get the name
 643 of a lexical variable from a padname array. Lexical variable names
 644 are always stored with a null terminator, and the length field
 645 (SvCUR) is overloaded for other purposes and can't be relied on here.
 646
 647 =back
 648
 649 =head2 B::PVMG Methods
 650
 651 =over 4
 652
 653 =item MAGIC
 654
 655 =item SvSTASH
 656
 657 =back
 658
 659 =head2 B::MAGIC Methods
 660
 661 =over 4
 662
 663 =item MOREMAGIC
 664
 665 =item precomp
 666
 667 Only valid on r-magic, returns the string that generated the regexp.
 668
 669 =item PRIVATE
 670
 671 =item TYPE
 672
 673 =item FLAGS
 674
 675 =item OBJ
 676
 677 Will die() if called on r-magic.
 678
 679 =item PTR
 680
 681 =item REGEX
 682
 683 Only valid on r-magic, returns the integer value of the REGEX stored
 684 in the MAGIC.
 685
 686 =back
 687
 688 =head2 B::PVLV Methods
 689
 690 =over 4
 691
 692 =item TARGOFF
 693
 694 =item TARGLEN
 695
 696 =item TYPE
 697
 698 =item TARG
 699
 700 =back
 701
 702 =head2 B::BM Methods
 703
 704 =over 4
 705
 706 =item USEFUL
 707
 708 =item PREVIOUS
 709
 710 =item RARE
 711
 712 =item TABLE
 713
 714 =back
 715
 716 =head2 B::GV Methods
 717
 718 =over 4
 719
 720 =item is_empty
 721
 722 This method returns TRUE if the GP field of the GV is NULL.
 723
 724 =item NAME
 725
 726 =item SAFENAME
 727
 728 This method returns the name of the glob, but if the first
 729 character of the name is a control character, then it converts
 730 it to ^X first, so that *^G would return "^G" rather than "\cG".
 731
 732 It's useful if you want to print out the name of a variable.
 733 If you restrict yourself to globs which exist at compile-time
 734 then the result ought to be unambiguous, because code like
 735 C<${"^G"} = 1> is compiled as two ops - a constant string and
 736 a dereference (rv2gv) - so that the glob is created at runtime.
 737
 738 If you're working with globs at runtime, and need to disambiguate
 739 *^G from *{"^G"}, then you should use the raw NAME method.
 740
 741 =item STASH
 742
 743 =item SV
 744
 745 =item IO
 746
 747 =item FORM
 748
 749 =item AV
 750
 751 =item HV
 752
 753 =item EGV
 754
 755 =item CV
 756
 757 =item CVGEN
 758
 759 =item LINE
 760
 761 =item FILE
 762
 763 =item FILEGV
 764
 765 =item GvREFCNT
 766
 767 =item FLAGS
 768
 769 =back
 770
 771 =head2 B::IO Methods
 772
 773 =over 4
 774
 775 =item LINES
 776
 777 =item PAGE
 778
 779 =item PAGE_LEN
 780
 781 =item LINES_LEFT
 782
 783 =item TOP_NAME
 784
 785 =item TOP_GV
 786
 787 =item FMT_NAME
 788
 789 =item FMT_GV
 790
 791 =item BOTTOM_NAME
 792
 793 =item BOTTOM_GV
 794
 795 =item SUBPROCESS
 796
 797 =item IoTYPE
 798
 799 =item IoFLAGS
 800
 801 =item IsSTD
 802
 803 Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
 804 if the IoIFP of the object is equal to the handle whose name was
 805 passed as argument ( i.e. $io->IsSTD('stderr') is true if
 806 IoIFP($io) == PerlIO_stdin() ).
 807
 808 =back
 809
 810 =head2 B::AV Methods
 811
 812 =over 4
 813
 814 =item FILL
 815
 816 =item MAX
 817
 818 =item OFF
 819
 820 =item ARRAY
 821
 822 =item AvFLAGS
 823
 824 =back
 825
 826 =head2 B::CV Methods
 827
 828 =over 4
 829
 830 =item STASH
 831
 832 =item START
 833
 834 =item ROOT
 835
 836 =item GV
 837
 838 =item FILE
 839
 840 =item DEPTH
 841
 842 =item PADLIST
 843
 844 =item OUTSIDE
 845
 846 =item OUTSIDE_SEQ
 847
 848 =item XSUB
 849
 850 =item XSUBANY
 851
 852 For constant subroutines, returns the constant SV returned by the subroutine.
 853
 854 =item CvFLAGS
 855
 856 =item const_sv
 857
 858 =back
 859
 860 =head2 B::HV Methods
 861
 862 =over 4
 863
 864 =item FILL
 865
 866 =item MAX
 867
 868 =item KEYS
 869
 870 =item RITER
 871
 872 =item NAME
 873
 874 =item PMROOT
 875
 876 =item ARRAY
 877
 878 =back
 879
 880 =head2 OP-RELATED CLASSES
 881
 882 C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
 883 C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::CVOP>, C<B::LOOP>, C<B::COP>.
 884
 885 These classes correspond in the obvious way to the underlying C
 886 structures of similar names. The inheritance hierarchy mimics the
 887 underlying C "inheritance":
 888
 889                                  B::OP
 890                                    |
 891                    +---------------+--------+--------+------+
 892                    |               |        |        |      |
 893                 B::UNOP          B::SVOP B::PADOP B::CVOP B::COP
 894                  ,'  `-.
 895                 /       `--.
 896            B::BINOP     B::LOGOP
 897                |
 898                |
 899            B::LISTOP
 900              ,' `.
 901             /     \
 902         B::LOOP B::PMOP
 903
 904 Access methods correspond to the underlying C structre field names,
 905 with the leading "class indication" prefix (C<"op_">) removed.
 906
 907 =head2 B::OP Methods
 908
 909 =over 4
 910
 911 =item next
 912
 913 =item sibling
 914
 915 =item name
 916
 917 This returns the op name as a string (e.g. "add", "rv2av").
 918
 919 =item ppaddr
 920
 921 This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
 922 "PL_ppaddr[OP_RV2AV]").
 923
 924 =item desc
 925
 926 This returns the op description from the global C PL_op_desc array
 927 (e.g. "addition" "array deref").
 928
 929 =item targ
 930
 931 =item type
 932
 933 =item seq
 934
 935 =item flags
 936
 937 =item private
 938
 939 =back
 940
 941 =head2 B::UNOP METHOD
 942
 943 =over 4
 944
 945 =item first
 946
 947 =back
 948
 949 =head2 B::BINOP METHOD
 950
 951 =over 4
 952
 953 =item last
 954
 955 =back
 956
 957 =head2 B::LOGOP METHOD
 958
 959 =over 4
 960
 961 =item other
 962
 963 =back
 964
 965 =head2 B::LISTOP METHOD
 966
 967 =over 4
 968
 969 =item children
 970
 971 =back
 972
 973 =head2 B::PMOP Methods
 974
 975 =over 4
 976
 977 =item pmreplroot
 978
 979 =item pmreplstart
 980
 981 =item pmnext
 982
 983 =item pmregexp
 984
 985 =item pmflags
 986
 987 =item pmdynflags
 988
 989 =item pmpermflags
 990
 991 =item precomp
 992
 993 =item pmoffet
 994
 995 Only when perl was compiled with ithreads.
 996
 997 =back
 998
 999 =head2 B::SVOP METHOD
1000
1001 =over 4
1002
1003 =item sv
1004
1005 =item gv
1006
1007 =back
1008
1009 =head2 B::PADOP METHOD
1010
1011 =over 4
1012
1013 =item padix
1014
1015 =back
1016
1017 =head2 B::PVOP METHOD
1018
1019 =over 4
1020
1021 =item pv
1022
1023 =back
1024
1025 =head2 B::LOOP Methods
1026
1027 =over 4
1028
1029 =item redoop
1030
1031 =item nextop
1032
1033 =item lastop
1034
1035 =back
1036
1037 =head2 B::COP Methods
1038
1039 =over 4
1040
1041 =item label
1042
1043 =item stash
1044
1045 =item stashpv
1046
1047 =item file
1048
1049 =item cop_seq
1050
1051 =item arybase
1052
1053 =item line
1054
1055 =item warnings
1056
1057 =item io
1058
1059 =back
1060
1061
1062 =head1 AUTHOR
1063
1064 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
1065
1066 =cut