ext/B/B.pm

   1 #      B.pm
   2 #
   3 #      Copyright (c) 1996, 1997, 1998 Malcolm Beattie
   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 #
   8 package B;
   9
  10 our $VERSION = '1.01';
  11
  12 use XSLoader ();
  13 require Exporter;
  14 @ISA = qw(Exporter);
  15
  16 # walkoptree_slow comes from B.pm (you are there),
  17 # walkoptree comes from B.xs
  18 @EXPORT_OK = qw(minus_c ppname save_BEGINs
  19                 class peekop cast_I32 cstring cchar hash threadsv_names
  20                 main_root main_start main_cv svref_2object opnumber
  21                 amagic_generation perlstring
  22                 walkoptree_slow walkoptree walkoptree_exec walksymtable
  23                 parents comppadlist sv_undef compile_stats timing_info
  24                 begin_av init_av end_av regex_padav);
  25
  26 sub OPf_KIDS ();
  27 use 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';
  43 @B::IO::ISA = 'B::PVMG';
  44 @B::FM::ISA = 'B::CV';
  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';
  50 @B::LISTOP::ISA = 'B::BINOP';
  51 @B::SVOP::ISA = 'B::OP';
  52 @B::PADOP::ISA = 'B::OP';
  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
  66 sub B::GV::SAFENAME {
  67   my $name = (shift())->NAME;
  68
  69   # The regex below corresponds to the isCONTROLVAR macro
  70   # from toke.c
  71
  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
  78   return $name;
  79 }
  80
  81 sub B::IV::int_value {
  82   my ($self) = @_;
  83   return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV);
  84 }
  85
  86 sub B::NULL::as_string() {""}
  87 sub B::IV::as_string()   {goto &B::IV::int_value}
  88 sub B::PV::as_string()   {goto &B::PV::PV}
  89
  90 my $debug;
  91 my $op_count = 0;
  92 my @parents = ();
  93
  94 sub debug {
  95     my ($class, $value) = @_;
  96     $debug = $value;
  97     walkoptree_debug($value);
  98 }
  99
 100 sub class {
 101     my $obj = shift;
 102     my $name = ref $obj;
 103     $name =~ s/^.*:://;
 104     return $name;
 105 }
 106
 107 sub parents { \@parents }
 108
 109 # For debugging
 110 sub peekop {
 111     my $op = shift;
 112     return sprintf("%s (0x%x) %s", class($op), $$op, $op->name);
 113 }
 114
 115 sub walkoptree_slow {
 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) {
 125             walkoptree_slow($kid, $method, $level + 1);
 126         }
 127         shift @parents;
 128     }
 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     }
 134 }
 135
 136 sub compile_stats {
 137     return "Total number of OPs processed: $op_count\n";
 138 }
 139
 140 sub 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
 147 my %symtable;
 148
 149 sub clearsym {
 150     %symtable = ();
 151 }
 152
 153 sub 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
 159 sub objsym {
 160     my $obj = shift;
 161     return $symtable{sprintf("sym_%x", $$obj)};
 162 }
 163
 164 sub walkoptree_exec {
 165     my ($op, $method, $level) = @_;
 166     $level ||= 0;
 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);
 177         $ppname = $op->name;
 178         if ($ppname =~
 179             /^(or|and|mapwhile|grepwhile|entertry|range|cond_expr)$/)
 180         {
 181             print $prefix, uc($1), " => {\n";
 182             walkoptree_exec($op->other, $method, $level + 1);
 183             print $prefix, "}\n";
 184         } elsif ($ppname eq "match" || $ppname eq "subst") {
 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             }
 191         } elsif ($ppname eq "substcont") {
 192             print $prefix, "SUBSTCONT => {\n";
 193             walkoptree_exec($op->other->pmreplstart, $method, $level + 1);
 194             print $prefix, "}\n";
 195             $op = $op->other;
 196         } elsif ($ppname eq "enterloop") {
 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";
 204         } elsif ($ppname eq "subst") {
 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
 215 sub walksymtable {
 216     my ($symref, $method, $recurse, $prefix) = @_;
 217     my $sym;
 218     my $ref;
 219     my $fullname;
 220     no strict 'refs';
 221     $prefix = '' unless defined $prefix;
 222     while (($sym, $ref) = each %$symref) {
 223         $fullname = "*main::".$prefix.$sym;
 224         if ($sym =~ /::$/) {
 225             $sym = $prefix . $sym;
 226             if ($sym ne "main::" && $sym ne "<none>::" && &$recurse($sym)) {
 227                walksymtable(\%$fullname, $method, $recurse, $sym);
 228             }
 229         } else {
 230            svref_2object(\*$fullname)->$method();
 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
 301 XSLoader::load 'B';
 302
 303 1;
 304
 305 __END__
 306
 307 =head1 NAME
 308
 309 B - The Perl Compiler
 310
 311 =head1 SYNOPSIS
 312
 313         use B;
 314
 315 =head1 DESCRIPTION
 316
 317 The C<B> module supplies classes which allow a Perl program to delve
 318 into its own innards. It is the module used to implement the
 319 "backends" of the Perl compiler. Usage of the compiler does not
 320 require knowledge of this module: see the F<O> module for the
 321 user-visible part. The C<B> module is of use to those who want to
 322 write new compiler backends. This documentation assumes that the
 323 reader knows a fair amount about perl's internals including such
 324 things as SVs, OPs and the internal symbol table and syntax tree
 325 of a program.
 326
 327 =head1 OVERVIEW OF CLASSES
 328
 329 The C structures used by Perl's internals to hold SV and OP
 330 information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
 331 class hierarchy and the C<B> module gives access to them via a true
 332 object hierarchy. Structure fields which point to other objects
 333 (whether types of SV or types of OP) are represented by the C<B>
 334 module as Perl objects of the appropriate class. The bulk of the C<B>
 335 module is the methods for accessing fields of these structures. Note
 336 that all access is read-only: you cannot modify the internals by
 337 using this module.
 338
 339 =head2 SV-RELATED CLASSES
 340
 341 B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
 342 B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
 343 the obvious way to the underlying C structures of similar names. The
 344 inheritance hierarchy mimics the underlying C "inheritance". Access
 345 methods correspond to the underlying C macros for field access,
 346 usually with the leading "class indication" prefix removed (Sv, Av,
 347 Hv, ...). The leading prefix is only left in cases where its removal
 348 would cause a clash in method name. For example, C<GvREFCNT> stays
 349 as-is since its abbreviation would clash with the "superclass" method
 350 C<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
 368 Returns the value of the IV, I<interpreted as
 369 a signed integer>. This will be misleading
 370 if C<FLAGS & SVf_IVisUV>. Perhaps you want the
 371 C<int_value> method instead?
 372
 373 =item IVX
 374
 375 =item UVX
 376
 377 =item int_value
 378
 379 This method returns the value of the IV as an integer.
 380 It differs from C<IV> in that it returns the correct
 381 value regardless of whether it's stored signed or
 382 unsigned.
 383
 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
 414 This method is the one you usually want. It constructs a
 415 string using the length and offset information in the struct:
 416 for ordinary scalars it will return the string that you'd see
 417 from Perl, even if it contains null characters.
 418
 419 =item RV
 420
 421 Same as B::RV::RV, except that it will die() if the PV isn't
 422 a reference.
 423
 424 =item PVX
 425
 426 This method is less often useful. It assumes that the string
 427 stored in the struct is null-terminated, and disregards the
 428 length information.
 429
 430 It is the appropriate method to use if you need to get the name
 431 of a lexical variable from a padname array. Lexical variable names
 432 are 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
 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
 453 =item precomp
 454
 455 Only valid on r-magic, returns the string that generated the regexp.
 456
 457 =item PRIVATE
 458
 459 =item TYPE
 460
 461 =item FLAGS
 462
 463 =item OBJ
 464
 465 Will die() if called on r-magic.
 466
 467 =item PTR
 468
 469 =item REGEX
 470
 471 Only valid on r-magic, returns the integer value of the REGEX stored
 472 in the MAGIC.
 473
 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
 508 =item is_empty
 509
 510 This method returns TRUE if the GP field of the GV is NULL.
 511
 512 =item NAME
 513
 514 =item SAFENAME
 515
 516 This method returns the name of the glob, but if the first
 517 character of the name is a control character, then it converts
 518 it to ^X first, so that *^G would return "^G" rather than "\cG".
 519
 520 It's useful if you want to print out the name of a variable.
 521 If you restrict yourself to globs which exist at compile-time
 522 then the result ought to be unambiguous, because code like
 523 C<${"^G"} = 1> is compiled as two ops - a constant string and
 524 a dereference (rv2gv) - so that the glob is created at runtime.
 525
 526 If you're working with globs at runtime, and need to disambiguate
 527 *^G from *{"^G"}, then you should use the raw NAME method.
 528
 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
 549 =item FILE
 550
 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
 589 =item IsSTD
 590
 591 Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true
 592 if the IoIFP of the object is equal to the handle whose name was
 593 passed as argument ( i.e. $io->IsSTD('stderr') is true if
 594 IoIFP($io) == PerlIO_stdin() ).
 595
 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
 626 =item FILE
 627
 628 =item DEPTH
 629
 630 =item PADLIST
 631
 632 =item OUTSIDE
 633
 634 =item XSUB
 635
 636 =item XSUBANY
 637
 638 For constant subroutines, returns the constant SV returned by the subroutine.
 639
 640 =item CvFLAGS
 641
 642 =item const_sv
 643
 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
 668 B::OP, B::UNOP, B::BINOP, B::LOGOP, B::LISTOP, B::PMOP,
 669 B::SVOP, B::PADOP, B::PVOP, B::CVOP, B::LOOP, B::COP.
 670 These classes correspond in
 671 the obvious way to the underlying C structures of similar names. The
 672 inheritance hierarchy mimics the underlying C "inheritance". Access
 673 methods correspond to the underlying C structre field names, with the
 674 leading "class indication" prefix removed (op_).
 675
 676 =head2 B::OP METHODS
 677
 678 =over 4
 679
 680 =item next
 681
 682 =item sibling
 683
 684 =item name
 685
 686 This returns the op name as a string (e.g. "add", "rv2av").
 687
 688 =item ppaddr
 689
 690 This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]",
 691 "PL_ppaddr[OP_RV2AV]").
 692
 693 =item desc
 694
 695 This returns the op description from the global C PL_op_desc array
 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
 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
 756 =item pmdynflags
 757
 758 =item pmpermflags
 759
 760 =item precomp
 761
 762 =item pmoffet
 763
 764 Only when perl was compiled with ithreads.
 765
 766 =back
 767
 768 =head2 B::SVOP METHOD
 769
 770 =over 4
 771
 772 =item sv
 773
 774 =item gv
 775
 776 =back
 777
 778 =head2 B::PADOP METHOD
 779
 780 =over 4
 781
 782 =item padix
 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
 814 =item file
 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
 826 The C<B> module exports a variety of functions: some are simple
 827 utility functions, others provide a Perl program with a way to
 828 get an initial "handle" on an internal object.
 829
 830 =over 4
 831
 832 =item main_cv
 833
 834 Return the (faked) CV corresponding to the main part of the Perl
 835 program.
 836
 837 =item init_av
 838
 839 Returns the AV object (i.e. in class B::AV) representing INIT blocks.
 840
 841 =item begin_av
 842
 843 Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
 844
 845 =item end_av
 846
 847 Returns the AV object (i.e. in class B::AV) representing END blocks.
 848
 849 =item main_root
 850
 851 Returns the root op (i.e. an object in the appropriate B::OP-derived
 852 class) of the main part of the Perl program.
 853
 854 =item main_start
 855
 856 Returns the starting op of the main part of the Perl program.
 857
 858 =item comppadlist
 859
 860 Returns the AV object (i.e. in class B::AV) of the global comppadlist.
 861
 862 =item regex_padav
 863
 864 Only when perl was compiled with ithreads.
 865
 866 =item sv_undef
 867
 868 Returns the SV object corresponding to the C variable C<sv_undef>.
 869
 870 =item sv_yes
 871
 872 Returns the SV object corresponding to the C variable C<sv_yes>.
 873
 874 =item sv_no
 875
 876 Returns the SV object corresponding to the C variable C<sv_no>.
 877
 878 =item amagic_generation
 879
 880 Returns the SV object corresponding to the C variable C<amagic_generation>.
 881
 882 =item walkoptree(OP, METHOD)
 883
 884 Does a tree-walk of the syntax tree based at OP and calls METHOD on
 885 each op it visits. Each node is visited before its children. If
 886 C<walkoptree_debug> (q.v.) has been called to turn debugging on then
 887 the method C<walkoptree_debug> is called on each op before METHOD is
 888 called.
 889
 890 =item walkoptree_debug(DEBUG)
 891
 892 Returns the current debugging flag for C<walkoptree>. If the optional
 893 DEBUG argument is non-zero, it sets the debugging flag to that. See
 894 the description of C<walkoptree> above for what the debugging flag
 895 does.
 896
 897 =item walksymtable(SYMREF, METHOD, RECURSE, PREFIX)
 898
 899 Walk the symbol table starting at SYMREF and call METHOD on each
 900 symbol (a B::GV object) visited.  When the walk reaches package
 901 symbols (such as "Foo::") it invokes RECURSE, passing in the symbol
 902 name, and only recurses into the package if that sub returns true.
 903
 904 PREFIX is the name of the SYMREF you're walking.
 905
 906 For 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
 913 print_subs() is a B::GV method you have declared.
 914
 915
 916 =item svref_2object(SV)
 917
 918 Takes any Perl variable and turns it into an object in the
 919 appropriate B::OP-derived or B::SV-derived class. Apart from functions
 920 such as C<main_root>, this is the primary way to get an initial
 921 "handle" on an internal perl data structure which can then be followed
 922 with the other access methods.
 923
 924 =item ppname(OPNUM)
 925
 926 Return the PP function name (e.g. "pp_add") of op number OPNUM.
 927
 928 =item hash(STR)
 929
 930 Returns a string in the form "0x..." representing the value of the
 931 internal hash function used by perl on string STR.
 932
 933 =item cast_I32(I)
 934
 935 Casts I to the internal I32 type used by that perl.
 936
 937
 938 =item minus_c
 939
 940 Does the equivalent of the C<-c> command-line option. Obviously, this
 941 is only useful in a BEGIN block or else the flag is set too late.
 942
 943
 944 =item cstring(STR)
 945
 946 Returns a double-quote-surrounded escaped version of STR which can
 947 be used as a string in C source code.
 948
 949 =item perlstring(STR)
 950
 951 Returns a double-quote-surrounded escaped version of STR which can
 952 be used as a string in Perl source code.
 953
 954 =item class(OBJ)
 955
 956 Returns the class of an object without the part of the classname
 957 preceding the first "::". This is used to turn "B::UNOP" into
 958 "UNOP" for example.
 959
 960 =item threadsv_names
 961
 962 In a perl compiled for threads, this returns a list of the special
 963 per-thread threadsv variables.
 964
 965 =back
 966
 967 =head1 AUTHOR
 968
 969 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
 970
 971 =cut