B - The Perl Compiler |
B::SV
, B::AV
, B::HV
, and B::CV
objectsB::OP
objects or for walking op trees
B - The Perl Compiler
use B;
The B
module supplies classes which allow a Perl program to delve
into its own innards. It is the module used to implement the
``backends'' of the Perl compiler. Usage of the compiler does not
require knowledge of this module: see the O module for the
user-visible part. The B
module is of use to those who want to
write new compiler backends. This documentation assumes that the
reader knows a fair amount about perl's internals including such
things as SVs, OPs and the internal symbol table and syntax tree
of a program.
The B
module contains a set of utility functions for querying the
current state of the Perl interpreter; typically these functions
return objects from the B::SV and B::OP classes, or their derived
classes. These classes in turn define methods for querying the
resulting objects about their own internal state.
The B
module exports a variety of functions: some are simple
utility functions, others provide a Perl program with a way to
get an initial ``handle'' on an internal object.
B::SV
, B::AV
, B::HV
, and B::CV
objectsFor descriptions of the class hierachy of these objects and the methods that can be called on them, see below, OVERVIEW OF CLASSES and SV-RELATED CLASSES.
sv_undef
.
sv_yes
.
sv_no
.
svref_2object(SVREF)
main_root
, this is the primary
way to get an initial ``handle'' on an internal perl data structure
which can then be followed with the other access methods.
amagic_generation
.
init_av
main_cv
PREFIX is the name of the SYMREF you're walking.
For example:
# Walk CGI's symbol table calling print_subs on each symbol. # Recurse only into CGI::Util:: walksymtable(\%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' }, 'CGI::');
print_subs()
is a B::GV method you have declared. Also see B::GV Methods, below.
B::OP
objects or for walking op treesFor descriptions of the class hierachy of these objects and the methods that can be called on them, see below, OVERVIEW OF CLASSES and OP-RELATED CLASSES.
walkoptree_debug
(see below) has been called to turn debugging on then
the method walkoptree_debug
is called on each op before METHOD is
called.
walkoptree_debug(DEBUG)
walkoptree
. If the optional
DEBUG argument is non-zero, it sets the debugging flag to that. See
the description of walkoptree
above for what the debugging flag
does.
ppname(OPNUM)
hash(STR)
cast_I32(I)
-c
command-line option. Obviously, this
is only useful in a BEGIN block or else the flag is set too late.
cstring(STR)
perlstring(STR)
class(OBJ)
"::"
. This is used to turn "B::UNOP"
into
"UNOP"
for example.
The C structures used by Perl's internals to hold SV and OP
information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a
class hierarchy and the B
module gives access to them via a true
object hierarchy. Structure fields which point to other objects
(whether types of SV or types of OP) are represented by the B
module as Perl objects of the appropriate class.
The bulk of the B
module is the methods for accessing fields of
these structures.
Note that all access is read-only. You cannot modify the internals by using this module.
B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV, B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in the obvious way to the underlying C structures of similar names. The inheritance hierarchy mimics the underlying C ``inheritance'':
B::SV | +--------------+----------------------+ | | | B::PV B::IV B::RV | \ / \ | \ / \ | B::PVIV B::NV \ / \____ __/ \ / B::PVNV | | B::PVMG | +------+-----+----+------+-----+-----+ | | | | | | | B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO | | B::FM
Access methods correspond to the underlying C macros for field access,
usually with the leading ``class indication'' prefix removed (Sv, Av,
Hv, ...). The leading prefix is only left in cases where its removal
would cause a clash in method name. For example, GvREFCNT
stays
as-is since its abbreviation would clash with the ``superclass'' method
REFCNT
(corresponding to the C function SvREFCNT
).
FLAGS & SVf_IVisUV
. Perhaps you want the
int_value
method instead?
IV
in that it returns the correct
value regardless of whether it's stored signed or
unsigned.
die()
if the PV isn't
a reference.
It is the appropriate method to use if you need to get the name of a lexical variable from a padname array. Lexical variable names are always stored with a null terminator, and the length field (SvCUR) is overloaded for other purposes and can't be relied on here.
die()
if called on r-magic.
It's useful if you want to print out the name of a variable.
If you restrict yourself to globs which exist at compile-time
then the result ought to be unambiguous, because code like
${"^G"} = 1
is compiled as two ops - a constant string and
a dereference (rv2gv) - so that the glob is created at runtime.
If you're working with globs at runtime, and need to disambiguate *^G from *{``^G''}, then you should use the raw NAME method.
IsSTD('stderr')
is true if
IoIFP($io)
== PerlIO_stdin()
).
B::OP
, B::UNOP
, B::BINOP
, B::LOGOP
, B::LISTOP
, B::PMOP
,
B::SVOP
, B::PADOP
, B::PVOP
, B::CVOP
, B::LOOP
, B::COP
.
These classes correspond in the obvious way to the underlying C structures of similar names. The inheritance hierarchy mimics the underlying C ``inheritance'':
B::OP | +---------------+--------+--------+------+ | | | | | B::UNOP B::SVOP B::PADOP B::CVOP B::COP ,' `-. / `--. B::BINOP B::LOGOP | | B::LISTOP ,' `. / \ B::LOOP B::PMOP
Access methods correspond to the underlying C structre field names,
with the leading ``class indication'' prefix ("op_"
) removed.
Malcolm Beattie, mbeattie@sable.ox.ac.uk
B - The Perl Compiler |