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.14';
  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                 sub_generation amagic_generation perlstring
  22                 walkoptree_slow walkoptree walkoptree_exec walksymtable
  23                 parents comppadlist sv_undef compile_stats timing_info
  24                 begin_av init_av unitcheck_av check_av end_av regex_padav
  25                 dowarn 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::SV';
  35 @B::RV::ISA = 'B::SV';
  36 @B::PVIV::ISA = qw(B::PV B::IV);
  37 @B::PVNV::ISA = qw(B::PVIV B::NV);
  38 @B::PVMG::ISA = 'B::PVNV';
  39 # Change in the inheritance hierarchy post 5.9.0
  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' && ref($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 hierarchy 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 The returned object will only be valid as long as the underlying OPs
 372 and SVs continue to exist. Do not attempt to use the object after the
 373 underlying structures are freed.
 374
 375 =item amagic_generation
 376
 377 Returns the SV object corresponding to the C variable C<amagic_generation>.
 378
 379 =item init_av
 380
 381 Returns the AV object (i.e. in class B::AV) representing INIT blocks.
 382
 383 =item check_av
 384
 385 Returns the AV object (i.e. in class B::AV) representing CHECK blocks.
 386
 387 =item unitcheck_av
 388
 389 Returns the AV object (i.e. in class B::AV) representing UNITCHECK blocks.
 390
 391 =item begin_av
 392
 393 Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
 394
 395 =item end_av
 396
 397 Returns the AV object (i.e. in class B::AV) representing END blocks.
 398
 399 =item comppadlist
 400
 401 Returns the AV object (i.e. in class B::AV) of the global comppadlist.
 402
 403 =item regex_padav
 404
 405 Only when perl was compiled with ithreads.
 406
 407 =item main_cv
 408
 409 Return the (faked) CV corresponding to the main part of the Perl
 410 program.
 411
 412 =back
 413
 414 =head2 Functions for Examining the Symbol Table
 415
 416 =over 4
 417
 418 =item walksymtable(SYMREF, METHOD, RECURSE, PREFIX)
 419
 420 Walk the symbol table starting at SYMREF and call METHOD on each
 421 symbol (a B::GV object) visited.  When the walk reaches package
 422 symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
 423 name, and only recurses into the package if that sub returns true.
 424
 425 PREFIX is the name of the SYMREF you're walking.
 426
 427 For example:
 428
 429   # Walk CGI's symbol table calling print_subs on each symbol.
 430   # Recurse only into CGI::Util::
 431   walksymtable(\%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' },
 432                'CGI::');
 433
 434 print_subs() is a B::GV method you have declared. Also see L<"B::GV
 435 Methods">, below.
 436
 437 =back
 438
 439 =head2 Functions Returning C<B::OP> objects or for walking op trees
 440
 441 For descriptions of the class hierarchy of these objects and the
 442 methods that can be called on them, see below, L<"OVERVIEW OF
 443 CLASSES"> and L<"OP-RELATED CLASSES">.
 444
 445 =over 4
 446
 447 =item main_root
 448
 449 Returns the root op (i.e. an object in the appropriate B::OP-derived
 450 class) of the main part of the Perl program.
 451
 452 =item main_start
 453
 454 Returns the starting op of the main part of the Perl program.
 455
 456 =item walkoptree(OP, METHOD)
 457
 458 Does a tree-walk of the syntax tree based at OP and calls METHOD on
 459 each op it visits. Each node is visited before its children. If
 460 C<walkoptree_debug> (see below) has been called to turn debugging on then
 461 the method C<walkoptree_debug> is called on each op before METHOD is
 462 called.
 463
 464 =item walkoptree_debug(DEBUG)
 465
 466 Returns the current debugging flag for C<walkoptree>. If the optional
 467 DEBUG argument is non-zero, it sets the debugging flag to that. See
 468 the description of C<walkoptree> above for what the debugging flag
 469 does.
 470
 471 =back
 472
 473 =head2 Miscellaneous Utility Functions
 474
 475 =over 4
 476
 477 =item ppname(OPNUM)
 478
 479 Return the PP function name (e.g. "pp_add") of op number OPNUM.
 480
 481 =item hash(STR)
 482
 483 Returns a string in the form "0x..." representing the value of the
 484 internal hash function used by perl on string STR.
 485
 486 =item cast_I32(I)
 487
 488 Casts I to the internal I32 type used by that perl.
 489
 490 =item minus_c
 491
 492 Does the equivalent of the C<-c> command-line option. Obviously, this
 493 is only useful in a BEGIN block or else the flag is set too late.
 494
 495 =item cstring(STR)
 496
 497 Returns a double-quote-surrounded escaped version of STR which can
 498 be used as a string in C source code.
 499
 500 =item perlstring(STR)
 501
 502 Returns a double-quote-surrounded escaped version of STR which can
 503 be used as a string in Perl source code.
 504
 505 =item class(OBJ)
 506
 507 Returns the class of an object without the part of the classname
 508 preceding the first C<"::">. This is used to turn C<"B::UNOP"> into
 509 C<"UNOP"> for example.
 510
 511 =item threadsv_names
 512
 513 In a perl compiled for threads, this returns a list of the special
 514 per-thread threadsv variables.
 515
 516 =back
 517
 518
 519
 520
 521 =head1 OVERVIEW OF CLASSES
 522
 523 The C structures used by Perl's internals to hold SV and OP
 524 information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
 525 class hierarchy and the C<B> module gives access to them via a true
 526 object hierarchy. Structure fields which point to other objects
 527 (whether types of SV or types of OP) are represented by the C<B>
 528 module as Perl objects of the appropriate class.
 529
 530 The bulk of the C<B> module is the methods for accessing fields of
 531 these structures.
 532
 533 Note that all access is read-only.  You cannot modify the internals by
 534 using this module. Also, note that the B::OP and B::SV objects created
 535 by this module are only valid for as long as the underlying objects
 536 exist; their creation doesn't increase the reference counts of the
 537 underlying objects. Trying to access the fields of a freed object will
 538 give incomprehensible results, or worse.
 539
 540 =head2 SV-RELATED CLASSES
 541
 542 B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
 543 B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
 544 the obvious way to the underlying C structures of similar names. The
 545 inheritance hierarchy mimics the underlying C "inheritance". For 5.9.1
 546 and later this is:
 547
 548                              B::SV
 549                                |
 550                 +--------------+----------+------------+
 551                 |              |          |            |
 552               B::PV          B::IV      B::NV        B::RV
 553                    \         /          /
 554                     \       /          /
 555                      B::PVIV          /
 556                          \           /
 557                           \         /
 558                            \       /
 559                             B::PVNV
 560                                |
 561                                |
 562                             B::PVMG
 563                                |
 564                     +-----+----+------+-----+-----+
 565                     |     |    |      |     |     |
 566                   B::BM B::AV B::GV B::HV B::CV B::IO
 567                                |            |
 568                             B::PVLV         |
 569                                           B::FM
 570
 571
 572 For 5.9.0 and earlier, PVLV is a direct subclass of PVMG, so the base
 573 of this diagram is
 574
 575                            |
 576                         B::PVMG
 577                            |
 578          +------+-----+----+------+-----+-----+
 579          |      |     |    |      |     |     |
 580       B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO
 581                                         |
 582                                         |
 583                                       B::FM
 584
 585
 586 Access methods correspond to the underlying C macros for field access,
 587 usually with the leading "class indication" prefix removed (Sv, Av,
 588 Hv, ...). The leading prefix is only left in cases where its removal
 589 would cause a clash in method name. For example, C<GvREFCNT> stays
 590 as-is since its abbreviation would clash with the "superclass" method
 591 C<REFCNT> (corresponding to the C function C<SvREFCNT>).
 592
 593 =head2 B::SV Methods
 594
 595 =over 4
 596
 597 =item REFCNT
 598
 599 =item FLAGS
 600
 601 =item object_2svref
 602
 603 Returns a reference to the regular scalar corresponding to this
 604 B::SV object. In other words, this method is the inverse operation
 605 to the svref_2object() subroutine. This scalar and other data it points
 606 at should be considered read-only: modifying them is neither safe nor
 607 guaranteed to have a sensible effect.
 608
 609 =back
 610
 611 =head2 B::IV Methods
 612
 613 =over 4
 614
 615 =item IV
 616
 617 Returns the value of the IV, I<interpreted as
 618 a signed integer>. This will be misleading
 619 if C<FLAGS & SVf_IVisUV>. Perhaps you want the
 620 C<int_value> method instead?
 621
 622 =item IVX
 623
 624 =item UVX
 625
 626 =item int_value
 627
 628 This method returns the value of the IV as an integer.
 629 It differs from C<IV> in that it returns the correct
 630 value regardless of whether it's stored signed or
 631 unsigned.
 632
 633 =item needs64bits
 634
 635 =item packiv
 636
 637 =back
 638
 639 =head2 B::NV Methods
 640
 641 =over 4
 642
 643 =item NV
 644
 645 =item NVX
 646
 647 =back
 648
 649 =head2 B::RV Methods
 650
 651 =over 4
 652
 653 =item RV
 654
 655 =back
 656
 657 =head2 B::PV Methods
 658
 659 =over 4
 660
 661 =item PV
 662
 663 This method is the one you usually want. It constructs a
 664 string using the length and offset information in the struct:
 665 for ordinary scalars it will return the string that you'd see
 666 from Perl, even if it contains null characters.
 667
 668 =item RV
 669
 670 Same as B::RV::RV, except that it will die() if the PV isn't
 671 a reference.
 672
 673 =item PVX
 674
 675 This method is less often useful. It assumes that the string
 676 stored in the struct is null-terminated, and disregards the
 677 length information.
 678
 679 It is the appropriate method to use if you need to get the name
 680 of a lexical variable from a padname array. Lexical variable names
 681 are always stored with a null terminator, and the length field
 682 (SvCUR) is overloaded for other purposes and can't be relied on here.
 683
 684 =back
 685
 686 =head2 B::PVMG Methods
 687
 688 =over 4
 689
 690 =item MAGIC
 691
 692 =item SvSTASH
 693
 694 =back
 695
 696 =head2 B::MAGIC Methods
 697
 698 =over 4
 699
 700 =item MOREMAGIC
 701
 702 =item precomp
 703
 704 Only valid on r-magic, returns the string that generated the regexp.
 705
 706 =item PRIVATE
 707
 708 =item TYPE
 709
 710 =item FLAGS
 711
 712 =item OBJ
 713
 714 Will die() if called on r-magic.
 715
 716 =item PTR
 717
 718 =item REGEX
 719
 720 Only valid on r-magic, returns the integer value of the REGEX stored
 721 in the MAGIC.
 722
 723 =back
 724
 725 =head2 B::PVLV Methods
 726
 727 =over 4
 728
 729 =item TARGOFF
 730
 731 =item TARGLEN
 732
 733 =item TYPE
 734
 735 =item TARG
 736
 737 =back
 738
 739 =head2 B::BM Methods
 740
 741 =over 4
 742
 743 =item USEFUL
 744
 745 =item PREVIOUS
 746
 747 =item RARE
 748
 749 =item TABLE
 750
 751 =back
 752
 753 =head2 B::GV Methods
 754
 755 =over 4
 756
 757 =item is_empty
 758
 759 This method returns TRUE if the GP field of the GV is NULL.
 760
 761 =item NAME
 762
 763 =item SAFENAME
 764
 765 This method returns the name of the glob, but if the first
 766 character of the name is a control character, then it converts
 767 it to ^X first, so that *^G would return "^G" rather than "\cG".
 768
 769 It's useful if you want to print out the name of a variable.
 770 If you restrict yourself to globs which exist at compile-time
 771 then the result ought to be unambiguous, because code like
 772 C<${"^G"} = 1> is compiled as two ops - a constant string and
 773 a dereference (rv2gv) - so that the glob is created at runtime.
 774
 775 If you're working with globs at runtime, and need to disambiguate
 776 *^G from *{"^G"}, then you should use the raw NAME method.
 777
 778 =item STASH
 779
 780 =item SV
 781
 782 =item IO
 783
 784 =item FORM
 785
 786 =item AV
 787
 788 =item HV
 789
 790 =item EGV
 791
 792 =item CV
 793
 794 =item CVGEN
 795
 796 =item LINE
 797
 798 =item FILE
 799
 800 =item FILEGV
 801
 802 =item GvREFCNT
 803
 804 =item FLAGS
 805
 806 =back
 807
 808 =head2 B::IO Methods
 809
 810 =over 4
 811
 812 =item LINES
 813
 814 =item PAGE
 815
 816 =item PAGE_LEN
 817
 818 =item LINES_LEFT
 819
 820 =item TOP_NAME
 821
 822 =item TOP_GV
 823
 824 =item FMT_NAME
 825
 826 =item FMT_GV
 827
 828 =item BOTTOM_NAME
 829
 830 =item BOTTOM_GV
 831
 832 =item SUBPROCESS
 833
 834 =item IoTYPE
 835
 836 =item IoFLAGS
 837
 838 =item IsSTD
 839
 840 Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
 841 if the IoIFP of the object is equal to the handle whose name was
 842 passed as argument ( i.e. $io->IsSTD('stderr') is true if
 843 IoIFP($io) == PerlIO_stdin() ).
 844
 845 =back
 846
 847 =head2 B::AV Methods
 848
 849 =over 4
 850
 851 =item FILL
 852
 853 =item MAX
 854
 855 =item ARRAY
 856
 857 =item ARRAYelt
 858
 859 Like C<ARRAY>, but takes an index as an argument to get only one element,
 860 rather than a list of all of them.
 861
 862 =item OFF
 863
 864 This method is deprecated if running under Perl 5.8, and is no longer present
 865 if running under Perl 5.9
 866
 867 =item AvFLAGS
 868
 869 This method returns the AV specific flags. In Perl 5.9 these are now stored
 870 in with the main SV flags, so this method is no longer present.
 871
 872 =back
 873
 874 =head2 B::CV Methods
 875
 876 =over 4
 877
 878 =item STASH
 879
 880 =item START
 881
 882 =item ROOT
 883
 884 =item GV
 885
 886 =item FILE
 887
 888 =item DEPTH
 889
 890 =item PADLIST
 891
 892 =item OUTSIDE
 893
 894 =item OUTSIDE_SEQ
 895
 896 =item XSUB
 897
 898 =item XSUBANY
 899
 900 For constant subroutines, returns the constant SV returned by the subroutine.
 901
 902 =item CvFLAGS
 903
 904 =item const_sv
 905
 906 =back
 907
 908 =head2 B::HV Methods
 909
 910 =over 4
 911
 912 =item FILL
 913
 914 =item MAX
 915
 916 =item KEYS
 917
 918 =item RITER
 919
 920 =item NAME
 921
 922 =item ARRAY
 923
 924 =item PMROOT
 925
 926 This method is not present if running under Perl 5.9, as the PMROOT
 927 information is no longer stored directly in the hash.
 928
 929 =back
 930
 931 =head2 OP-RELATED CLASSES
 932
 933 C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
 934 C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::LOOP>, C<B::COP>.
 935
 936 These classes correspond in the obvious way to the underlying C
 937 structures of similar names. The inheritance hierarchy mimics the
 938 underlying C "inheritance":
 939
 940                                  B::OP
 941                                    |
 942                    +---------------+--------+--------+-------+
 943                    |               |        |        |       |
 944                 B::UNOP          B::SVOP B::PADOP  B::COP  B::PVOP
 945                  ,'  `-.
 946                 /       `--.
 947            B::BINOP     B::LOGOP
 948                |
 949                |
 950            B::LISTOP
 951              ,' `.
 952             /     \
 953         B::LOOP B::PMOP
 954
 955 Access methods correspond to the underlying C structre field names,
 956 with the leading "class indication" prefix (C<"op_">) removed.
 957
 958 =head2 B::OP Methods
 959
 960 These methods get the values of similarly named fields within the OP
 961 data structure.  See top of C<op.h> for more info.
 962
 963 =over 4
 964
 965 =item next
 966
 967 =item sibling
 968
 969 =item name
 970
 971 This returns the op name as a string (e.g. "add", "rv2av").
 972
 973 =item ppaddr
 974
 975 This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
 976 "PL_ppaddr[OP_RV2AV]").
 977
 978 =item desc
 979
 980 This returns the op description from the global C PL_op_desc array
 981 (e.g. "addition" "array deref").
 982
 983 =item targ
 984
 985 =item type
 986
 987 =item opt
 988
 989 =item static
 990
 991 =item flags
 992
 993 =item private
 994
 995 =item spare
 996
 997 =back
 998
 999 =head2 B::UNOP METHOD
1000
1001 =over 4
1002
1003 =item first
1004
1005 =back
1006
1007 =head2 B::BINOP METHOD
1008
1009 =over 4
1010
1011 =item last
1012
1013 =back
1014
1015 =head2 B::LOGOP METHOD
1016
1017 =over 4
1018
1019 =item other
1020
1021 =back
1022
1023 =head2 B::LISTOP METHOD
1024
1025 =over 4
1026
1027 =item children
1028
1029 =back
1030
1031 =head2 B::PMOP Methods
1032
1033 =over 4
1034
1035 =item pmreplroot
1036
1037 =item pmreplstart
1038
1039 =item pmnext
1040
1041 =item pmregexp
1042
1043 =item pmflags
1044
1045 =item pmdynflags
1046
1047 =item pmpermflags
1048
1049 =item precomp
1050
1051 =item pmoffset
1052
1053 Only when perl was compiled with ithreads.
1054
1055 =back
1056
1057 =head2 B::SVOP METHOD
1058
1059 =over 4
1060
1061 =item sv
1062
1063 =item gv
1064
1065 =back
1066
1067 =head2 B::PADOP METHOD
1068
1069 =over 4
1070
1071 =item padix
1072
1073 =back
1074
1075 =head2 B::PVOP METHOD
1076
1077 =over 4
1078
1079 =item pv
1080
1081 =back
1082
1083 =head2 B::LOOP Methods
1084
1085 =over 4
1086
1087 =item redoop
1088
1089 =item nextop
1090
1091 =item lastop
1092
1093 =back
1094
1095 =head2 B::COP Methods
1096
1097 =over 4
1098
1099 =item label
1100
1101 =item stash
1102
1103 =item stashpv
1104
1105 =item file
1106
1107 =item cop_seq
1108
1109 =item arybase
1110
1111 =item line
1112
1113 =item warnings
1114
1115 =item io
1116
1117 =item hints
1118
1119 =back
1120
1121
1122 =head1 AUTHOR
1123
1124 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
1125
1126 =cut