This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade to Unicode::Normalize 0.23.
[perl5.git] / ext / B / B.pm
CommitLineData
a798dbf2
MB
1# B.pm
2#
1a52ab62 3# Copyright (c) 1996, 1997, 1998 Malcolm Beattie
a798dbf2
MB
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;
28b605d8 9
51a5edaf 10our $VERSION = '1.01';
28b605d8 11
9426adcd 12use XSLoader ();
a798dbf2 13require Exporter;
9426adcd 14@ISA = qw(Exporter);
b2590c4e 15
f72d64f0
DC
16# walkoptree_slow comes from B.pm (you are there),
17# walkoptree comes from B.xs
f6c2d85b
JH
18@EXPORT_OK = qw(minus_c ppname save_BEGINs
19 class peekop cast_I32 cstring cchar hash threadsv_names
b2590c4e 20 main_root main_start main_cv svref_2object opnumber
51a5edaf 21 amagic_generation perlstring
f6c2d85b
JH
22 walkoptree_slow walkoptree walkoptree_exec walksymtable
23 parents comppadlist sv_undef compile_stats timing_info
ece599bd 24 begin_av init_av check_av end_av regex_padav);
b2590c4e 25
4c1f658f 26sub OPf_KIDS ();
a798dbf2
MB
27use 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';
276493cb
SM
43@B::IO::ISA = 'B::PVMG';
44@B::FM::ISA = 'B::CV';
a798dbf2
MB
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';
a798dbf2
MB
50@B::LISTOP::ISA = 'B::BINOP';
51@B::SVOP::ISA = 'B::OP';
7934575e 52@B::PADOP::ISA = 'B::OP';
a798dbf2
MB
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
002b978b
RH
66sub B::GV::SAFENAME {
67 my $name = (shift())->NAME;
d9963e60
RH
68
69 # The regex below corresponds to the isCONTROLVAR macro
70 # from toke.c
71
7a9b44b9
RH
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
002b978b
RH
78 return $name;
79}
80
d9963e60
RH
81sub B::IV::int_value {
82 my ($self) = @_;
83 return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV);
84}
85
f3402b25
RH
86sub B::NULL::as_string() {""}
87sub B::IV::as_string() {goto &B::IV::int_value}
88sub B::PV::as_string() {goto &B::PV::PV}
89
a798dbf2
MB
90my $debug;
91my $op_count = 0;
92my @parents = ();
93
94sub debug {
95 my ($class, $value) = @_;
96 $debug = $value;
97 walkoptree_debug($value);
98}
99
a798dbf2
MB
100sub class {
101 my $obj = shift;
102 my $name = ref $obj;
103 $name =~ s/^.*:://;
104 return $name;
105}
106
107sub parents { \@parents }
108
109# For debugging
110sub peekop {
111 my $op = shift;
3f872cb9 112 return sprintf("%s (0x%x) %s", class($op), $$op, $op->name);
a798dbf2
MB
113}
114
b2590c4e 115sub walkoptree_slow {
a798dbf2
MB
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) {
b2590c4e 125 walkoptree_slow($kid, $method, $level + 1);
a798dbf2
MB
126 }
127 shift @parents;
128 }
0091380b
RGS
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 }
a798dbf2
MB
134}
135
136sub compile_stats {
137 return "Total number of OPs processed: $op_count\n";
138}
139
140sub 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
147my %symtable;
2b8dc4d2
DM
148
149sub clearsym {
150 %symtable = ();
151}
152
a798dbf2
MB
153sub 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
159sub objsym {
160 my $obj = shift;
161 return $symtable{sprintf("sym_%x", $$obj)};
162}
163
164sub walkoptree_exec {
165 my ($op, $method, $level) = @_;
244826eb 166 $level ||= 0;
a798dbf2
MB
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);
3f872cb9 177 $ppname = $op->name;
1a67a97c 178 if ($ppname =~
62e36f8a 179 /^(d?or(assign)?|and(assign)?|mapwhile|grepwhile|entertry|range|cond_expr)$/)
1a67a97c 180 {
a798dbf2
MB
181 print $prefix, uc($1), " => {\n";
182 walkoptree_exec($op->other, $method, $level + 1);
183 print $prefix, "}\n";
3f872cb9 184 } elsif ($ppname eq "match" || $ppname eq "subst") {
a798dbf2
MB
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 }
3f872cb9 191 } elsif ($ppname eq "substcont") {
a798dbf2
MB
192 print $prefix, "SUBSTCONT => {\n";
193 walkoptree_exec($op->other->pmreplstart, $method, $level + 1);
194 print $prefix, "}\n";
195 $op = $op->other;
3f872cb9 196 } elsif ($ppname eq "enterloop") {
a798dbf2
MB
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";
3f872cb9 204 } elsif ($ppname eq "subst") {
a798dbf2
MB
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
215sub walksymtable {
216 my ($symref, $method, $recurse, $prefix) = @_;
217 my $sym;
0cc1d052 218 my $ref;
b6b0fb7b
MB
219 my $fullname;
220 no strict 'refs';
0cc1d052
NIS
221 $prefix = '' unless defined $prefix;
222 while (($sym, $ref) = each %$symref) {
b6b0fb7b 223 $fullname = "*main::".$prefix.$sym;
a798dbf2
MB
224 if ($sym =~ /::$/) {
225 $sym = $prefix . $sym;
b4e94495 226 if ($sym ne "main::" && $sym ne "<none>::" && &$recurse($sym)) {
b6b0fb7b 227 walksymtable(\%$fullname, $method, $recurse, $sym);
a798dbf2
MB
228 }
229 } else {
b6b0fb7b 230 svref_2object(\*$fullname)->$method();
a798dbf2
MB
231 }
232 }
233}
234
235{
236 package B::Section;
237 my $output_fh;
238 my %sections;
85cf7f2e 239
a798dbf2
MB
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 }
85cf7f2e 247
a798dbf2
MB
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 }
85cf7f2e 275
a798dbf2
MB
276 sub default {
277 my $section = shift;
278 return $section->[3];
279 }
85cf7f2e 280
a798dbf2
MB
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
9426adcd 301XSLoader::load 'B';
a798dbf2
MB
302
3031;
7f20e9dd
GS
304
305__END__
306
307=head1 NAME
308
309B - The Perl Compiler
310
311=head1 SYNOPSIS
312
313 use B;
314
315=head1 DESCRIPTION
316
1a52ab62
MB
317The C<B> module supplies classes which allow a Perl program to delve
318into its own innards. It is the module used to implement the
319"backends" of the Perl compiler. Usage of the compiler does not
320require knowledge of this module: see the F<O> module for the
321user-visible part. The C<B> module is of use to those who want to
322write new compiler backends. This documentation assumes that the
323reader knows a fair amount about perl's internals including such
324things as SVs, OPs and the internal symbol table and syntax tree
325of a program.
326
85cf7f2e
MJD
327=head1 OVERVIEW
328
329The C<B> module contains a set of utility functions for querying the
330current state of the Perl interpreter; typically these functions
331return objects from the B::SV and B::OP classes, or their derived
332classes. These classes in turn define methods for querying the
333resulting objects about their own internal state.
334
335=head1 Utility Functions
336
337The C<B> module exports a variety of functions: some are simple
338utility functions, others provide a Perl program with a way to
339get 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
343For descriptions of the class hierachy of these objects and the
344methods that can be called on them, see below, L<"OVERVIEW OF
345CLASSES"> and L<"SV-RELATED CLASSES">.
346
347=over 4
348
349=item sv_undef
350
351Returns the SV object corresponding to the C variable C<sv_undef>.
352
353=item sv_yes
354
355Returns the SV object corresponding to the C variable C<sv_yes>.
356
357=item sv_no
358
359Returns the SV object corresponding to the C variable C<sv_no>.
360
361=item svref_2object(SVREF)
362
363Takes a reference to any Perl value, and turns the referred-to value
364into an object in the appropriate B::OP-derived or B::SV-derived
365class. Apart from functions such as C<main_root>, this is the primary
366way to get an initial "handle" on an internal perl data structure
367which can then be followed with the other access methods.
368
369=item amagic_generation
370
371Returns the SV object corresponding to the C variable C<amagic_generation>.
372
e13efe3c 373=item init_av
85cf7f2e
MJD
374
375Returns the AV object (i.e. in class B::AV) representing INIT blocks.
376
ece599bd
RGS
377=item check_av
378
379Returns the AV object (i.e. in class B::AV) representing CHECK blocks.
380
85cf7f2e
MJD
381=item begin_av
382
383Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
384
385=item end_av
386
387Returns the AV object (i.e. in class B::AV) representing END blocks.
388
389=item comppadlist
390
391Returns the AV object (i.e. in class B::AV) of the global comppadlist.
392
393=item regex_padav
394
395Only when perl was compiled with ithreads.
396
e13efe3c 397=item main_cv
85cf7f2e
MJD
398
399Return the (faked) CV corresponding to the main part of the Perl
400program.
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
410Walk the symbol table starting at SYMREF and call METHOD on each
411symbol (a B::GV object) visited. When the walk reaches package
412symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
413name, and only recurses into the package if that sub returns true.
414
415PREFIX is the name of the SYMREF you're walking.
416
417For 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
424print_subs() is a B::GV method you have declared. Also see L<"B::GV
425Methods">, below.
426
427=back
428
429=head2 Functions Returning C<B::OP> objects or for walking op trees
430
431For descriptions of the class hierachy of these objects and the
432methods that can be called on them, see below, L<"OVERVIEW OF
433CLASSES"> and L<"OP-RELATED CLASSES">.
434
435=over 4
436
437=item main_root
438
439Returns the root op (i.e. an object in the appropriate B::OP-derived
440class) of the main part of the Perl program.
441
442=item main_start
443
444Returns the starting op of the main part of the Perl program.
445
446=item walkoptree(OP, METHOD)
447
448Does a tree-walk of the syntax tree based at OP and calls METHOD on
449each op it visits. Each node is visited before its children. If
450C<walkoptree_debug> (see below) has been called to turn debugging on then
451the method C<walkoptree_debug> is called on each op before METHOD is
452called.
453
454=item walkoptree_debug(DEBUG)
455
456Returns the current debugging flag for C<walkoptree>. If the optional
457DEBUG argument is non-zero, it sets the debugging flag to that. See
458the description of C<walkoptree> above for what the debugging flag
459does.
460
461=back
462
463=head2 Miscellaneous Utility Functions
464
465=over 4
466
467=item ppname(OPNUM)
468
469Return the PP function name (e.g. "pp_add") of op number OPNUM.
470
471=item hash(STR)
472
473Returns a string in the form "0x..." representing the value of the
474internal hash function used by perl on string STR.
475
476=item cast_I32(I)
477
478Casts I to the internal I32 type used by that perl.
479
480=item minus_c
481
482Does the equivalent of the C<-c> command-line option. Obviously, this
483is only useful in a BEGIN block or else the flag is set too late.
484
485=item cstring(STR)
486
487Returns a double-quote-surrounded escaped version of STR which can
488be used as a string in C source code.
489
490=item perlstring(STR)
491
492Returns a double-quote-surrounded escaped version of STR which can
493be used as a string in Perl source code.
494
495=item class(OBJ)
496
497Returns the class of an object without the part of the classname
498preceding the first C<"::">. This is used to turn C<"B::UNOP"> into
499C<"UNOP"> for example.
500
501=item threadsv_names
502
503In a perl compiled for threads, this returns a list of the special
504per-thread threadsv variables.
505
506=back
507
508
509
510
1a52ab62
MB
511=head1 OVERVIEW OF CLASSES
512
513The C structures used by Perl's internals to hold SV and OP
514information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
515class hierarchy and the C<B> module gives access to them via a true
516object hierarchy. Structure fields which point to other objects
517(whether types of SV or types of OP) are represented by the C<B>
85cf7f2e
MJD
518module as Perl objects of the appropriate class.
519
520The bulk of the C<B> module is the methods for accessing fields of
521these structures.
522
523Note that all access is read-only. You cannot modify the internals by
1a52ab62
MB
524using this module.
525
526=head2 SV-RELATED CLASSES
527
528B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
529B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
530the obvious way to the underlying C structures of similar names. The
85cf7f2e
MJD
531inheritance 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
557Access methods correspond to the underlying C macros for field access,
1a52ab62
MB
558usually with the leading "class indication" prefix removed (Sv, Av,
559Hv, ...). The leading prefix is only left in cases where its removal
560would cause a clash in method name. For example, C<GvREFCNT> stays
561as-is since its abbreviation would clash with the "superclass" method
562C<REFCNT> (corresponding to the C function C<SvREFCNT>).
563
85cf7f2e 564=head2 B::SV Methods
1a52ab62
MB
565
566=over 4
567
568=item REFCNT
569
570=item FLAGS
571
572=back
573
85cf7f2e 574=head2 B::IV Methods
1a52ab62
MB
575
576=over 4
577
578=item IV
579
d9963e60
RH
580Returns the value of the IV, I<interpreted as
581a signed integer>. This will be misleading
582if C<FLAGS & SVf_IVisUV>. Perhaps you want the
583C<int_value> method instead?
584
1a52ab62
MB
585=item IVX
586
d9963e60
RH
587=item UVX
588
589=item int_value
590
591This method returns the value of the IV as an integer.
592It differs from C<IV> in that it returns the correct
593value regardless of whether it's stored signed or
594unsigned.
595
1a52ab62
MB
596=item needs64bits
597
598=item packiv
599
600=back
601
85cf7f2e 602=head2 B::NV Methods
1a52ab62
MB
603
604=over 4
605
606=item NV
607
608=item NVX
609
610=back
611
85cf7f2e 612=head2 B::RV Methods
1a52ab62
MB
613
614=over 4
615
616=item RV
617
618=back
619
85cf7f2e 620=head2 B::PV Methods
1a52ab62
MB
621
622=over 4
623
624=item PV
625
76ef7183
JH
626This method is the one you usually want. It constructs a
627string using the length and offset information in the struct:
628for ordinary scalars it will return the string that you'd see
629from Perl, even if it contains null characters.
630
9d2bbe64
MB
631=item RV
632
633Same as B::RV::RV, except that it will die() if the PV isn't
634a reference.
635
0b40bd6d
RH
636=item PVX
637
76ef7183
JH
638This method is less often useful. It assumes that the string
639stored in the struct is null-terminated, and disregards the
640length information.
641
642It is the appropriate method to use if you need to get the name
643of a lexical variable from a padname array. Lexical variable names
644are 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
1a52ab62
MB
647=back
648
85cf7f2e 649=head2 B::PVMG Methods
1a52ab62
MB
650
651=over 4
652
653=item MAGIC
654
655=item SvSTASH
656
657=back
658
85cf7f2e 659=head2 B::MAGIC Methods
1a52ab62
MB
660
661=over 4
662
663=item MOREMAGIC
664
9d2bbe64
MB
665=item precomp
666
667Only valid on r-magic, returns the string that generated the regexp.
668
1a52ab62
MB
669=item PRIVATE
670
671=item TYPE
672
673=item FLAGS
674
675=item OBJ
676
9d2bbe64
MB
677Will die() if called on r-magic.
678
1a52ab62
MB
679=item PTR
680
9d2bbe64
MB
681=item REGEX
682
683Only valid on r-magic, returns the integer value of the REGEX stored
684in the MAGIC.
685
1a52ab62
MB
686=back
687
85cf7f2e 688=head2 B::PVLV Methods
1a52ab62
MB
689
690=over 4
691
692=item TARGOFF
693
694=item TARGLEN
695
696=item TYPE
697
698=item TARG
699
700=back
701
85cf7f2e 702=head2 B::BM Methods
1a52ab62
MB
703
704=over 4
705
706=item USEFUL
707
708=item PREVIOUS
709
710=item RARE
711
712=item TABLE
713
714=back
715
85cf7f2e 716=head2 B::GV Methods
1a52ab62
MB
717
718=over 4
719
87d7fd28
GS
720=item is_empty
721
722This method returns TRUE if the GP field of the GV is NULL.
723
1a52ab62
MB
724=item NAME
725
002b978b
RH
726=item SAFENAME
727
728This method returns the name of the glob, but if the first
729character of the name is a control character, then it converts
730it to ^X first, so that *^G would return "^G" rather than "\cG".
731
732It's useful if you want to print out the name of a variable.
733If you restrict yourself to globs which exist at compile-time
734then the result ought to be unambiguous, because code like
735C<${"^G"} = 1> is compiled as two ops - a constant string and
736a dereference (rv2gv) - so that the glob is created at runtime.
737
738If you're working with globs at runtime, and need to disambiguate
739*^G from *{"^G"}, then you should use the raw NAME method.
740
1a52ab62
MB
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
b195d487
GS
761=item FILE
762
1a52ab62
MB
763=item FILEGV
764
765=item GvREFCNT
766
767=item FLAGS
768
769=back
770
85cf7f2e 771=head2 B::IO Methods
1a52ab62
MB
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
9d2bbe64
MB
801=item IsSTD
802
803Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
804if the IoIFP of the object is equal to the handle whose name was
805passed as argument ( i.e. $io->IsSTD('stderr') is true if
806IoIFP($io) == PerlIO_stdin() ).
807
1a52ab62
MB
808=back
809
85cf7f2e 810=head2 B::AV Methods
1a52ab62
MB
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
85cf7f2e 826=head2 B::CV Methods
1a52ab62
MB
827
828=over 4
829
830=item STASH
831
832=item START
833
834=item ROOT
835
836=item GV
837
57843af0
GS
838=item FILE
839
1a52ab62
MB
840=item DEPTH
841
842=item PADLIST
843
844=item OUTSIDE
845
a3985cdc
DM
846=item OUTSIDE_SEQ
847
1a52ab62
MB
848=item XSUB
849
850=item XSUBANY
851
9d2bbe64
MB
852For constant subroutines, returns the constant SV returned by the subroutine.
853
5cfd8ad4
VB
854=item CvFLAGS
855
de3f1649
JT
856=item const_sv
857
1a52ab62
MB
858=back
859
85cf7f2e 860=head2 B::HV Methods
1a52ab62
MB
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
85cf7f2e
MJD
882C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
883C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::CVOP>, C<B::LOOP>, C<B::COP>.
884
885These classes correspond in the obvious way to the underlying C
886structures of similar names. The inheritance hierarchy mimics the
887underlying 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
904Access methods correspond to the underlying C structre field names,
905with the leading "class indication" prefix (C<"op_">) removed.
906
907=head2 B::OP Methods
1a52ab62
MB
908
909=over 4
910
911=item next
912
913=item sibling
914
3f872cb9
GS
915=item name
916
917This returns the op name as a string (e.g. "add", "rv2av").
918
1a52ab62
MB
919=item ppaddr
920
dc333d64
GS
921This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
922"PL_ppaddr[OP_RV2AV]").
1a52ab62
MB
923
924=item desc
925
4369b173 926This returns the op description from the global C PL_op_desc array
1a52ab62
MB
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
1a52ab62
MB
965=head2 B::LISTOP METHOD
966
967=over 4
968
969=item children
970
971=back
972
85cf7f2e 973=head2 B::PMOP Methods
1a52ab62
MB
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
9d2bbe64
MB
987=item pmdynflags
988
1a52ab62
MB
989=item pmpermflags
990
991=item precomp
992
9d2bbe64
MB
993=item pmoffet
994
995Only when perl was compiled with ithreads.
996
1a52ab62
MB
997=back
998
999=head2 B::SVOP METHOD
1000
1001=over 4
1002
1003=item sv
1004
065a1863
GS
1005=item gv
1006
1a52ab62
MB
1007=back
1008
7934575e 1009=head2 B::PADOP METHOD
1a52ab62
MB
1010
1011=over 4
1012
7934575e 1013=item padix
1a52ab62
MB
1014
1015=back
1016
1017=head2 B::PVOP METHOD
1018
1019=over 4
1020
1021=item pv
1022
1023=back
1024
85cf7f2e 1025=head2 B::LOOP Methods
1a52ab62
MB
1026
1027=over 4
1028
1029=item redoop
1030
1031=item nextop
1032
1033=item lastop
1034
1035=back
1036
85cf7f2e 1037=head2 B::COP Methods
1a52ab62
MB
1038
1039=over 4
1040
1041=item label
1042
1043=item stash
1044
6e6a1aef
RGS
1045=item stashpv
1046
57843af0 1047=item file
1a52ab62
MB
1048
1049=item cop_seq
1050
1051=item arybase
1052
1053=item line
1054
6e6a1aef
RGS
1055=item warnings
1056
1057=item io
1058
1a52ab62
MB
1059=back
1060
7f20e9dd
GS
1061
1062=head1 AUTHOR
1063
1064Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
1065
1066=cut