Fix warnings (used once) for O.pm

[perl5.git] / ext / B / O.pm

diff --git a/ext/B/O.pm b/ext/B/O.pm
index 2ef91ed..09a905e 100644 (file)
--- a/ext/B/O.pm
+++ b/ext/B/O.pm
@@ -1,20 +1,61 @@
 package O;
-use B qw(minus_c save_BEGINs);
-use Carp;    
+
+our $VERSION = '1.02';
+
+use B ();
+
+our $BEGIN_output;
+our $saveout_fh;
 
 sub import {
-    my ($class, $backend, @options) = @_;
-    eval "use B::$backend ()";
-    if ($@) {
-       croak "use of backend $backend failed: $@";
+    my ($class, @options) = @_;
+    my ($quiet, $veryquiet) = (0, 0);
+    if ($options[0] eq '-q' || $options[0] eq '-qq') {
+       $quiet = 1;
+       open ($saveout_fh, ">&", STDOUT);
+       close STDOUT;
+       open (STDOUT, ">", \$O::BEGIN_output);
+       if ($options[0] eq '-qq') {
+           $veryquiet = 1;
+       }
+       shift @options;
     }
-    my $compilesub = &{"B::${backend}::compile"}(@options);
-    if (ref($compilesub) eq "CODE") {
-       minus_c;
-       save_BEGINs;
-       eval 'CHECK { &$compilesub() }';
-    } else {
-       die $compilesub;
+    my $backend = shift (@options);
+    eval q[
+       BEGIN {
+           B::minus_c;
+           B::save_BEGINs;
+       }
+
+       CHECK {
+           if ($quiet) {
+               close STDOUT;
+               open (STDOUT, ">&", $saveout_fh);
+               close $saveout_fh;
+           }
+
+           # Note: if you change the code after this 'use', please
+           # change the fudge factors in B::Concise (grep for
+           # "fragile kludge") so that its output still looks
+           # nice. Thanks. --smcc
+           use B::].$backend.q[ ();
+
+           my $compilesub = &{"B::${backend}::compile"}(@options);
+           if (ref($compilesub) ne "CODE") {
+               die $compilesub;
+           }
+
+           local $savebackslash = $\;
+           local ($\,$",$,) = (undef,' ','');
+           &$compilesub();
+
+           close STDERR if $veryquiet;
+       }
+    ];
+    if ($@) {
+        my $msg = "$@";
+        require Carp;
+        Carp::croak("Loading compiler backend 'B::$backend' failed: $msg");
     }
 }
 
@@ -28,12 +69,25 @@ O - Generic interface to Perl Compiler backends
 
 =head1 SYNOPSIS
 
-       perl -MO=Backend[,OPTIONS] foo.pl
+       perl -MO=[-q,]Backend[,OPTIONS] foo.pl
 
 =head1 DESCRIPTION
 
 This is the module that is used as a frontend to the Perl Compiler.
 
+If you pass the C<-q> option to the module, then the STDOUT
+filehandle will be redirected into the variable C<$O::BEGIN_output>
+during compilation.  This has the effect that any output printed
+to STDOUT by BEGIN blocks or use'd modules will be stored in this
+variable rather than printed. It's useful with those backends which
+produce output themselves (C<Deparse>, C<Concise> etc), so that
+their output is not confused with that generated by the code
+being compiled.
+
+The C<-qq> option behaves like C<-q>, except that it also closes
+STDERR after deparsing has finished. This suppresses the "Syntax OK"
+message normally produced by perl.
+
 =head1 CONVENTIONS
 
 Most compiler backends use the following conventions: OPTIONS
@@ -55,16 +109,15 @@ the Perl code
 
     use O ("Backend", OPTIONS);
 
-The C<import> function which that calls loads in the appropriate
-C<B::Backend> module and calls the C<compile> function in that
-package, passing it OPTIONS. That function is expected to return
-a sub reference which we'll call CALLBACK. Next, the "compile-only"
-flag is switched on (equivalent to the command-line option C<-c>)
-and a CHECK block is registered which calls CALLBACK. Thus the main
-Perl program mentioned on the command-line is read in, parsed and
-compiled into internal syntax tree form. Since the C<-c> flag is
-set, the program does not start running (excepting BEGIN blocks of
-course) but the CALLBACK function registered by the compiler
+The C<O::import> function loads the appropriate C<B::Backend> module
+and calls its C<compile> function, passing it OPTIONS. That function
+is expected to return a sub reference which we'll call CALLBACK. Next,
+the "compile-only" flag is switched on (equivalent to the command-line
+option C<-c>) and a CHECK block is registered which calls
+CALLBACK. Thus the main Perl program mentioned on the command-line is
+read in, parsed and compiled into internal syntax tree form. Since the
+C<-c> flag is set, the program does not start running (excepting BEGIN
+blocks of course) but the CALLBACK function registered by the compiler
 backend is called.
 
 In summary, a compiler backend module should be called "B::Foo"
@@ -79,6 +132,12 @@ After the user's program is loaded and parsed, that returned sub ref
 is invoked which can then go ahead and do the compilation, usually by
 making use of the C<B> module's functionality.
 
+=head1 BUGS
+
+The C<-q> and C<-qq> options don't work correctly if perl isn't
+compiled with PerlIO support : STDOUT will be closed instead of being
+redirected to C<$O::BEGIN_output>.
+
 =head1 AUTHOR
 
 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>