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.06';
  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::GV';
  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::BM B::AV B::GV B::HV B::CV B::IO
 553                            |            |
 554                         B::PVLV         |
 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 =item object_2svref
 574
 575 Returns a reference to the regular scalar corresponding to this
 576 B::SV object. In other words, this method is the inverse operation
 577 to the svref_2object() subroutine. This scalar and other data it points
 578 at should be considered read-only: modifying them is neither safe nor
 579 guaranteed to have a sensible effect.
 580
 581 =back
 582
 583 =head2 B::IV Methods
 584
 585 =over 4
 586
 587 =item IV
 588
 589 Returns the value of the IV, I<interpreted as
 590 a signed integer>. This will be misleading
 591 if C<FLAGS & SVf_IVisUV>. Perhaps you want the
 592 C<int_value> method instead?
 593
 594 =item IVX
 595
 596 =item UVX
 597
 598 =item int_value
 599
 600 This method returns the value of the IV as an integer.
 601 It differs from C<IV> in that it returns the correct
 602 value regardless of whether it's stored signed or
 603 unsigned.
 604
 605 =item needs64bits
 606
 607 =item packiv
 608
 609 =back
 610
 611 =head2 B::NV Methods
 612
 613 =over 4
 614
 615 =item NV
 616
 617 =item NVX
 618
 619 =back
 620
 621 =head2 B::RV Methods
 622
 623 =over 4
 624
 625 =item RV
 626
 627 =back
 628
 629 =head2 B::PV Methods
 630
 631 =over 4
 632
 633 =item PV
 634
 635 This method is the one you usually want. It constructs a
 636 string using the length and offset information in the struct:
 637 for ordinary scalars it will return the string that you'd see
 638 from Perl, even if it contains null characters.
 639
 640 =item RV
 641
 642 Same as B::RV::RV, except that it will die() if the PV isn't
 643 a reference.
 644
 645 =item PVX
 646
 647 This method is less often useful. It assumes that the string
 648 stored in the struct is null-terminated, and disregards the
 649 length information.
 650
 651 It is the appropriate method to use if you need to get the name
 652 of a lexical variable from a padname array. Lexical variable names
 653 are always stored with a null terminator, and the length field
 654 (SvCUR) is overloaded for other purposes and can't be relied on here.
 655
 656 =back
 657
 658 =head2 B::PVMG Methods
 659
 660 =over 4
 661
 662 =item MAGIC
 663
 664 =item SvSTASH
 665
 666 =back
 667
 668 =head2 B::MAGIC Methods
 669
 670 =over 4
 671
 672 =item MOREMAGIC
 673
 674 =item precomp
 675
 676 Only valid on r-magic, returns the string that generated the regexp.
 677
 678 =item PRIVATE
 679
 680 =item TYPE
 681
 682 =item FLAGS
 683
 684 =item OBJ
 685
 686 Will die() if called on r-magic.
 687
 688 =item PTR
 689
 690 =item REGEX
 691
 692 Only valid on r-magic, returns the integer value of the REGEX stored
 693 in the MAGIC.
 694
 695 =back
 696
 697 =head2 B::PVLV Methods
 698
 699 =over 4
 700
 701 =item TARGOFF
 702
 703 =item TARGLEN
 704
 705 =item TYPE
 706
 707 =item TARG
 708
 709 =back
 710
 711 =head2 B::BM Methods
 712
 713 =over 4
 714
 715 =item USEFUL
 716
 717 =item PREVIOUS
 718
 719 =item RARE
 720
 721 =item TABLE
 722
 723 =back
 724
 725 =head2 B::GV Methods
 726
 727 =over 4
 728
 729 =item is_empty
 730
 731 This method returns TRUE if the GP field of the GV is NULL.
 732
 733 =item NAME
 734
 735 =item SAFENAME
 736
 737 This method returns the name of the glob, but if the first
 738 character of the name is a control character, then it converts
 739 it to ^X first, so that *^G would return "^G" rather than "\cG".
 740
 741 It's useful if you want to print out the name of a variable.
 742 If you restrict yourself to globs which exist at compile-time
 743 then the result ought to be unambiguous, because code like
 744 C<${"^G"} = 1> is compiled as two ops - a constant string and
 745 a dereference (rv2gv) - so that the glob is created at runtime.
 746
 747 If you're working with globs at runtime, and need to disambiguate
 748 *^G from *{"^G"}, then you should use the raw NAME method.
 749
 750 =item STASH
 751
 752 =item SV
 753
 754 =item IO
 755
 756 =item FORM
 757
 758 =item AV
 759
 760 =item HV
 761
 762 =item EGV
 763
 764 =item CV
 765
 766 =item CVGEN
 767
 768 =item LINE
 769
 770 =item FILE
 771
 772 =item FILEGV
 773
 774 =item GvREFCNT
 775
 776 =item FLAGS
 777
 778 =back
 779
 780 =head2 B::IO Methods
 781
 782 =over 4
 783
 784 =item LINES
 785
 786 =item PAGE
 787
 788 =item PAGE_LEN
 789
 790 =item LINES_LEFT
 791
 792 =item TOP_NAME
 793
 794 =item TOP_GV
 795
 796 =item FMT_NAME
 797
 798 =item FMT_GV
 799
 800 =item BOTTOM_NAME
 801
 802 =item BOTTOM_GV
 803
 804 =item SUBPROCESS
 805
 806 =item IoTYPE
 807
 808 =item IoFLAGS
 809
 810 =item IsSTD
 811
 812 Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
 813 if the IoIFP of the object is equal to the handle whose name was
 814 passed as argument ( i.e. $io->IsSTD('stderr') is true if
 815 IoIFP($io) == PerlIO_stdin() ).
 816
 817 =back
 818
 819 =head2 B::AV Methods
 820
 821 =over 4
 822
 823 =item FILL
 824
 825 =item MAX
 826
 827 =item OFF
 828
 829 =item ARRAY
 830
 831 =item ARRAYelt
 832
 833 Like C<ARRAY>, but takes an index as an argument to get only one element,
 834 rather than a list of all of them.
 835
 836 =item AvFLAGS
 837
 838 =back
 839
 840 =head2 B::CV Methods
 841
 842 =over 4
 843
 844 =item STASH
 845
 846 =item START
 847
 848 =item ROOT
 849
 850 =item GV
 851
 852 =item FILE
 853
 854 =item DEPTH
 855
 856 =item PADLIST
 857
 858 =item OUTSIDE
 859
 860 =item OUTSIDE_SEQ
 861
 862 =item XSUB
 863
 864 =item XSUBANY
 865
 866 For constant subroutines, returns the constant SV returned by the subroutine.
 867
 868 =item CvFLAGS
 869
 870 =item const_sv
 871
 872 =back
 873
 874 =head2 B::HV Methods
 875
 876 =over 4
 877
 878 =item FILL
 879
 880 =item MAX
 881
 882 =item KEYS
 883
 884 =item RITER
 885
 886 =item NAME
 887
 888 =item PMROOT
 889
 890 =item ARRAY
 891
 892 =back
 893
 894 =head2 OP-RELATED CLASSES
 895
 896 C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
 897 C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::LOOP>, C<B::COP>.
 898
 899 These classes correspond in the obvious way to the underlying C
 900 structures of similar names. The inheritance hierarchy mimics the
 901 underlying C "inheritance":
 902
 903                                  B::OP
 904                                    |
 905                    +---------------+--------+--------+
 906                    |               |        |        |
 907                 B::UNOP          B::SVOP B::PADOP  B::COP
 908                  ,'  `-.
 909                 /       `--.
 910            B::BINOP     B::LOGOP
 911                |
 912                |
 913            B::LISTOP
 914              ,' `.
 915             /     \
 916         B::LOOP B::PMOP
 917
 918 Access methods correspond to the underlying C structre field names,
 919 with the leading "class indication" prefix (C<"op_">) removed.
 920
 921 =head2 B::OP Methods
 922
 923 These methods get the values of similarly named fields within the OP
 924 data structure.  See top of C<op.h> for more info.
 925
 926 =over 4
 927
 928 =item next
 929
 930 =item sibling
 931
 932 =item name
 933
 934 This returns the op name as a string (e.g. "add", "rv2av").
 935
 936 =item ppaddr
 937
 938 This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
 939 "PL_ppaddr[OP_RV2AV]").
 940
 941 =item desc
 942
 943 This returns the op description from the global C PL_op_desc array
 944 (e.g. "addition" "array deref").
 945
 946 =item targ
 947
 948 =item type
 949
 950 =item opt
 951
 952 =item static
 953
 954 =item flags
 955
 956 =item private
 957
 958 =item spare
 959
 960 =back
 961
 962 =head2 B::UNOP METHOD
 963
 964 =over 4
 965
 966 =item first
 967
 968 =back
 969
 970 =head2 B::BINOP METHOD
 971
 972 =over 4
 973
 974 =item last
 975
 976 =back
 977
 978 =head2 B::LOGOP METHOD
 979
 980 =over 4
 981
 982 =item other
 983
 984 =back
 985
 986 =head2 B::LISTOP METHOD
 987
 988 =over 4
 989
 990 =item children
 991
 992 =back
 993
 994 =head2 B::PMOP Methods
 995
 996 =over 4
 997
 998 =item pmreplroot
 999
1000 =item pmreplstart
1001
1002 =item pmnext
1003
1004 =item pmregexp
1005
1006 =item pmflags
1007
1008 =item pmdynflags
1009
1010 =item pmpermflags
1011
1012 =item precomp
1013
1014 =item pmoffset
1015
1016 Only when perl was compiled with ithreads.
1017
1018 =back
1019
1020 =head2 B::SVOP METHOD
1021
1022 =over 4
1023
1024 =item sv
1025
1026 =item gv
1027
1028 =back
1029
1030 =head2 B::PADOP METHOD
1031
1032 =over 4
1033
1034 =item padix
1035
1036 =back
1037
1038 =head2 B::PVOP METHOD
1039
1040 =over 4
1041
1042 =item pv
1043
1044 =back
1045
1046 =head2 B::LOOP Methods
1047
1048 =over 4
1049
1050 =item redoop
1051
1052 =item nextop
1053
1054 =item lastop
1055
1056 =back
1057
1058 =head2 B::COP Methods
1059
1060 =over 4
1061
1062 =item label
1063
1064 =item stash
1065
1066 =item stashpv
1067
1068 =item file
1069
1070 =item cop_seq
1071
1072 =item arybase
1073
1074 =item line
1075
1076 =item warnings
1077
1078 =item io
1079
1080 =back
1081
1082
1083 =head1 AUTHOR
1084
1085 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
1086
1087 =cut