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# 8package B; 9 10our $VERSION = '1.02'; 11 12use XSLoader (); 13require 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 28sub OPf_KIDS (); 29use strict; 30@B::SV::ISA = 'B::OBJECT'; 31@B::NULL::ISA = 'B::SV'; 32@B::PV::ISA = 'B::SV'; 33@B::IV::ISA = 'B::SV'; 34@B::NV::ISA = 'B::IV'; 35@B::RV::ISA = 'B::SV'; 36@B::PVIV::ISA = qw(B::PV B::IV); 37@B::PVNV::ISA = qw(B::PV B::NV); 38@B::PVMG::ISA = 'B::PVNV'; 39@B::PVLV::ISA = 'B::PVMG'; 40@B::BM::ISA = 'B::PVMG'; 41@B::AV::ISA = 'B::PVMG'; 42@B::GV::ISA = 'B::PVMG'; 43@B::HV::ISA = 'B::PVMG'; 44@B::CV::ISA = 'B::PVMG'; 45@B::IO::ISA = 'B::PVMG'; 46@B::FM::ISA = 'B::CV'; 47 48@B::OP::ISA = 'B::OBJECT'; 49@B::UNOP::ISA = 'B::OP'; 50@B::BINOP::ISA = 'B::UNOP'; 51@B::LOGOP::ISA = 'B::UNOP'; 52@B::LISTOP::ISA = 'B::BINOP'; 53@B::SVOP::ISA = 'B::OP'; 54@B::PADOP::ISA = 'B::OP'; 55@B::PVOP::ISA = 'B::OP'; 56@B::LOOP::ISA = 'B::LISTOP'; 57@B::PMOP::ISA = 'B::LISTOP'; 58@B::COP::ISA = 'B::OP'; 59 60@B::SPECIAL::ISA = 'B::OBJECT'; 61 62{ 63 # Stop "-w" from complaining about the lack of a real B::OBJECT class 64 package B::OBJECT; 65} 66 67sub 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 82sub B::IV::int_value { 83 my ($self) = @_; 84 return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV); 85} 86 87sub B::NULL::as_string() {""} 88sub B::IV::as_string() {goto &B::IV::int_value} 89sub B::PV::as_string() {goto &B::PV::PV} 90 91my $debug; 92my $op_count = 0; 93my @parents = (); 94 95sub debug { 96 my ($class, $value) = @_; 97 $debug = $value; 98 walkoptree_debug($value); 99} 100 101sub class { 102 my $obj = shift; 103 my $name = ref $obj; 104 $name =~ s/^.*:://; 105 return $name; 106} 107 108sub parents { \@parents } 109 110# For debugging 111sub peekop { 112 my $op = shift; 113 return sprintf("%s (0x%x) %s", class($op), $$op, $op->name); 114} 115 116sub 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 137sub compile_stats { 138 return "Total number of OPs processed: $op_count\n"; 139} 140 141sub 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 148my %symtable; 149 150sub clearsym { 151 %symtable = (); 152} 153 154sub 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 160sub objsym { 161 my $obj = shift; 162 return $symtable{sprintf("sym_%x", $$obj)}; 163} 164 165sub 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 /^(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 216sub 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 302XSLoader::load 'B'; 303 3041; 305 306__END__ 307 308=head1 NAME 309 310B - The Perl Compiler 311 312=head1 SYNOPSIS 313 314 use B; 315 316=head1 DESCRIPTION 317 318The C<B> module supplies classes which allow a Perl program to delve 319into its own innards. It is the module used to implement the 320"backends" of the Perl compiler. Usage of the compiler does not 321require knowledge of this module: see the F<O> module for the 322user-visible part. The C<B> module is of use to those who want to 323write new compiler backends. This documentation assumes that the 324reader knows a fair amount about perl's internals including such 325things as SVs, OPs and the internal symbol table and syntax tree 326of a program. 327 328=head1 OVERVIEW 329 330The C<B> module contains a set of utility functions for querying the 331current state of the Perl interpreter; typically these functions 332return objects from the B::SV and B::OP classes, or their derived 333classes. These classes in turn define methods for querying the 334resulting objects about their own internal state. 335 336=head1 Utility Functions 337 338The C<B> module exports a variety of functions: some are simple 339utility functions, others provide a Perl program with a way to 340get 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 344For descriptions of the class hierachy of these objects and the 345methods that can be called on them, see below, L<"OVERVIEW OF 346CLASSES"> and L<"SV-RELATED CLASSES">. 347 348=over 4 349 350=item sv_undef 351 352Returns the SV object corresponding to the C variable C<sv_undef>. 353 354=item sv_yes 355 356Returns the SV object corresponding to the C variable C<sv_yes>. 357 358=item sv_no 359 360Returns the SV object corresponding to the C variable C<sv_no>. 361 362=item svref_2object(SVREF) 363 364Takes a reference to any Perl value, and turns the referred-to value 365into an object in the appropriate B::OP-derived or B::SV-derived 366class. Apart from functions such as C<main_root>, this is the primary 367way to get an initial "handle" on an internal perl data structure 368which can then be followed with the other access methods. 369 370=item amagic_generation 371 372Returns the SV object corresponding to the C variable C<amagic_generation>. 373 374=item init_av 375 376Returns the AV object (i.e. in class B::AV) representing INIT blocks. 377 378=item check_av 379 380Returns the AV object (i.e. in class B::AV) representing CHECK blocks. 381 382=item begin_av 383 384Returns the AV object (i.e. in class B::AV) representing BEGIN blocks. 385 386=item end_av 387 388Returns the AV object (i.e. in class B::AV) representing END blocks. 389 390=item comppadlist 391 392Returns the AV object (i.e. in class B::AV) of the global comppadlist. 393 394=item regex_padav 395 396Only when perl was compiled with ithreads. 397 398=item main_cv 399 400Return the (faked) CV corresponding to the main part of the Perl 401program. 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 411Walk the symbol table starting at SYMREF and call METHOD on each 412symbol (a B::GV object) visited. When the walk reaches package 413symbols (such as "Foo::") it invokes RECURSE, passing in the symbol 414name, and only recurses into the package if that sub returns true. 415 416PREFIX is the name of the SYMREF you're walking. 417 418For 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 425print_subs() is a B::GV method you have declared. Also see L<"B::GV 426Methods">, below. 427 428=back 429 430=head2 Functions Returning C<B::OP> objects or for walking op trees 431 432For descriptions of the class hierachy of these objects and the 433methods that can be called on them, see below, L<"OVERVIEW OF 434CLASSES"> and L<"OP-RELATED CLASSES">. 435 436=over 4 437 438=item main_root 439 440Returns the root op (i.e. an object in the appropriate B::OP-derived 441class) of the main part of the Perl program. 442 443=item main_start 444 445Returns the starting op of the main part of the Perl program. 446 447=item walkoptree(OP, METHOD) 448 449Does a tree-walk of the syntax tree based at OP and calls METHOD on 450each op it visits. Each node is visited before its children. If 451C<walkoptree_debug> (see below) has been called to turn debugging on then 452the method C<walkoptree_debug> is called on each op before METHOD is 453called. 454 455=item walkoptree_debug(DEBUG) 456 457Returns the current debugging flag for C<walkoptree>. If the optional 458DEBUG argument is non-zero, it sets the debugging flag to that. See 459the description of C<walkoptree> above for what the debugging flag 460does. 461 462=back 463 464=head2 Miscellaneous Utility Functions 465 466=over 4 467 468=item ppname(OPNUM) 469 470Return the PP function name (e.g. "pp_add") of op number OPNUM. 471 472=item hash(STR) 473 474Returns a string in the form "0x..." representing the value of the 475internal hash function used by perl on string STR. 476 477=item cast_I32(I) 478 479Casts I to the internal I32 type used by that perl. 480 481=item minus_c 482 483Does the equivalent of the C<-c> command-line option. Obviously, this 484is only useful in a BEGIN block or else the flag is set too late. 485 486=item cstring(STR) 487 488Returns a double-quote-surrounded escaped version of STR which can 489be used as a string in C source code. 490 491=item perlstring(STR) 492 493Returns a double-quote-surrounded escaped version of STR which can 494be used as a string in Perl source code. 495 496=item class(OBJ) 497 498Returns the class of an object without the part of the classname 499preceding the first C<"::">. This is used to turn C<"B::UNOP"> into 500C<"UNOP"> for example. 501 502=item threadsv_names 503 504In a perl compiled for threads, this returns a list of the special 505per-thread threadsv variables. 506 507=back 508 509 510 511 512=head1 OVERVIEW OF CLASSES 513 514The C structures used by Perl's internals to hold SV and OP 515information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a 516class hierarchy and the C<B> module gives access to them via a true 517object hierarchy. Structure fields which point to other objects 518(whether types of SV or types of OP) are represented by the C<B> 519module as Perl objects of the appropriate class. 520 521The bulk of the C<B> module is the methods for accessing fields of 522these structures. 523 524Note that all access is read-only. You cannot modify the internals by 525using this module. 526 527=head2 SV-RELATED CLASSES 528 529B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV, 530B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in 531the obvious way to the underlying C structures of similar names. The 532inheritance hierarchy mimics the underlying C "inheritance": 533 534 B::SV 535 | 536 +--------------+----------------------+ 537 | | | 538 B::PV B::IV B::RV 539 | \ / \ 540 | \ / \ 541 | B::PVIV B::NV 542 \ / 543 \____ __/ 544 \ / 545 B::PVNV 546 | 547 | 548 B::PVMG 549 | 550 +------+-----+----+------+-----+-----+ 551 | | | | | | | 552 B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO 553 | 554 | 555 B::FM 556 557 558Access methods correspond to the underlying C macros for field access, 559usually with the leading "class indication" prefix removed (Sv, Av, 560Hv, ...). The leading prefix is only left in cases where its removal 561would cause a clash in method name. For example, C<GvREFCNT> stays 562as-is since its abbreviation would clash with the "superclass" method 563C<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 575Returns a reference to the regular scalar corresponding to this 576B::SV object. In other words, this method is the inverse operation 577to the svref_2object() subroutine. This scalar and other data it points 578at should be considered read-only: modifying them is neither safe nor 579guaranteed to have a sensible effect. 580 581=back 582 583=head2 B::IV Methods 584 585=over 4 586 587=item IV 588 589Returns the value of the IV, I<interpreted as 590a signed integer>. This will be misleading 591if C<FLAGS & SVf_IVisUV>. Perhaps you want the 592C<int_value> method instead? 593 594=item IVX 595 596=item UVX 597 598=item int_value 599 600This method returns the value of the IV as an integer. 601It differs from C<IV> in that it returns the correct 602value regardless of whether it's stored signed or 603unsigned. 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 635This method is the one you usually want. It constructs a 636string using the length and offset information in the struct: 637for ordinary scalars it will return the string that you'd see 638from Perl, even if it contains null characters. 639 640=item RV 641 642Same as B::RV::RV, except that it will die() if the PV isn't 643a reference. 644 645=item PVX 646 647This method is less often useful. It assumes that the string 648stored in the struct is null-terminated, and disregards the 649length information. 650 651It is the appropriate method to use if you need to get the name 652of a lexical variable from a padname array. Lexical variable names 653are 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 676Only 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 686Will die() if called on r-magic. 687 688=item PTR 689 690=item REGEX 691 692Only valid on r-magic, returns the integer value of the REGEX stored 693in 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 731This method returns TRUE if the GP field of the GV is NULL. 732 733=item NAME 734 735=item SAFENAME 736 737This method returns the name of the glob, but if the first 738character of the name is a control character, then it converts 739it to ^X first, so that *^G would return "^G" rather than "\cG". 740 741It's useful if you want to print out the name of a variable. 742If you restrict yourself to globs which exist at compile-time 743then the result ought to be unambiguous, because code like 744C<${"^G"} = 1> is compiled as two ops - a constant string and 745a dereference (rv2gv) - so that the glob is created at runtime. 746 747If 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 812Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true 813if the IoIFP of the object is equal to the handle whose name was 814passed as argument ( i.e. $io->IsSTD('stderr') is true if 815IoIFP($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 833Like C<ARRAY>, but takes an index as an argument to get only one element, 834rather 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 866For 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 896C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>, 897C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::LOOP>, C<B::COP>. 898 899These classes correspond in the obvious way to the underlying C 900structures of similar names. The inheritance hierarchy mimics the 901underlying 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 918Access methods correspond to the underlying C structre field names, 919with the leading "class indication" prefix (C<"op_">) removed. 920 921=head2 B::OP Methods 922 923=over 4 924 925=item next 926 927=item sibling 928 929=item name 930 931This returns the op name as a string (e.g. "add", "rv2av"). 932 933=item ppaddr 934 935This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]", 936"PL_ppaddr[OP_RV2AV]"). 937 938=item desc 939 940This returns the op description from the global C PL_op_desc array 941(e.g. "addition" "array deref"). 942 943=item targ 944 945=item type 946 947=item seq 948 949=item flags 950 951=item private 952 953=back 954 955=head2 B::UNOP METHOD 956 957=over 4 958 959=item first 960 961=back 962 963=head2 B::BINOP METHOD 964 965=over 4 966 967=item last 968 969=back 970 971=head2 B::LOGOP METHOD 972 973=over 4 974 975=item other 976 977=back 978 979=head2 B::LISTOP METHOD 980 981=over 4 982 983=item children 984 985=back 986 987=head2 B::PMOP Methods 988 989=over 4 990 991=item pmreplroot 992 993=item pmreplstart 994 995=item pmnext 996 997=item pmregexp 998 999=item pmflags 1000 1001=item pmdynflags 1002 1003=item pmpermflags 1004 1005=item precomp 1006 1007=item pmoffset 1008 1009Only when perl was compiled with ithreads. 1010 1011=back 1012 1013=head2 B::SVOP METHOD 1014 1015=over 4 1016 1017=item sv 1018 1019=item gv 1020 1021=back 1022 1023=head2 B::PADOP METHOD 1024 1025=over 4 1026 1027=item padix 1028 1029=back 1030 1031=head2 B::PVOP METHOD 1032 1033=over 4 1034 1035=item pv 1036 1037=back 1038 1039=head2 B::LOOP Methods 1040 1041=over 4 1042 1043=item redoop 1044 1045=item nextop 1046 1047=item lastop 1048 1049=back 1050 1051=head2 B::COP Methods 1052 1053=over 4 1054 1055=item label 1056 1057=item stash 1058 1059=item stashpv 1060 1061=item file 1062 1063=item cop_seq 1064 1065=item arybase 1066 1067=item line 1068 1069=item warnings 1070 1071=item io 1072 1073=back 1074 1075 1076=head1 AUTHOR 1077 1078Malcolm Beattie, C<mbeattie@sable.ox.ac.uk> 1079 1080=cut 1081