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