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