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