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