This is Info file pm.info, produced by Makeinfo version 1.68 from the input file bigpm.texi.  File: pm.info, Node: B/C, Next: B/CC, Prev: B/Bytecode, Up: Module List Perl compiler's C backend ************************* NAME ==== B::C - Perl compiler's C backend SYNOPSIS ======== perl -MO=C[,OPTIONS] foo.pl DESCRIPTION =========== This compiler backend takes Perl source and generates C source code corresponding to the internal structures that perl uses to run your program. When the generated C source is compiled and run, it cuts out the time which perl would have taken to load and parse your program into its internal semi-compiled form. That means that compiling with this backend will not help improve the runtime execution speed of your program but may improve the start-up time. Depending on the environment in which your program runs this may be either a help or a hindrance. OPTIONS ======= If there are any non-option arguments, they are taken to be names of objects to be saved (probably doesn't work properly yet). Without extra arguments, it saves the main program. *-ofilename* Output to filename instead of STDOUT -v Verbose compilation (currently gives a few compilation statistics). - Force end of options *-uPackname* Force apparently unused subs from package Packname to be compiled. This allows programs to use eval "foo()" even when sub foo is never seen to be used at compile time. The down side is that any subs which really are never used also have code generated. This option is necessary, for example, if you have a signal handler foo which you initialise with `$SIG{BAR} = "foo"'. A better fix, though, is just to change it to `$SIG{BAR} = \&foo'. You can have multiple -u options. The compiler tries to figure out which packages may possibly have subs in which need compiling but the current version doesn't do it very well. In particular, it is confused by nested packages (i.e. of the form `A::B') where package A does not contain any subs. -D Debug options (concatenated or separate flags like `perl -D'). *-Do* OPs, prints each OP as it's processed *-Dc* COPs, prints COPs as processed (incl. file & line num) *-DA* prints AV information on saving *-DC* prints CV information on saving *-DM* prints MAGIC information on saving -f Force optimisations on or off one at a time. *-fcog* Copy-on-grow: PVs declared and initialised statically. *-fno-cog* No copy-on-grow. *-On* Optimisation level (n = 0, 1, 2, ...). -O means *-O1*. Currently, *-O1* and higher set *-fcog*. *-llimit* Some C compilers impose an arbitrary limit on the length of string constants (e.g. 2048 characters for Microsoft Visual C++). The *-llimit* options tells the C backend not to generate string literals exceeding that limit. EXAMPLES ======== perl -MO=C,-ofoo.c foo.pl perl cc_harness -o foo foo.c Note that `cc_harness' lives in the B subdirectory of your perl library directory. The utility called perlcc may also be used to help make use of this compiler. perl -MO=C,-v,-DcA,-l2048 bar.pl > /dev/null BUGS ==== Plenty. Current status: experimental. AUTHOR ====== Malcolm Beattie, `mbeattie@sable.ox.ac.uk'  File: pm.info, Node: B/CC, Next: B/Debug, Prev: B/C, Up: Module List Perl compiler's optimized C translation backend *********************************************** NAME ==== B::CC - Perl compiler's optimized C translation backend SYNOPSIS ======== perl -MO=CC[,OPTIONS] foo.pl DESCRIPTION =========== This compiler backend takes Perl source and generates C source code corresponding to the flow of your program. In other words, this backend is somewhat a "real" compiler in the sense that many people think about compilers. Note however that, currently, it is a very poor compiler in that although it generates (mostly, or at least sometimes) correct code, it performs relatively few optimisations. This will change as the compiler develops. The result is that running an executable compiled with this backend may start up more quickly than running the original Perl program (a feature shared by the C compiler backend-see B::C) and may also execute slightly faster. This is by no means a good optimising compiler-yet. OPTIONS ======= If there are any non-option arguments, they are taken to be names of objects to be saved (probably doesn't work properly yet). Without extra arguments, it saves the main program. *-ofilename* Output to filename instead of STDOUT -v Verbose compilation (currently gives a few compilation statistics). - Force end of options *-uPackname* Force apparently unused subs from package Packname to be compiled. This allows programs to use eval "foo()" even when sub foo is never seen to be used at compile time. The down side is that any subs which really are never used also have code generated. This option is necessary, for example, if you have a signal handler foo which you initialise with `$SIG{BAR} = "foo"'. A better fix, though, is just to change it to `$SIG{BAR} = \&foo'. You can have multiple -u options. The compiler tries to figure out which packages may possibly have subs in which need compiling but the current version doesn't do it very well. In particular, it is confused by nested packages (i.e. of the form `A::B') where package A does not contain any subs. *-mModulename* Instead of generating source for a runnable executable, generate source for an XSUB module. The boot_Modulename function (which DynaLoader can look for) does the appropriate initialisation and runs the main part of the Perl source that is being compiled. -D Debug options (concatenated or separate flags like `perl -D'). *-Dr* Writes debugging output to STDERR just as it's about to write to the program's runtime (otherwise writes debugging info as comments in its C output). *-DO* Outputs each OP as it's compiled *-Ds* Outputs the contents of the shadow stack at each OP *-Dp* Outputs the contents of the shadow pad of lexicals as it's loaded for each sub or the main program. *-Dq* Outputs the name of each fake PP function in the queue as it's about to process it. *-Dl* Output the filename and line number of each original line of Perl code as it's processed (`pp_nextstate'). *-Dt* Outputs timing information of compilation stages. -f Force optimisations on or off one at a time. *-ffreetmps-each-bblock* Delays FREETMPS from the end of each statement to the end of the each basic block. *-ffreetmps-each-loop* Delays FREETMPS from the end of each statement to the end of the group of basic blocks forming a loop. At most one of the freetmps-each-* options can be used. *-fomit-taint* Omits generating code for handling perl's tainting mechanism. *-On* Optimisation level (n = 0, 1, 2, ...). -O means *-O1*. Currently, *-O1* sets *-ffreetmps-each-bblock* and *-O2* sets *-ffreetmps-each-loop*. EXAMPLES ======== perl -MO=CC,-O2,-ofoo.c foo.pl perl cc_harness -o foo foo.c Note that `cc_harness' lives in the B subdirectory of your perl library directory. The utility called perlcc may also be used to help make use of this compiler. perl -MO=CC,-mFoo,-oFoo.c Foo.pm perl cc_harness -shared -c -o Foo.so Foo.c BUGS ==== Plenty. Current status: experimental. DIFFERENCES =========== These aren't really bugs but they are constructs which are heavily tied to perl's compile-and-go implementation and with which this compiler backend cannot cope. Loops ----- Standard perl calculates the target of "next", "last", and "redo" at run-time. The compiler calculates the targets at compile-time. For example, the program sub skip_on_odd { next NUMBER if $_[0] % 2 } NUMBER: for ($i = 0; $i < 5; $i++) { skip_on_odd($i); print $i; } produces the output 024 with standard perl but gives a compile-time error with the compiler. Context of ".." --------------- The context (scalar or array) of the ".." operator determines whether it behaves as a range or a flip/flop. Standard perl delays until runtime the decision of which context it is in but the compiler needs to know the context at compile-time. For example, @a = (4,6,1,0,0,1); sub range { (shift @a)..(shift @a) } print range(); while (@a) { print scalar(range()) } generates the output 456123E0 with standard Perl but gives a compile-time error with compiled Perl. Arithmetic ---------- Compiled Perl programs use native C arithemtic much more frequently than standard perl. Operations on large numbers or on boundary cases may produce different behaviour. Deprecated features ------------------- Features of standard perl such as $[ which have been deprecated in standard perl since Perl5 was released have not been implemented in the compiler. AUTHOR ====== Malcolm Beattie, `mbeattie@sable.ox.ac.uk'  File: pm.info, Node: B/Debug, Next: B/Deparse, Prev: B/CC, Up: Module List Walk Perl syntax tree, printing debug info about ops **************************************************** NAME ==== B::Debug - Walk Perl syntax tree, printing debug info about ops SYNOPSIS ======== perl -MO=Debug[,OPTIONS] foo.pl DESCRIPTION =========== See `ext/B/README'. AUTHOR ====== Malcolm Beattie, `mbeattie@sable.ox.ac.uk'  File: pm.info, Node: B/Deparse, Next: B/Disassembler, Prev: B/Debug, Up: Module List Perl compiler backend to produce perl code ****************************************** NAME ==== B::Deparse - Perl compiler backend to produce perl code SYNOPSIS ======== *perl* *-MO=Deparse*[*,-u*PACKAGE][*,-p*][*,-q*][*,-l*][*,-s**LETTERS*] *prog.pl* DESCRIPTION =========== B::Deparse is a backend module for the Perl compiler that generates perl source code, based on the internal compiled structure that perl itself creates after parsing a program. The output of B::Deparse won't be exactly the same as the original source, since perl doesn't keep track of comments or whitespace, and there isn't a one-to-one correspondence between perl's syntactical constructions and their compiled form, but it will often be close. When you use the -p option, the output also includes parentheses even when they are not required by precedence, which can make it easy to see if perl is parsing your expressions the way you intended. Please note that this module is mainly new and untested code and is still under development, so it may change in the future. OPTIONS ======= As with all compiler backend options, these must follow directly after the '-MO=Deparse', separated by a comma but not any white space. -l Add '#line' declarations to the output based on the line and file locations of the original code. -p Print extra parentheses. Without this option, B::Deparse includes parentheses in its output only when they are needed, based on the structure of your program. With -p, it uses parentheses (almost) whenever they would be legal. This can be useful if you are used to LISP, or if you want to see how perl parses your input. If you say if ($var & 0x7f == 65) {print "Gimme an A!"} print ($which ? $a : $b), "\n"; $name = $ENV{USER} or "Bob"; `B::Deparse,-p' will print if (($var & 0)) { print('Gimme an A!') }; (print(($which ? $a : $b)), '???'); (($name = $ENV{'USER'}) or '???') which probably isn't what you intended (the `'???'' is a sign that perl optimized away a constant value). -q Expand double-quoted strings into the corresponding combinations of concatenation, uc, ucfirst, lc, lcfirst, quotemeta, and join. For instance, print print "Hello, $world, @ladies, \u$gentlemen\E, \u\L$me!"; as print 'Hello, ' . $world . ', ' . join($", @ladies) . ', ' . ucfirst($gentlemen) . ', ' . ucfirst(lc $me . '!'); Note that the expanded form represents the way perl handles such constructions internally - this option actually turns off the reverse translation that B::Deparse usually does. On the other hand, note that `$x = "$y"' is not the same as `$x = $y': the former makes the value of $y into a string before doing the assignment. -uPACKAGE Normally, B::Deparse deparses the main code of a program, all the subs called by the main program (and all the subs called by them, recursively), and any other subs in the main:: package. To include subs in other packages that aren't called directly, such as AUTOLOAD, DESTROY, other subs called automatically by perl, and methods (which aren't resolved to subs until runtime), use the -u option. The argument to -u is the name of a package, and should follow directly after the 'u'. Multiple -u options may be given, separated by commas. Note that unlike some other backends, B::Deparse doesn't (yet) try to guess automatically when -u is needed - you must invoke it yourself. -s*LETTERS* Tweak the style of B::Deparse's output. The letters should follow directly after the 's', with no space or punctuation. The following options are available: C Cuddle `elsif', else, and continue blocks. For example, print if (...) { ... } else { ... } instead of if (...) { ... } else { ... } The default is not to cuddle. i*NUMBER* Indent lines by multiples of *NUMBER* columns. The default is 4 columns. T Use tabs for each 8 columns of indent. The default is to use only spaces. For instance, if the style options are *-si4T*, a line that's indented 3 times will be preceded by one tab and four spaces; if the options were *-si8T*, the same line would be preceded by three tabs. vSTRING. Print STRING for the value of a constant that can't be determined because it was optimized away (mnemonic: this happens when a constant is used in void context). The end of the string is marked by a period. The string should be a valid perl expression, generally a constant. Note that unless it's a number, it probably needs to be quoted, and on a command line quotes need to be protected from the shell. Some conventional values include 0, 1, 42, ", 'foo', and 'Useless use of constant omitted' (which may need to be *-sv"'Useless use of constant omitted'."* or something similar depending on your shell). The default is '???'. If you're using B::Deparse on a module or other file that's require'd, you shouldn't use a value that evaluates to false, since the customary true constant at the end of a module will be in void context when the file is compiled as a main program. USING B::Deparse AS A MODULE ============================ Synopsis -------- use B::Deparse; $deparse = B::Deparse->new("-p", "-sC"); $body = $deparse->coderef2text(\&func); eval "sub func $body"; # the inverse operation Description ----------- B::Deparse can also be used on a sub-by-sub basis from other perl programs. new --- $deparse = B::Deparse->new(OPTIONS) Create an object to store the state of a deparsing operation and any options. The options are the same as those that can be given on the command line (see `' in this node); options that are separated by commas after *-MO=Deparse* should be given as separate strings. Some options, like -u, don't make sense for a single subroutine, so don't pass them. coderef2text ------------ $body = $deparse->coderef2text(\&func) $body = $deparse->coderef2text(sub ($$) { ... }) Return source code for the body of a subroutine (a block, optionally preceded by a prototype in parens), given a reference to the sub. Because a subroutine can have no names, or more than one name, this method doesn't return a complete subroutine definition - if you want to eval the result, you should prepend "sub subname ", or "sub " for an anonymous function constructor. Unless the sub was defined in the main:: package, the code will include a package declaration. BUGS ==== See the 'to do' list at the beginning of the module file. AUTHOR ====== Stephen McCamant , based on an earlier version by Malcolm Beattie , with contributions from Gisle Aas, James Duncan, Albert Dvornik, Hugo van der Sanden, Gurusamy Sarathy, and Nick Ing-Simmons.  File: pm.info, Node: B/Disassembler, Next: B/Fathom, Prev: B/Deparse, Up: Module List Disassemble Perl bytecode ************************* NAME ==== B::Disassembler - Disassemble Perl bytecode SYNOPSIS ======== use Disassembler; DESCRIPTION =========== See `ext/B/B/Disassembler.pm'. AUTHOR ====== Malcolm Beattie, `mbeattie@sable.ox.ac.uk'  File: pm.info, Node: B/Fathom, Next: B/FindAmpersand, Prev: B/Disassembler, Up: Module List a module to evaluate the readability of Perl code ************************************************* NAME ==== B::Fathom - a module to evaluate the readability of Perl code SYNOPSIS ======== perl -MO=Fathom