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, @options) = @_;
my ($quiet, $veryquiet) = (0, 0);
if ($options[0] eq '-q' || $options[0] eq '-qq') {
$quiet = 1;
- open (SAVEOUT, ">&STDOUT");
+ open ($saveout_fh, ">&", STDOUT);
close STDOUT;
open (STDOUT, ">", \$O::BEGIN_output);
if ($options[0] eq '-qq') {
my $backend = shift (@options);
eval q[
BEGIN {
- minus_c;
- save_BEGINs;
+ B::minus_c;
+ B::save_BEGINs;
}
CHECK {
if ($quiet) {
close STDOUT;
- open (STDOUT, ">&SAVEOUT");
- close SAVEOUT;
- }
- use B::].$backend.q[ ();
- if ($@) {
- croak "use of backend $backend failed: $@";
+ 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 ($\,$",$,) = (undef,' ','');
+ local $savebackslash = $\;
+ local ($\,$",$,) = (undef,' ','');
&$compilesub();
close STDERR if $veryquiet;
}
];
- die $@ if $@;
+ if ($@) {
+ my $msg = "$@";
+ require Carp;
+ Carp::croak("Loading compiler backend 'B::$backend' failed: $msg");
+ }
}
1;
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"
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>