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