This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
1d31369869cc3274d9268dd562d9a582dc76409c
[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.04';
11
12 use XSLoader ();
13 require Exporter;
14 @ISA = qw(Exporter);
15
16 # walkoptree_slow comes from B.pm (you are there),
17 # walkoptree comes from B.xs
18 @EXPORT_OK = qw(minus_c ppname save_BEGINs
19                 class peekop cast_I32 cstring cchar hash threadsv_names
20                 main_root main_start main_cv svref_2object opnumber
21                 amagic_generation perlstring
22                 walkoptree_slow walkoptree walkoptree_exec walksymtable
23                 parents comppadlist sv_undef compile_stats timing_info
24                 begin_av init_av check_av end_av regex_padav dowarn
25                 defstash curstash warnhook diehook inc_gv
26                 );
27
28 sub OPf_KIDS ();
29 use strict;
30 @B::SV::ISA = 'B::OBJECT';
31 @B::NULL::ISA = 'B::SV';
32 @B::PV::ISA = 'B::SV';
33 @B::IV::ISA = 'B::SV';
34 @B::NV::ISA = 'B::IV';
35 @B::RV::ISA = 'B::SV';
36 @B::PVIV::ISA = qw(B::PV B::IV);
37 @B::PVNV::ISA = qw(B::PV B::NV);
38 @B::PVMG::ISA = 'B::PVNV';
39 @B::PVLV::ISA = 'B::GV';
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
67 sub 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
82 sub B::IV::int_value {
83   my ($self) = @_;
84   return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV);
85 }
86
87 sub B::NULL::as_string() {""}
88 sub B::IV::as_string()   {goto &B::IV::int_value}
89 sub B::PV::as_string()   {goto &B::PV::PV}
90
91 my $debug;
92 my $op_count = 0;
93 my @parents = ();
94
95 sub debug {
96     my ($class, $value) = @_;
97     $debug = $value;
98     walkoptree_debug($value);
99 }
100
101 sub class {
102     my $obj = shift;
103     my $name = ref $obj;
104     $name =~ s/^.*:://;
105     return $name;
106 }
107
108 sub parents { \@parents }
109
110 # For debugging
111 sub peekop {
112     my $op = shift;
113     return sprintf("%s (0x%x) %s", class($op), $$op, $op->name);
114 }
115
116 sub 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
137 sub compile_stats {
138     return "Total number of OPs processed: $op_count\n";
139 }
140
141 sub 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
148 my %symtable;
149
150 sub clearsym {
151     %symtable = ();
152 }
153
154 sub 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
160 sub objsym {
161     my $obj = shift;
162     return $symtable{sprintf("sym_%x", $$obj)};
163 }
164
165 sub 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             /^(d?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
216 sub 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
302 XSLoader::load 'B';
303
304 1;
305
306 __END__
307
308 =head1 NAME
309
310 B - The Perl Compiler
311
312 =head1 SYNOPSIS
313
314         use B;
315
316 =head1 DESCRIPTION
317
318 The C<B> module supplies classes which allow a Perl program to delve
319 into its own innards. It is the module used to implement the
320 "backends" of the Perl compiler. Usage of the compiler does not
321 require knowledge of this module: see the F<O> module for the
322 user-visible part. The C<B> module is of use to those who want to
323 write new compiler backends. This documentation assumes that the
324 reader knows a fair amount about perl's internals including such
325 things as SVs, OPs and the internal symbol table and syntax tree
326 of a program.
327
328 =head1 OVERVIEW
329
330 The C<B> module contains a set of utility functions for querying the
331 current state of the Perl interpreter; typically these functions
332 return objects from the B::SV and B::OP classes, or their derived
333 classes.  These classes in turn define methods for querying the
334 resulting objects about their own internal state.
335
336 =head1 Utility Functions
337
338 The C<B> module exports a variety of functions: some are simple
339 utility functions, others provide a Perl program with a way to
340 get 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
344 For descriptions of the class hierachy of these objects and the
345 methods that can be called on them, see below, L<"OVERVIEW OF
346 CLASSES"> and L<"SV-RELATED CLASSES">.
347
348 =over 4
349
350 =item sv_undef
351
352 Returns the SV object corresponding to the C variable C<sv_undef>.
353
354 =item sv_yes
355
356 Returns the SV object corresponding to the C variable C<sv_yes>.
357
358 =item sv_no
359
360 Returns the SV object corresponding to the C variable C<sv_no>.
361
362 =item svref_2object(SVREF)
363
364 Takes a reference to any Perl value, and turns the referred-to value
365 into an object in the appropriate B::OP-derived or B::SV-derived
366 class. Apart from functions such as C<main_root>, this is the primary
367 way to get an initial "handle" on an internal perl data structure
368 which can then be followed with the other access methods.
369
370 =item amagic_generation
371
372 Returns the SV object corresponding to the C variable C<amagic_generation>.
373
374 =item init_av
375
376 Returns the AV object (i.e. in class B::AV) representing INIT blocks.
377
378 =item check_av
379
380 Returns the AV object (i.e. in class B::AV) representing CHECK blocks.
381
382 =item begin_av
383
384 Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
385
386 =item end_av
387
388 Returns the AV object (i.e. in class B::AV) representing END blocks.
389
390 =item comppadlist
391
392 Returns the AV object (i.e. in class B::AV) of the global comppadlist.
393
394 =item regex_padav
395
396 Only when perl was compiled with ithreads.
397
398 =item main_cv
399
400 Return the (faked) CV corresponding to the main part of the Perl
401 program.
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
411 Walk the symbol table starting at SYMREF and call METHOD on each
412 symbol (a B::GV object) visited.  When the walk reaches package
413 symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
414 name, and only recurses into the package if that sub returns true.
415
416 PREFIX is the name of the SYMREF you're walking.
417
418 For 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
425 print_subs() is a B::GV method you have declared. Also see L<"B::GV
426 Methods">, below.
427
428 =back
429
430 =head2 Functions Returning C<B::OP> objects or for walking op trees
431
432 For descriptions of the class hierachy of these objects and the
433 methods that can be called on them, see below, L<"OVERVIEW OF
434 CLASSES"> and L<"OP-RELATED CLASSES">.
435
436 =over 4
437
438 =item main_root
439
440 Returns the root op (i.e. an object in the appropriate B::OP-derived
441 class) of the main part of the Perl program.
442
443 =item main_start
444
445 Returns the starting op of the main part of the Perl program.
446
447 =item walkoptree(OP, METHOD)
448
449 Does a tree-walk of the syntax tree based at OP and calls METHOD on
450 each op it visits. Each node is visited before its children. If
451 C<walkoptree_debug> (see below) has been called to turn debugging on then
452 the method C<walkoptree_debug> is called on each op before METHOD is
453 called.
454
455 =item walkoptree_debug(DEBUG)
456
457 Returns the current debugging flag for C<walkoptree>. If the optional
458 DEBUG argument is non-zero, it sets the debugging flag to that. See
459 the description of C<walkoptree> above for what the debugging flag
460 does.
461
462 =back
463
464 =head2 Miscellaneous Utility Functions
465
466 =over 4
467
468 =item ppname(OPNUM)
469
470 Return the PP function name (e.g. "pp_add") of op number OPNUM.
471
472 =item hash(STR)
473
474 Returns a string in the form "0x..." representing the value of the
475 internal hash function used by perl on string STR.
476
477 =item cast_I32(I)
478
479 Casts I to the internal I32 type used by that perl.
480
481 =item minus_c
482
483 Does the equivalent of the C<-c> command-line option. Obviously, this
484 is only useful in a BEGIN block or else the flag is set too late.
485
486 =item cstring(STR)
487
488 Returns a double-quote-surrounded escaped version of STR which can
489 be used as a string in C source code.
490
491 =item perlstring(STR)
492
493 Returns a double-quote-surrounded escaped version of STR which can
494 be used as a string in Perl source code.
495
496 =item class(OBJ)
497
498 Returns the class of an object without the part of the classname
499 preceding the first C<"::">. This is used to turn C<"B::UNOP"> into
500 C<"UNOP"> for example.
501
502 =item threadsv_names
503
504 In a perl compiled for threads, this returns a list of the special
505 per-thread threadsv variables.
506
507 =back
508
509
510
511
512 =head1 OVERVIEW OF CLASSES
513
514 The C structures used by Perl's internals to hold SV and OP
515 information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
516 class hierarchy and the C<B> module gives access to them via a true
517 object hierarchy. Structure fields which point to other objects
518 (whether types of SV or types of OP) are represented by the C<B>
519 module as Perl objects of the appropriate class.
520
521 The bulk of the C<B> module is the methods for accessing fields of
522 these structures.
523
524 Note that all access is read-only.  You cannot modify the internals by
525 using this module.
526
527 =head2 SV-RELATED CLASSES
528
529 B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
530 B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
531 the obvious way to the underlying C structures of similar names. The
532 inheritance 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::BM B::AV B::GV B::HV B::CV B::IO
553                            |            |
554                         B::PVLV         |
555                                       B::FM
556
557
558 Access methods correspond to the underlying C macros for field access,
559 usually with the leading "class indication" prefix removed (Sv, Av,
560 Hv, ...). The leading prefix is only left in cases where its removal
561 would cause a clash in method name. For example, C<GvREFCNT> stays
562 as-is since its abbreviation would clash with the "superclass" method
563 C<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
575 Returns a reference to the regular scalar corresponding to this
576 B::SV object. In other words, this method is the inverse operation
577 to the svref_2object() subroutine. This scalar and other data it points
578 at should be considered read-only: modifying them is neither safe nor
579 guaranteed to have a sensible effect.
580
581 =back
582
583 =head2 B::IV Methods
584
585 =over 4
586
587 =item IV
588
589 Returns the value of the IV, I<interpreted as
590 a signed integer>. This will be misleading
591 if C<FLAGS & SVf_IVisUV>. Perhaps you want the
592 C<int_value> method instead?
593
594 =item IVX
595
596 =item UVX
597
598 =item int_value
599
600 This method returns the value of the IV as an integer.
601 It differs from C<IV> in that it returns the correct
602 value regardless of whether it's stored signed or
603 unsigned.
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
635 This method is the one you usually want. It constructs a
636 string using the length and offset information in the struct:
637 for ordinary scalars it will return the string that you'd see
638 from Perl, even if it contains null characters.
639
640 =item RV
641
642 Same as B::RV::RV, except that it will die() if the PV isn't
643 a reference.
644
645 =item PVX
646
647 This method is less often useful. It assumes that the string
648 stored in the struct is null-terminated, and disregards the
649 length information.
650
651 It is the appropriate method to use if you need to get the name
652 of a lexical variable from a padname array. Lexical variable names
653 are 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
676 Only 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
686 Will die() if called on r-magic.
687
688 =item PTR
689
690 =item REGEX
691
692 Only valid on r-magic, returns the integer value of the REGEX stored
693 in 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
731 This method returns TRUE if the GP field of the GV is NULL.
732
733 =item NAME
734
735 =item SAFENAME
736
737 This method returns the name of the glob, but if the first
738 character of the name is a control character, then it converts
739 it to ^X first, so that *^G would return "^G" rather than "\cG".
740
741 It's useful if you want to print out the name of a variable.
742 If you restrict yourself to globs which exist at compile-time
743 then the result ought to be unambiguous, because code like
744 C<${"^G"} = 1> is compiled as two ops - a constant string and
745 a dereference (rv2gv) - so that the glob is created at runtime.
746
747 If 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
812 Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
813 if the IoIFP of the object is equal to the handle whose name was
814 passed as argument ( i.e. $io->IsSTD('stderr') is true if
815 IoIFP($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
833 Like C<ARRAY>, but takes an index as an argument to get only one element,
834 rather 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
866 For 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
896 C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
897 C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::LOOP>, C<B::COP>.
898
899 These classes correspond in the obvious way to the underlying C
900 structures of similar names. The inheritance hierarchy mimics the
901 underlying 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
918 Access methods correspond to the underlying C structre field names,
919 with 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
931 This returns the op name as a string (e.g. "add", "rv2av").
932
933 =item ppaddr
934
935 This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
936 "PL_ppaddr[OP_RV2AV]").
937
938 =item desc
939
940 This 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
1009 Only 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
1078 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
1079
1080 =cut