This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Missing MANIFEST files for #17783.
[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
9d2bbe64 24 begin_av init_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 =~
3f872cb9 179 /^(or|and|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;
239
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 }
247
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 }
275
276 sub default {
277 my $section = shift;
278 return $section->[3];
279 }
280
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
327=head1 OVERVIEW OF CLASSES
328
329The C structures used by Perl's internals to hold SV and OP
330information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
331class hierarchy and the C<B> module gives access to them via a true
332object hierarchy. Structure fields which point to other objects
333(whether types of SV or types of OP) are represented by the C<B>
334module as Perl objects of the appropriate class. The bulk of the C<B>
335module is the methods for accessing fields of these structures. Note
336that all access is read-only: you cannot modify the internals by
337using this module.
338
339=head2 SV-RELATED CLASSES
340
341B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
342B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
343the obvious way to the underlying C structures of similar names. The
344inheritance hierarchy mimics the underlying C "inheritance". Access
345methods correspond to the underlying C macros for field access,
346usually with the leading "class indication" prefix removed (Sv, Av,
347Hv, ...). The leading prefix is only left in cases where its removal
348would cause a clash in method name. For example, C<GvREFCNT> stays
349as-is since its abbreviation would clash with the "superclass" method
350C<REFCNT> (corresponding to the C function C<SvREFCNT>).
351
352=head2 B::SV METHODS
353
354=over 4
355
356=item REFCNT
357
358=item FLAGS
359
360=back
361
362=head2 B::IV METHODS
363
364=over 4
365
366=item IV
367
d9963e60
RH
368Returns the value of the IV, I<interpreted as
369a signed integer>. This will be misleading
370if C<FLAGS & SVf_IVisUV>. Perhaps you want the
371C<int_value> method instead?
372
1a52ab62
MB
373=item IVX
374
d9963e60
RH
375=item UVX
376
377=item int_value
378
379This method returns the value of the IV as an integer.
380It differs from C<IV> in that it returns the correct
381value regardless of whether it's stored signed or
382unsigned.
383
1a52ab62
MB
384=item needs64bits
385
386=item packiv
387
388=back
389
390=head2 B::NV METHODS
391
392=over 4
393
394=item NV
395
396=item NVX
397
398=back
399
400=head2 B::RV METHODS
401
402=over 4
403
404=item RV
405
406=back
407
408=head2 B::PV METHODS
409
410=over 4
411
412=item PV
413
76ef7183
JH
414This method is the one you usually want. It constructs a
415string using the length and offset information in the struct:
416for ordinary scalars it will return the string that you'd see
417from Perl, even if it contains null characters.
418
9d2bbe64
MB
419=item RV
420
421Same as B::RV::RV, except that it will die() if the PV isn't
422a reference.
423
0b40bd6d
RH
424=item PVX
425
76ef7183
JH
426This method is less often useful. It assumes that the string
427stored in the struct is null-terminated, and disregards the
428length information.
429
430It is the appropriate method to use if you need to get the name
431of a lexical variable from a padname array. Lexical variable names
432are always stored with a null terminator, and the length field
433(SvCUR) is overloaded for other purposes and can't be relied on here.
434
1a52ab62
MB
435=back
436
437=head2 B::PVMG METHODS
438
439=over 4
440
441=item MAGIC
442
443=item SvSTASH
444
445=back
446
447=head2 B::MAGIC METHODS
448
449=over 4
450
451=item MOREMAGIC
452
9d2bbe64
MB
453=item precomp
454
455Only valid on r-magic, returns the string that generated the regexp.
456
1a52ab62
MB
457=item PRIVATE
458
459=item TYPE
460
461=item FLAGS
462
463=item OBJ
464
9d2bbe64
MB
465Will die() if called on r-magic.
466
1a52ab62
MB
467=item PTR
468
9d2bbe64
MB
469=item REGEX
470
471Only valid on r-magic, returns the integer value of the REGEX stored
472in the MAGIC.
473
1a52ab62
MB
474=back
475
476=head2 B::PVLV METHODS
477
478=over 4
479
480=item TARGOFF
481
482=item TARGLEN
483
484=item TYPE
485
486=item TARG
487
488=back
489
490=head2 B::BM METHODS
491
492=over 4
493
494=item USEFUL
495
496=item PREVIOUS
497
498=item RARE
499
500=item TABLE
501
502=back
503
504=head2 B::GV METHODS
505
506=over 4
507
87d7fd28
GS
508=item is_empty
509
510This method returns TRUE if the GP field of the GV is NULL.
511
1a52ab62
MB
512=item NAME
513
002b978b
RH
514=item SAFENAME
515
516This method returns the name of the glob, but if the first
517character of the name is a control character, then it converts
518it to ^X first, so that *^G would return "^G" rather than "\cG".
519
520It's useful if you want to print out the name of a variable.
521If you restrict yourself to globs which exist at compile-time
522then the result ought to be unambiguous, because code like
523C<${"^G"} = 1> is compiled as two ops - a constant string and
524a dereference (rv2gv) - so that the glob is created at runtime.
525
526If you're working with globs at runtime, and need to disambiguate
527*^G from *{"^G"}, then you should use the raw NAME method.
528
1a52ab62
MB
529=item STASH
530
531=item SV
532
533=item IO
534
535=item FORM
536
537=item AV
538
539=item HV
540
541=item EGV
542
543=item CV
544
545=item CVGEN
546
547=item LINE
548
b195d487
GS
549=item FILE
550
1a52ab62
MB
551=item FILEGV
552
553=item GvREFCNT
554
555=item FLAGS
556
557=back
558
559=head2 B::IO METHODS
560
561=over 4
562
563=item LINES
564
565=item PAGE
566
567=item PAGE_LEN
568
569=item LINES_LEFT
570
571=item TOP_NAME
572
573=item TOP_GV
574
575=item FMT_NAME
576
577=item FMT_GV
578
579=item BOTTOM_NAME
580
581=item BOTTOM_GV
582
583=item SUBPROCESS
584
585=item IoTYPE
586
587=item IoFLAGS
588
9d2bbe64
MB
589=item IsSTD
590
591Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
592if the IoIFP of the object is equal to the handle whose name was
593passed as argument ( i.e. $io->IsSTD('stderr') is true if
594IoIFP($io) == PerlIO_stdin() ).
595
1a52ab62
MB
596=back
597
598=head2 B::AV METHODS
599
600=over 4
601
602=item FILL
603
604=item MAX
605
606=item OFF
607
608=item ARRAY
609
610=item AvFLAGS
611
612=back
613
614=head2 B::CV METHODS
615
616=over 4
617
618=item STASH
619
620=item START
621
622=item ROOT
623
624=item GV
625
57843af0
GS
626=item FILE
627
1a52ab62
MB
628=item DEPTH
629
630=item PADLIST
631
632=item OUTSIDE
633
634=item XSUB
635
636=item XSUBANY
637
9d2bbe64
MB
638For constant subroutines, returns the constant SV returned by the subroutine.
639
5cfd8ad4
VB
640=item CvFLAGS
641
de3f1649
JT
642=item const_sv
643
1a52ab62
MB
644=back
645
646=head2 B::HV METHODS
647
648=over 4
649
650=item FILL
651
652=item MAX
653
654=item KEYS
655
656=item RITER
657
658=item NAME
659
660=item PMROOT
661
662=item ARRAY
663
664=back
665
666=head2 OP-RELATED CLASSES
667
1a67a97c 668B::OP, B::UNOP, B::BINOP, B::LOGOP, B::LISTOP, B::PMOP,
7934575e 669B::SVOP, B::PADOP, B::PVOP, B::CVOP, B::LOOP, B::COP.
1a52ab62
MB
670These classes correspond in
671the obvious way to the underlying C structures of similar names. The
672inheritance hierarchy mimics the underlying C "inheritance". Access
673methods correspond to the underlying C structre field names, with the
674leading "class indication" prefix removed (op_).
675
676=head2 B::OP METHODS
677
678=over 4
679
680=item next
681
682=item sibling
683
3f872cb9
GS
684=item name
685
686This returns the op name as a string (e.g. "add", "rv2av").
687
1a52ab62
MB
688=item ppaddr
689
dc333d64
GS
690This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
691"PL_ppaddr[OP_RV2AV]").
1a52ab62
MB
692
693=item desc
694
4369b173 695This returns the op description from the global C PL_op_desc array
1a52ab62
MB
696(e.g. "addition" "array deref").
697
698=item targ
699
700=item type
701
702=item seq
703
704=item flags
705
706=item private
707
708=back
709
710=head2 B::UNOP METHOD
711
712=over 4
713
714=item first
715
716=back
717
718=head2 B::BINOP METHOD
719
720=over 4
721
722=item last
723
724=back
725
726=head2 B::LOGOP METHOD
727
728=over 4
729
730=item other
731
732=back
733
1a52ab62
MB
734=head2 B::LISTOP METHOD
735
736=over 4
737
738=item children
739
740=back
741
742=head2 B::PMOP METHODS
743
744=over 4
745
746=item pmreplroot
747
748=item pmreplstart
749
750=item pmnext
751
752=item pmregexp
753
754=item pmflags
755
9d2bbe64
MB
756=item pmdynflags
757
1a52ab62
MB
758=item pmpermflags
759
760=item precomp
761
9d2bbe64
MB
762=item pmoffet
763
764Only when perl was compiled with ithreads.
765
1a52ab62
MB
766=back
767
768=head2 B::SVOP METHOD
769
770=over 4
771
772=item sv
773
065a1863
GS
774=item gv
775
1a52ab62
MB
776=back
777
7934575e 778=head2 B::PADOP METHOD
1a52ab62
MB
779
780=over 4
781
7934575e 782=item padix
1a52ab62
MB
783
784=back
785
786=head2 B::PVOP METHOD
787
788=over 4
789
790=item pv
791
792=back
793
794=head2 B::LOOP METHODS
795
796=over 4
797
798=item redoop
799
800=item nextop
801
802=item lastop
803
804=back
805
806=head2 B::COP METHODS
807
808=over 4
809
810=item label
811
812=item stash
813
57843af0 814=item file
1a52ab62
MB
815
816=item cop_seq
817
818=item arybase
819
820=item line
821
822=back
823
824=head1 FUNCTIONS EXPORTED BY C<B>
825
826The C<B> module exports a variety of functions: some are simple
827utility functions, others provide a Perl program with a way to
828get an initial "handle" on an internal object.
829
830=over 4
831
832=item main_cv
833
834Return the (faked) CV corresponding to the main part of the Perl
835program.
836
31d7d75a
NIS
837=item init_av
838
839Returns the AV object (i.e. in class B::AV) representing INIT blocks.
840
9d2bbe64
MB
841=item begin_av
842
843Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
844
845=item end_av
846
847Returns the AV object (i.e. in class B::AV) representing END blocks.
848
1a52ab62
MB
849=item main_root
850
851Returns the root op (i.e. an object in the appropriate B::OP-derived
852class) of the main part of the Perl program.
853
854=item main_start
855
856Returns the starting op of the main part of the Perl program.
857
858=item comppadlist
859
860Returns the AV object (i.e. in class B::AV) of the global comppadlist.
861
9d2bbe64
MB
862=item regex_padav
863
864Only when perl was compiled with ithreads.
865
1a52ab62
MB
866=item sv_undef
867
868Returns the SV object corresponding to the C variable C<sv_undef>.
869
870=item sv_yes
871
872Returns the SV object corresponding to the C variable C<sv_yes>.
873
874=item sv_no
875
876Returns the SV object corresponding to the C variable C<sv_no>.
877
56eca212
GS
878=item amagic_generation
879
880Returns the SV object corresponding to the C variable C<amagic_generation>.
881
1a52ab62
MB
882=item walkoptree(OP, METHOD)
883
884Does a tree-walk of the syntax tree based at OP and calls METHOD on
885each op it visits. Each node is visited before its children. If
886C<walkoptree_debug> (q.v.) has been called to turn debugging on then
887the method C<walkoptree_debug> is called on each op before METHOD is
888called.
889
890=item walkoptree_debug(DEBUG)
891
892Returns the current debugging flag for C<walkoptree>. If the optional
893DEBUG argument is non-zero, it sets the debugging flag to that. See
894the description of C<walkoptree> above for what the debugging flag
895does.
896
87a42246 897=item walksymtable(SYMREF, METHOD, RECURSE, PREFIX)
1a52ab62
MB
898
899Walk the symbol table starting at SYMREF and call METHOD on each
87a42246
MS
900symbol (a B::GV object) visited. When the walk reaches package
901symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
902name, and only recurses into the package if that sub returns true.
903
904PREFIX is the name of the SYMREF you're walking.
905
906For example...
907
908 # Walk CGI's symbol table calling print_subs on each symbol.
909 # Only recurse into CGI::Util::
910 walksymtable(\%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' },
911 'CGI::');
912
913print_subs() is a B::GV method you have declared.
914
1a52ab62
MB
915
916=item svref_2object(SV)
917
918Takes any Perl variable and turns it into an object in the
919appropriate B::OP-derived or B::SV-derived class. Apart from functions
920such as C<main_root>, this is the primary way to get an initial
d1be9408 921"handle" on an internal perl data structure which can then be followed
1a52ab62
MB
922with the other access methods.
923
924=item ppname(OPNUM)
925
926Return the PP function name (e.g. "pp_add") of op number OPNUM.
927
928=item hash(STR)
929
930Returns a string in the form "0x..." representing the value of the
931internal hash function used by perl on string STR.
932
933=item cast_I32(I)
934
935Casts I to the internal I32 type used by that perl.
936
937
938=item minus_c
939
940Does the equivalent of the C<-c> command-line option. Obviously, this
941is only useful in a BEGIN block or else the flag is set too late.
942
943
944=item cstring(STR)
945
946Returns a double-quote-surrounded escaped version of STR which can
947be used as a string in C source code.
948
51a5edaf
RGS
949=item perlstring(STR)
950
951Returns a double-quote-surrounded escaped version of STR which can
952be used as a string in Perl source code.
953
1a52ab62
MB
954=item class(OBJ)
955
956Returns the class of an object without the part of the classname
957preceding the first "::". This is used to turn "B::UNOP" into
958"UNOP" for example.
959
960=item threadsv_names
961
962In a perl compiled for threads, this returns a list of the special
963per-thread threadsv variables.
964
1a52ab62 965=back
7f20e9dd
GS
966
967=head1 AUTHOR
968
969Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
970
971=cut