This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Re: POSIX::sigprocmask implemented incorrectly
[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
7fd0c236 10our $VERSION = '1.05';
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';
4ce457a6 39@B::PVLV::ISA = 'B::GV';
a798dbf2
MB
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 |
4ce457a6
TP
550 +-----+----+------+-----+-----+
551 | | | | | |
552 B::BM B::AV B::GV B::HV B::CV B::IO
553 | |
554 B::PVLV |
85cf7f2e
MJD
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
429a5ce7
SM
573=item object_2svref
574
575Returns a reference to the regular scalar corresponding to this
576B::SV object. In other words, this method is the inverse operation
577to the svref_2object() subroutine. This scalar and other data it points
578at should be considered read-only: modifying them is neither safe nor
579guaranteed to have a sensible effect.
580
1a52ab62
MB
581=back
582
85cf7f2e 583=head2 B::IV Methods
1a52ab62
MB
584
585=over 4
586
587=item IV
588
d9963e60
RH
589Returns the value of the IV, I<interpreted as
590a signed integer>. This will be misleading
591if C<FLAGS & SVf_IVisUV>. Perhaps you want the
592C<int_value> method instead?
593
1a52ab62
MB
594=item IVX
595
d9963e60
RH
596=item UVX
597
598=item int_value
599
600This method returns the value of the IV as an integer.
601It differs from C<IV> in that it returns the correct
602value regardless of whether it's stored signed or
603unsigned.
604
1a52ab62
MB
605=item needs64bits
606
607=item packiv
608
609=back
610
85cf7f2e 611=head2 B::NV Methods
1a52ab62
MB
612
613=over 4
614
615=item NV
616
617=item NVX
618
619=back
620
85cf7f2e 621=head2 B::RV Methods
1a52ab62
MB
622
623=over 4
624
625=item RV
626
627=back
628
85cf7f2e 629=head2 B::PV Methods
1a52ab62
MB
630
631=over 4
632
633=item PV
634
76ef7183
JH
635This method is the one you usually want. It constructs a
636string using the length and offset information in the struct:
637for ordinary scalars it will return the string that you'd see
638from Perl, even if it contains null characters.
639
9d2bbe64
MB
640=item RV
641
642Same as B::RV::RV, except that it will die() if the PV isn't
643a reference.
644
0b40bd6d
RH
645=item PVX
646
76ef7183
JH
647This method is less often useful. It assumes that the string
648stored in the struct is null-terminated, and disregards the
649length information.
650
651It is the appropriate method to use if you need to get the name
652of a lexical variable from a padname array. Lexical variable names
653are 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
1a52ab62
MB
656=back
657
85cf7f2e 658=head2 B::PVMG Methods
1a52ab62
MB
659
660=over 4
661
662=item MAGIC
663
664=item SvSTASH
665
666=back
667
85cf7f2e 668=head2 B::MAGIC Methods
1a52ab62
MB
669
670=over 4
671
672=item MOREMAGIC
673
9d2bbe64
MB
674=item precomp
675
676Only valid on r-magic, returns the string that generated the regexp.
677
1a52ab62
MB
678=item PRIVATE
679
680=item TYPE
681
682=item FLAGS
683
684=item OBJ
685
9d2bbe64
MB
686Will die() if called on r-magic.
687
1a52ab62
MB
688=item PTR
689
9d2bbe64
MB
690=item REGEX
691
692Only valid on r-magic, returns the integer value of the REGEX stored
693in the MAGIC.
694
1a52ab62
MB
695=back
696
85cf7f2e 697=head2 B::PVLV Methods
1a52ab62
MB
698
699=over 4
700
701=item TARGOFF
702
703=item TARGLEN
704
705=item TYPE
706
707=item TARG
708
709=back
710
85cf7f2e 711=head2 B::BM Methods
1a52ab62
MB
712
713=over 4
714
715=item USEFUL
716
717=item PREVIOUS
718
719=item RARE
720
721=item TABLE
722
723=back
724
85cf7f2e 725=head2 B::GV Methods
1a52ab62
MB
726
727=over 4
728
87d7fd28
GS
729=item is_empty
730
731This method returns TRUE if the GP field of the GV is NULL.
732
1a52ab62
MB
733=item NAME
734
002b978b
RH
735=item SAFENAME
736
737This method returns the name of the glob, but if the first
738character of the name is a control character, then it converts
739it to ^X first, so that *^G would return "^G" rather than "\cG".
740
741It's useful if you want to print out the name of a variable.
742If you restrict yourself to globs which exist at compile-time
743then the result ought to be unambiguous, because code like
744C<${"^G"} = 1> is compiled as two ops - a constant string and
745a dereference (rv2gv) - so that the glob is created at runtime.
746
747If you're working with globs at runtime, and need to disambiguate
748*^G from *{"^G"}, then you should use the raw NAME method.
749
1a52ab62
MB
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
b195d487
GS
770=item FILE
771
1a52ab62
MB
772=item FILEGV
773
774=item GvREFCNT
775
776=item FLAGS
777
778=back
779
85cf7f2e 780=head2 B::IO Methods
1a52ab62
MB
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
9d2bbe64
MB
810=item IsSTD
811
812Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
813if the IoIFP of the object is equal to the handle whose name was
814passed as argument ( i.e. $io->IsSTD('stderr') is true if
815IoIFP($io) == PerlIO_stdin() ).
816
1a52ab62
MB
817=back
818
85cf7f2e 819=head2 B::AV Methods
1a52ab62
MB
820
821=over 4
822
823=item FILL
824
825=item MAX
826
827=item OFF
828
829=item ARRAY
830
429a5ce7
SM
831=item ARRAYelt
832
833Like C<ARRAY>, but takes an index as an argument to get only one element,
834rather than a list of all of them.
835
1a52ab62
MB
836=item AvFLAGS
837
838=back
839
85cf7f2e 840=head2 B::CV Methods
1a52ab62
MB
841
842=over 4
843
844=item STASH
845
846=item START
847
848=item ROOT
849
850=item GV
851
57843af0
GS
852=item FILE
853
1a52ab62
MB
854=item DEPTH
855
856=item PADLIST
857
858=item OUTSIDE
859
a3985cdc
DM
860=item OUTSIDE_SEQ
861
1a52ab62
MB
862=item XSUB
863
864=item XSUBANY
865
9d2bbe64
MB
866For constant subroutines, returns the constant SV returned by the subroutine.
867
5cfd8ad4
VB
868=item CvFLAGS
869
de3f1649
JT
870=item const_sv
871
1a52ab62
MB
872=back
873
85cf7f2e 874=head2 B::HV Methods
1a52ab62
MB
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
85cf7f2e 896C<B::OP>, C<B::UNOP>, C<B::BINOP>, C<B::LOGOP>, C<B::LISTOP>, C<B::PMOP>,
651aa52e 897C<B::SVOP>, C<B::PADOP>, C<B::PVOP>, C<B::LOOP>, C<B::COP>.
85cf7f2e
MJD
898
899These classes correspond in the obvious way to the underlying C
900structures of similar names. The inheritance hierarchy mimics the
901underlying C "inheritance":
902
903 B::OP
904 |
651aa52e
AE
905 +---------------+--------+--------+
906 | | | |
907 B::UNOP B::SVOP B::PADOP B::COP
85cf7f2e
MJD
908 ,' `-.
909 / `--.
910 B::BINOP B::LOGOP
911 |
912 |
913 B::LISTOP
914 ,' `.
915 / \
916 B::LOOP B::PMOP
917
918Access methods correspond to the underlying C structre field names,
919with the leading "class indication" prefix (C<"op_">) removed.
920
921=head2 B::OP Methods
1a52ab62
MB
922
923=over 4
924
925=item next
926
927=item sibling
928
3f872cb9
GS
929=item name
930
931This returns the op name as a string (e.g. "add", "rv2av").
932
1a52ab62
MB
933=item ppaddr
934
dc333d64
GS
935This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
936"PL_ppaddr[OP_RV2AV]").
1a52ab62
MB
937
938=item desc
939
4369b173 940This returns the op description from the global C PL_op_desc array
1a52ab62
MB
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
1a52ab62
MB
979=head2 B::LISTOP METHOD
980
981=over 4
982
983=item children
984
985=back
986
85cf7f2e 987=head2 B::PMOP Methods
1a52ab62
MB
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
9d2bbe64
MB
1001=item pmdynflags
1002
1a52ab62
MB
1003=item pmpermflags
1004
1005=item precomp
1006
651aa52e 1007=item pmoffset
9d2bbe64
MB
1008
1009Only when perl was compiled with ithreads.
1010
1a52ab62
MB
1011=back
1012
1013=head2 B::SVOP METHOD
1014
1015=over 4
1016
1017=item sv
1018
065a1863
GS
1019=item gv
1020
1a52ab62
MB
1021=back
1022
7934575e 1023=head2 B::PADOP METHOD
1a52ab62
MB
1024
1025=over 4
1026
7934575e 1027=item padix
1a52ab62
MB
1028
1029=back
1030
1031=head2 B::PVOP METHOD
1032
1033=over 4
1034
1035=item pv
1036
1037=back
1038
85cf7f2e 1039=head2 B::LOOP Methods
1a52ab62
MB
1040
1041=over 4
1042
1043=item redoop
1044
1045=item nextop
1046
1047=item lastop
1048
1049=back
1050
85cf7f2e 1051=head2 B::COP Methods
1a52ab62
MB
1052
1053=over 4
1054
1055=item label
1056
1057=item stash
1058
6e6a1aef
RGS
1059=item stashpv
1060
57843af0 1061=item file
1a52ab62
MB
1062
1063=item cop_seq
1064
1065=item arybase
1066
1067=item line
1068
6e6a1aef
RGS
1069=item warnings
1070
1071=item io
1072
1a52ab62
MB
1073=back
1074
7f20e9dd
GS
1075
1076=head1 AUTHOR
1077
1078Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
1079
1080=cut