.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 .\" .\" Standard preamble: .\" ======================================================================== .de Sh \" Subsection heading .br .if t .Sp .ne 5 .PP \fB\\$1\fR .PP .. .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" Set up some character translations and predefined strings. \*(-- will .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left .\" double quote, and \*(R" will give a right double quote. | will give a .\" real vertical bar. \*(C+ will give a nicer C++. Capital omega is used to .\" do unbreakable dashes and therefore won't be available. \*(C` and \*(C' .\" expand to `' in nroff, nothing in troff, for use with C<>. .tr \(*W-|\(bv\*(Tr .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' .ie n \{\ . ds -- \(*W- . ds PI pi . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch . ds L" "" . ds R" "" . ds C` "" . ds C' "" 'br\} .el\{\ . ds -- \|\(em\| . ds PI \(*p . ds L" `` . ds R" '' 'br\} .\" .\" If the F register is turned on, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . nr % 0 . rr F .\} .\" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .hy 0 .if n .na .\" .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). .\" Fear. Run. Save yourself. No user-serviceable parts. . \" fudge factors for nroff and troff .if n \{\ . ds #H 0 . ds #V .8m . ds #F .3m . ds #[ \f1 . ds #] \fP .\} .if t \{\ . ds #H ((1u-(\\\\n(.fu%2u))*.13m) . ds #V .6m . ds #F 0 . ds #[ \& . ds #] \& .\} . \" simple accents for nroff and troff .if n \{\ . ds ' \& . ds ` \& . ds ^ \& . ds , \& . ds ~ ~ . ds / .\} .if t \{\ . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' .\} . \" troff and (daisy-wheel) nroff accents .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' .ds 8 \h'\*(#H'\(*b\h'-\*(#H' .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] .ds ae a\h'-(\w'a'u*4/10)'e .ds Ae A\h'-(\w'A'u*4/10)'E . \" corrections for vroff .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' . \" for low resolution devices (crt and lpr) .if \n(.H>23 .if \n(.V>19 \ \{\ . ds : e . ds 8 ss . ds o a . ds d- d\h'-1'\(ga . ds D- D\h'-1'\(hy . ds th \o'bp' . ds Th \o'LP' . ds ae ae . ds Ae AE .\} .rm #[ #] #H #V #F C .\" ======================================================================== .\" .IX Title "B 3" .TH B 3 "2002-06-01" "perl v5.8.0" "Perl Programmers Reference Guide" .SH "NAME" B \- The Perl Compiler .SH "SYNOPSIS" .IX Header "SYNOPSIS" .Vb 1 \& use B; .Ve .SH "DESCRIPTION" .IX Header "DESCRIPTION" The \f(CW\*(C`B\*(C'\fR module supplies classes which allow a Perl program to delve into its own innards. It is the module used to implement the \&\*(L"backends\*(R" of the Perl compiler. Usage of the compiler does not require knowledge of this module: see the \fIO\fR module for the user-visible part. The \f(CW\*(C`B\*(C'\fR 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. .SH "OVERVIEW OF CLASSES" .IX Header "OVERVIEW OF CLASSES" The C structures used by Perl's internals to hold \s-1SV\s0 and \s-1OP\s0 information (\s-1PVIV\s0, \s-1AV\s0, \s-1HV\s0, ..., \s-1OP\s0, \s-1SVOP\s0, \s-1UNOP\s0, ...) are modelled on a class hierarchy and the \f(CW\*(C`B\*(C'\fR module gives access to them via a true object hierarchy. Structure fields which point to other objects (whether types of \s-1SV\s0 or types of \s-1OP\s0) are represented by the \f(CW\*(C`B\*(C'\fR module as Perl objects of the appropriate class. The bulk of the \f(CW\*(C`B\*(C'\fR 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. .Sh "SV-RELATED \s-1CLASSES\s0" .IX Subsection "SV-RELATED CLASSES" 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 \*(L"inheritance\*(R". Access methods correspond to the underlying C macros for field access, usually with the leading \*(L"class indication\*(R" 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, \f(CW\*(C`GvREFCNT\*(C'\fR stays as-is since its abbreviation would clash with the \*(L"superclass\*(R" method \&\f(CW\*(C`REFCNT\*(C'\fR (corresponding to the C function \f(CW\*(C`SvREFCNT\*(C'\fR). .Sh "B::SV \s-1METHODS\s0" .IX Subsection "B::SV METHODS" .IP "\s-1REFCNT\s0" 4 .IX Item "REFCNT" .PD 0 .IP "\s-1FLAGS\s0" 4 .IX Item "FLAGS" .PD .Sh "B::IV \s-1METHODS\s0" .IX Subsection "B::IV METHODS" .IP "\s-1IV\s0" 4 .IX Item "IV" Returns the value of the \s-1IV\s0, \fIinterpreted as a signed integer\fR. This will be misleading if \f(CW\*(C`FLAGS & SVf_IVisUV\*(C'\fR. Perhaps you want the \&\f(CW\*(C`int_value\*(C'\fR method instead? .IP "\s-1IVX\s0" 4 .IX Item "IVX" .PD 0 .IP "\s-1UVX\s0" 4 .IX Item "UVX" .IP "int_value" 4 .IX Item "int_value" .PD This method returns the value of the \s-1IV\s0 as an integer. It differs from \f(CW\*(C`IV\*(C'\fR in that it returns the correct value regardless of whether it's stored signed or unsigned. .IP "needs64bits" 4 .IX Item "needs64bits" .PD 0 .IP "packiv" 4 .IX Item "packiv" .PD .Sh "B::NV \s-1METHODS\s0" .IX Subsection "B::NV METHODS" .IP "\s-1NV\s0" 4 .IX Item "NV" .PD 0 .IP "\s-1NVX\s0" 4 .IX Item "NVX" .PD .Sh "B::RV \s-1METHODS\s0" .IX Subsection "B::RV METHODS" .IP "\s-1RV\s0" 4 .IX Item "RV" .Sh "B::PV \s-1METHODS\s0" .IX Subsection "B::PV METHODS" .PD 0 .IP "\s-1PV\s0" 4 .IX Item "PV" .PD This method is the one you usually want. It constructs a string using the length and offset information in the struct: for ordinary scalars it will return the string that you'd see from Perl, even if it contains null characters. .IP "\s-1RV\s0" 4 .IX Item "RV" Same as B::RV::RV, except that it will \fIdie()\fR if the \s-1PV\s0 isn't a reference. .IP "\s-1PVX\s0" 4 .IX Item "PVX" This method is less often useful. It assumes that the string stored in the struct is null\-terminated, and disregards the length information. .Sp 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. .Sh "B::PVMG \s-1METHODS\s0" .IX Subsection "B::PVMG METHODS" .IP "\s-1MAGIC\s0" 4 .IX Item "MAGIC" .PD 0 .IP "SvSTASH" 4 .IX Item "SvSTASH" .PD .Sh "B::MAGIC \s-1METHODS\s0" .IX Subsection "B::MAGIC METHODS" .IP "\s-1MOREMAGIC\s0" 4 .IX Item "MOREMAGIC" .PD 0 .IP "precomp" 4 .IX Item "precomp" .PD Only valid on r\-magic, returns the string that generated the regexp. .IP "\s-1PRIVATE\s0" 4 .IX Item "PRIVATE" .PD 0 .IP "\s-1TYPE\s0" 4 .IX Item "TYPE" .IP "\s-1FLAGS\s0" 4 .IX Item "FLAGS" .IP "\s-1OBJ\s0" 4 .IX Item "OBJ" .PD Will \fIdie()\fR if called on r\-magic. .IP "\s-1PTR\s0" 4 .IX Item "PTR" .PD 0 .IP "\s-1REGEX\s0" 4 .IX Item "REGEX" .PD Only valid on r\-magic, returns the integer value of the \s-1REGEX\s0 stored in the \s-1MAGIC\s0. .Sh "B::PVLV \s-1METHODS\s0" .IX Subsection "B::PVLV METHODS" .IP "\s-1TARGOFF\s0" 4 .IX Item "TARGOFF" .PD 0 .IP "\s-1TARGLEN\s0" 4 .IX Item "TARGLEN" .IP "\s-1TYPE\s0" 4 .IX Item "TYPE" .IP "\s-1TARG\s0" 4 .IX Item "TARG" .PD .Sh "B::BM \s-1METHODS\s0" .IX Subsection "B::BM METHODS" .IP "\s-1USEFUL\s0" 4 .IX Item "USEFUL" .PD 0 .IP "\s-1PREVIOUS\s0" 4 .IX Item "PREVIOUS" .IP "\s-1RARE\s0" 4 .IX Item "RARE" .IP "\s-1TABLE\s0" 4 .IX Item "TABLE" .PD .Sh "B::GV \s-1METHODS\s0" .IX Subsection "B::GV METHODS" .IP "is_empty" 4 .IX Item "is_empty" This method returns \s-1TRUE\s0 if the \s-1GP\s0 field of the \s-1GV\s0 is \s-1NULL\s0. .IP "\s-1NAME\s0" 4 .IX Item "NAME" .PD 0 .IP "\s-1SAFENAME\s0" 4 .IX Item "SAFENAME" .PD This method returns the name of the glob, but if the first character of the name is a control character, then it converts it to ^X first, so that *^G would return \*(L"^G\*(R" rather than \*(L"\ecG\*(R". .Sp 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 \&\f(CW\*(C`${"^G"} = 1\*(C'\fR is compiled as two ops \- a constant string and a dereference (rv2gv) \- so that the glob is created at runtime. .Sp If you're working with globs at runtime, and need to disambiguate *^G from *{\*(L"^G\*(R"}, then you should use the raw \s-1NAME\s0 method. .IP "\s-1STASH\s0" 4 .IX Item "STASH" .PD 0 .IP "\s-1SV\s0" 4 .IX Item "SV" .IP "\s-1IO\s0" 4 .IX Item "IO" .IP "\s-1FORM\s0" 4 .IX Item "FORM" .IP "\s-1AV\s0" 4 .IX Item "AV" .IP "\s-1HV\s0" 4 .IX Item "HV" .IP "\s-1EGV\s0" 4 .IX Item "EGV" .IP "\s-1CV\s0" 4 .IX Item "CV" .IP "\s-1CVGEN\s0" 4 .IX Item "CVGEN" .IP "\s-1LINE\s0" 4 .IX Item "LINE" .IP "\s-1FILE\s0" 4 .IX Item "FILE" .IP "\s-1FILEGV\s0" 4 .IX Item "FILEGV" .IP "GvREFCNT" 4 .IX Item "GvREFCNT" .IP "\s-1FLAGS\s0" 4 .IX Item "FLAGS" .PD .Sh "B::IO \s-1METHODS\s0" .IX Subsection "B::IO METHODS" .IP "\s-1LINES\s0" 4 .IX Item "LINES" .PD 0 .IP "\s-1PAGE\s0" 4 .IX Item "PAGE" .IP "\s-1PAGE_LEN\s0" 4 .IX Item "PAGE_LEN" .IP "\s-1LINES_LEFT\s0" 4 .IX Item "LINES_LEFT" .IP "\s-1TOP_NAME\s0" 4 .IX Item "TOP_NAME" .IP "\s-1TOP_GV\s0" 4 .IX Item "TOP_GV" .IP "\s-1FMT_NAME\s0" 4 .IX Item "FMT_NAME" .IP "\s-1FMT_GV\s0" 4 .IX Item "FMT_GV" .IP "\s-1BOTTOM_NAME\s0" 4 .IX Item "BOTTOM_NAME" .IP "\s-1BOTTOM_GV\s0" 4 .IX Item "BOTTOM_GV" .IP "\s-1SUBPROCESS\s0" 4 .IX Item "SUBPROCESS" .IP "IoTYPE" 4 .IX Item "IoTYPE" .IP "IoFLAGS" 4 .IX Item "IoFLAGS" .IP "IsSTD" 4 .IX Item "IsSTD" .PD Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true if the IoIFP of the object is equal to the handle whose name was passed as argument ( i.e. \f(CW$io\fR\->IsSTD('stderr') is true if IoIFP($io) == \fIPerlIO_stdin()\fR ). .Sh "B::AV \s-1METHODS\s0" .IX Subsection "B::AV METHODS" .IP "\s-1FILL\s0" 4 .IX Item "FILL" .PD 0 .IP "\s-1MAX\s0" 4 .IX Item "MAX" .IP "\s-1OFF\s0" 4 .IX Item "OFF" .IP "\s-1ARRAY\s0" 4 .IX Item "ARRAY" .IP "AvFLAGS" 4 .IX Item "AvFLAGS" .PD .Sh "B::CV \s-1METHODS\s0" .IX Subsection "B::CV METHODS" .IP "\s-1STASH\s0" 4 .IX Item "STASH" .PD 0 .IP "\s-1START\s0" 4 .IX Item "START" .IP "\s-1ROOT\s0" 4 .IX Item "ROOT" .IP "\s-1GV\s0" 4 .IX Item "GV" .IP "\s-1FILE\s0" 4 .IX Item "FILE" .IP "\s-1DEPTH\s0" 4 .IX Item "DEPTH" .IP "\s-1PADLIST\s0" 4 .IX Item "PADLIST" .IP "\s-1OUTSIDE\s0" 4 .IX Item "OUTSIDE" .IP "\s-1XSUB\s0" 4 .IX Item "XSUB" .IP "\s-1XSUBANY\s0" 4 .IX Item "XSUBANY" .PD For constant subroutines, returns the constant \s-1SV\s0 returned by the subroutine. .IP "CvFLAGS" 4 .IX Item "CvFLAGS" .PD 0 .IP "const_sv" 4 .IX Item "const_sv" .PD .Sh "B::HV \s-1METHODS\s0" .IX Subsection "B::HV METHODS" .IP "\s-1FILL\s0" 4 .IX Item "FILL" .PD 0 .IP "\s-1MAX\s0" 4 .IX Item "MAX" .IP "\s-1KEYS\s0" 4 .IX Item "KEYS" .IP "\s-1RITER\s0" 4 .IX Item "RITER" .IP "\s-1NAME\s0" 4 .IX Item "NAME" .IP "\s-1PMROOT\s0" 4 .IX Item "PMROOT" .IP "\s-1ARRAY\s0" 4 .IX Item "ARRAY" .PD .Sh "OP-RELATED \s-1CLASSES\s0" .IX Subsection "OP-RELATED CLASSES" 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 \*(L"inheritance\*(R". Access methods correspond to the underlying C structre field names, with the leading \*(L"class indication\*(R" prefix removed (op_). .Sh "B::OP \s-1METHODS\s0" .IX Subsection "B::OP METHODS" .IP "next" 4 .IX Item "next" .PD 0 .IP "sibling" 4 .IX Item "sibling" .IP "name" 4 .IX Item "name" .PD This returns the op name as a string (e.g. \*(L"add\*(R", \*(L"rv2av\*(R"). .IP "ppaddr" 4 .IX Item "ppaddr" This returns the function name as a string (e.g. \*(L"PL_ppaddr[\s-1OP_ADD\s0]\*(R", \&\*(L"PL_ppaddr[\s-1OP_RV2AV\s0]\*(R"). .IP "desc" 4 .IX Item "desc" This returns the op description from the global C PL_op_desc array (e.g. \*(L"addition\*(R" \*(L"array deref\*(R"). .IP "targ" 4 .IX Item "targ" .PD 0 .IP "type" 4 .IX Item "type" .IP "seq" 4 .IX Item "seq" .IP "flags" 4 .IX Item "flags" .IP "private" 4 .IX Item "private" .PD .Sh "B::UNOP \s-1METHOD\s0" .IX Subsection "B::UNOP METHOD" .IP "first" 4 .IX Item "first" .Sh "B::BINOP \s-1METHOD\s0" .IX Subsection "B::BINOP METHOD" .PD 0 .IP "last" 4 .IX Item "last" .PD .Sh "B::LOGOP \s-1METHOD\s0" .IX Subsection "B::LOGOP METHOD" .IP "other" 4 .IX Item "other" .Sh "B::LISTOP \s-1METHOD\s0" .IX Subsection "B::LISTOP METHOD" .PD 0 .IP "children" 4 .IX Item "children" .PD .Sh "B::PMOP \s-1METHODS\s0" .IX Subsection "B::PMOP METHODS" .IP "pmreplroot" 4 .IX Item "pmreplroot" .PD 0 .IP "pmreplstart" 4 .IX Item "pmreplstart" .IP "pmnext" 4 .IX Item "pmnext" .IP "pmregexp" 4 .IX Item "pmregexp" .IP "pmflags" 4 .IX Item "pmflags" .IP "pmdynflags" 4 .IX Item "pmdynflags" .IP "pmpermflags" 4 .IX Item "pmpermflags" .IP "precomp" 4 .IX Item "precomp" .IP "pmoffet" 4 .IX Item "pmoffet" .PD Only when perl was compiled with ithreads. .Sh "B::SVOP \s-1METHOD\s0" .IX Subsection "B::SVOP METHOD" .IP "sv" 4 .IX Item "sv" .PD 0 .IP "gv" 4 .IX Item "gv" .PD .Sh "B::PADOP \s-1METHOD\s0" .IX Subsection "B::PADOP METHOD" .IP "padix" 4 .IX Item "padix" .Sh "B::PVOP \s-1METHOD\s0" .IX Subsection "B::PVOP METHOD" .PD 0 .IP "pv" 4 .IX Item "pv" .PD .Sh "B::LOOP \s-1METHODS\s0" .IX Subsection "B::LOOP METHODS" .IP "redoop" 4 .IX Item "redoop" .PD 0 .IP "nextop" 4 .IX Item "nextop" .IP "lastop" 4 .IX Item "lastop" .PD .Sh "B::COP \s-1METHODS\s0" .IX Subsection "B::COP METHODS" .IP "label" 4 .IX Item "label" .PD 0 .IP "stash" 4 .IX Item "stash" .IP "file" 4 .IX Item "file" .IP "cop_seq" 4 .IX Item "cop_seq" .IP "arybase" 4 .IX Item "arybase" .IP "line" 4 .IX Item "line" .PD .ie n .SH "FUNCTIONS EXPORTED BY ""B""" .el .SH "FUNCTIONS EXPORTED BY \f(CWB\fP" .IX Header "FUNCTIONS EXPORTED BY B" The \f(CW\*(C`B\*(C'\fR module exports a variety of functions: some are simple utility functions, others provide a Perl program with a way to get an initial \*(L"handle\*(R" on an internal object. .IP "main_cv" 4 .IX Item "main_cv" Return the (faked) \s-1CV\s0 corresponding to the main part of the Perl program. .IP "init_av" 4 .IX Item "init_av" Returns the \s-1AV\s0 object (i.e. in class B::AV) representing \s-1INIT\s0 blocks. .IP "begin_av" 4 .IX Item "begin_av" Returns the \s-1AV\s0 object (i.e. in class B::AV) representing \s-1BEGIN\s0 blocks. .IP "end_av" 4 .IX Item "end_av" Returns the \s-1AV\s0 object (i.e. in class B::AV) representing \s-1END\s0 blocks. .IP "main_root" 4 .IX Item "main_root" Returns the root op (i.e. an object in the appropriate B::OP\-derived class) of the main part of the Perl program. .IP "main_start" 4 .IX Item "main_start" Returns the starting op of the main part of the Perl program. .IP "comppadlist" 4 .IX Item "comppadlist" Returns the \s-1AV\s0 object (i.e. in class B::AV) of the global comppadlist. .IP "regex_padav" 4 .IX Item "regex_padav" Only when perl was compiled with ithreads. .IP "sv_undef" 4 .IX Item "sv_undef" Returns the \s-1SV\s0 object corresponding to the C variable \f(CW\*(C`sv_undef\*(C'\fR. .IP "sv_yes" 4 .IX Item "sv_yes" Returns the \s-1SV\s0 object corresponding to the C variable \f(CW\*(C`sv_yes\*(C'\fR. .IP "sv_no" 4 .IX Item "sv_no" Returns the \s-1SV\s0 object corresponding to the C variable \f(CW\*(C`sv_no\*(C'\fR. .IP "amagic_generation" 4 .IX Item "amagic_generation" Returns the \s-1SV\s0 object corresponding to the C variable \f(CW\*(C`amagic_generation\*(C'\fR. .IP "walkoptree(\s-1OP\s0, \s-1METHOD\s0)" 4 .IX Item "walkoptree(OP, METHOD)" Does a tree-walk of the syntax tree based at \s-1OP\s0 and calls \s-1METHOD\s0 on each op it visits. Each node is visited before its children. If \&\f(CW\*(C`walkoptree_debug\*(C'\fR (q.v.) has been called to turn debugging on then the method \f(CW\*(C`walkoptree_debug\*(C'\fR is called on each op before \s-1METHOD\s0 is called. .IP "walkoptree_debug(\s-1DEBUG\s0)" 4 .IX Item "walkoptree_debug(DEBUG)" Returns the current debugging flag for \f(CW\*(C`walkoptree\*(C'\fR. If the optional \&\s-1DEBUG\s0 argument is non\-zero, it sets the debugging flag to that. See the description of \f(CW\*(C`walkoptree\*(C'\fR above for what the debugging flag does. .IP "walksymtable(\s-1SYMREF\s0, \s-1METHOD\s0, \s-1RECURSE\s0, \s-1PREFIX\s0)" 4 .IX Item "walksymtable(SYMREF, METHOD, RECURSE, PREFIX)" Walk the symbol table starting at \s-1SYMREF\s0 and call \s-1METHOD\s0 on each symbol (a B::GV object) visited. When the walk reaches package symbols (such as \*(L"Foo::\*(R") it invokes \s-1RECURSE\s0, passing in the symbol name, and only recurses into the package if that sub returns true. .Sp \&\s-1PREFIX\s0 is the name of the \s-1SYMREF\s0 you're walking. .Sp For example... .Sp .Vb 4 \& # Walk CGI's symbol table calling print_subs on each symbol. \& # Only recurse into CGI::Util:: \& walksymtable(\e%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' }, \& 'CGI::'); .Ve .Sp \&\fIprint_subs()\fR is a B::GV method you have declared. .IP "svref_2object(\s-1SV\s0)" 4 .IX Item "svref_2object(SV)" Takes any Perl variable and turns it into an object in the appropriate B::OP\-derived or B::SV\-derived class. Apart from functions such as \f(CW\*(C`main_root\*(C'\fR, this is the primary way to get an initial \&\*(L"handle\*(R" on an internal perl data structure which can then be followed with the other access methods. .IP "ppname(\s-1OPNUM\s0)" 4 .IX Item "ppname(OPNUM)" Return the \s-1PP\s0 function name (e.g. \*(L"pp_add\*(R") of op number \s-1OPNUM\s0. .IP "hash(\s-1STR\s0)" 4 .IX Item "hash(STR)" Returns a string in the form \*(L"0x...\*(R" representing the value of the internal hash function used by perl on string \s-1STR\s0. .IP "cast_I32(I)" 4 .IX Item "cast_I32(I)" Casts I to the internal I32 type used by that perl. .IP "minus_c" 4 .IX Item "minus_c" Does the equivalent of the \f(CW\*(C`\-c\*(C'\fR command-line option. Obviously, this is only useful in a \s-1BEGIN\s0 block or else the flag is set too late. .IP "cstring(\s-1STR\s0)" 4 .IX Item "cstring(STR)" Returns a double-quote-surrounded escaped version of \s-1STR\s0 which can be used as a string in C source code. .IP "perlstring(\s-1STR\s0)" 4 .IX Item "perlstring(STR)" Returns a double-quote-surrounded escaped version of \s-1STR\s0 which can be used as a string in Perl source code. .IP "class(\s-1OBJ\s0)" 4 .IX Item "class(OBJ)" Returns the class of an object without the part of the classname preceding the first \*(L"::\*(R". This is used to turn \*(L"B::UNOP\*(R" into \&\*(L"\s-1UNOP\s0\*(R" for example. .IP "threadsv_names" 4 .IX Item "threadsv_names" In a perl compiled for threads, this returns a list of the special per-thread threadsv variables. .SH "AUTHOR" .IX Header "AUTHOR" Malcolm Beattie, \f(CW\*(C`mbeattie@sable.ox.ac.uk\*(C'\fR