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