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