utils/perlcc.PL

   1 #!/usr/local/bin/perl
   2
   3 use Config;
   4 use File::Basename qw(&basename &dirname);
   5 use File::Spec;
   6 use Cwd;
   7
   8 # List explicitly here the variables you want Configure to
   9 # generate.  Metaconfig only looks for shell variables, so you
  10 # have to mention them as if they were shell variables, not
  11 # %Config entries.  Thus you write
  12 #  $startperl
  13 # to ensure Configure will look for $Config{startperl}.
  14 # Wanted:  $archlibexp
  15
  16 # This forces PL files to create target in same directory as PL file.
  17 # This is so that make depend always knows where to find PL derivatives.
  18 $origdir = cwd;
  19 chdir dirname($0);
  20 $file = basename($0, '.PL');
  21 $file .= '.com' if $^O eq 'VMS';
  22
  23 open OUT,">$file" or die "Can't create $file: $!";
  24
  25 print "Extracting $file (with variable substitutions)\n";
  26
  27 # In this section, perl variables will be expanded during extraction.
  28 # You can use $Config{...} to use Configure variables.
  29
  30 print OUT <<"!GROK!THIS!";
  31 $Config{startperl}
  32     eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
  33     if \$running_under_some_shell;
  34 --\$running_under_some_shell;
  35 !GROK!THIS!
  36
  37 # In the following, perl variables are not expanded during extraction.
  38
  39 print OUT <<'!NO!SUBS!';
  40
  41 # Version 2.0, Simon Cozens, Thu Mar 30 17:52:45 JST 2000
  42 # Version 2.01, Tom Christiansen, Thu Mar 30 08:25:14 MST 2000
  43 # Version 2.02, Simon Cozens, Sun Apr 16 01:53:36 JST 2000
  44 # Version 2.03, Edward Peschko, Mon Feb 26 12:04:17 PST 2001
  45
  46 use strict;
  47 use warnings;
  48 use 5.006_000;
  49
  50 use FileHandle;
  51 use Config;
  52 use Fcntl qw(:DEFAULT :flock);
  53 use File::Temp qw(tempfile);
  54 use Cwd;
  55 our $VERSION = 2.03;
  56 $| = 1;
  57
  58 $SIG{INT} = sub { exit(); }; # exit gracefully and clean up after ourselves.
  59
  60 use subs qw{
  61     cc_harness check_read check_write checkopts_byte choose_backend
  62     compile_byte compile_cstyle compile_module generate_code
  63     grab_stash parse_argv sanity_check vprint yclept spawnit
  64 };
  65 sub opt(*); # imal quoting
  66 sub is_win32();
  67 sub is_msvc();
  68
  69 our ($Options, $BinPerl, $Backend);
  70 our ($Input => $Output);
  71 our ($logfh);
  72 our ($cfile);
  73 our (@begin_output); # output from BEGIN {}, for testsuite
  74
  75 # eval { main(); 1 } or die;
  76
  77 main();
  78
  79 sub main {
  80     parse_argv();
  81     check_write($Output);
  82     choose_backend();
  83     generate_code();
  84     run_code();
  85     _die("XXX: Not reached?");
  86 }
  87
  88 #######################################################################
  89
  90 sub choose_backend {
  91     # Choose the backend.
  92     $Backend = 'C';
  93     if (opt(B)) {
  94         checkopts_byte();
  95         $Backend = 'Bytecode';
  96     }
  97     if (opt(S) && opt(c)) {
  98         # die "$0: Do you want me to compile this or not?\n";
  99         delete $Options->{S};
 100     }
 101     $Backend = 'CC' if opt(O);
 102 }
 103
 104
 105 sub generate_code {
 106
 107     vprint 0, "Compiling $Input";
 108
 109     $BinPerl  = yclept();  # Calling convention for perl.
 110
 111     if (opt(shared)) {
 112         compile_module();
 113     } else {
 114         if ($Backend eq 'Bytecode') {
 115             compile_byte();
 116         } else {
 117             compile_cstyle();
 118         }
 119     }
 120     exit(0) if (!opt('r'));
 121 }
 122
 123 sub run_code {
 124     vprint 0, "Running code";
 125     run("$Output @ARGV");
 126     exit(0);
 127 }
 128
 129 # usage: vprint [level] msg args
 130 sub vprint {
 131     my $level;
 132     if (@_ == 1) {
 133         $level = 1;
 134     } elsif ($_[0] =~ /^\d$/) {
 135         $level = shift;
 136     } else {
 137         # well, they forgot to use a number; means >0
 138         $level = 0;
 139     }
 140     my $msg = "@_";
 141     $msg .= "\n" unless substr($msg, -1) eq "\n";
 142     if (opt(v) > $level)
 143     {
 144          print        "$0: $msg" if !opt('log');
 145          print $logfh "$0: $msg" if  opt('log');
 146     }
 147 }
 148
 149 sub parse_argv {
 150
 151     use Getopt::Long;
 152
 153     # disallows using long arguments
 154     # Getopt::Long::Configure("bundling");
 155
 156     Getopt::Long::Configure("no_ignore_case");
 157
 158     # no difference in exists and defined for %ENV; also, a "0"
 159     # argument or a "" would not help cc, so skip
 160     unshift @ARGV, split ' ', $ENV{PERLCC_OPTS} if $ENV{PERLCC_OPTS};
 161
 162     $Options = {};
 163     Getopt::Long::GetOptions( $Options,
 164         'L:s',          # lib directory
 165         'I:s',          # include directories (FOR C, NOT FOR PERL)
 166         'o:s',          # Output executable
 167         'v:i',          # Verbosity level
 168         'e:s',          # One-liner
 169         'r',            # run resulting executable
 170         'B',            # Byte compiler backend
 171         'O',            # Optimised C backend
 172         'c',            # Compile only
 173         'h',            # Help me
 174         'S',            # Dump C files
 175         'r',            # run the resulting executable
 176         'T',            # run the backend using perl -T
 177         't',            # run the backend using perl -t
 178         'static',       # Dirty hack to enable -shared/-static
 179         'shared',       # Create a shared library (--shared for compat.)
 180         'log:s',        # where to log compilation process information
 181         'testsuite',    # try to be nice to testsuite
 182     );
 183
 184     $Options->{v} += 0;
 185
 186     if( opt(t) && opt(T) ) {
 187         warn "Can't specify both -T and -t, -t ignored";
 188         $Options->{t} = 0;
 189     }
 190
 191     helpme() if opt(h); # And exit
 192
 193     $Output = opt(o) || ( is_win32 ? 'a.exe' : 'a.out' );
 194     $Output = is_win32() ? $Output : relativize($Output);
 195     $logfh  = new FileHandle(">> " . opt('log')) if (opt('log'));
 196
 197     if (opt(e)) {
 198         warn "$0: using -e 'code' as input file, ignoring @ARGV\n" if @ARGV;
 199         # We don't use a temporary file here; why bother?
 200         # XXX: this is not bullet proof -- spaces or quotes in name!
 201         $Input = is_win32() ? # Quotes eaten by shell
 202             '-e "'.opt(e).'"' :
 203             "-e '".opt(e)."'";
 204     } else {
 205         $Input = shift @ARGV;  # XXX: more files?
 206         _usage_and_die("$0: No input file specified\n") unless $Input;
 207         # DWIM modules. This is bad but necessary.
 208         $Options->{shared}++ if $Input =~ /\.pm\z/;
 209         warn "$0: using $Input as input file, ignoring @ARGV\n" if @ARGV;
 210         check_read($Input);
 211         check_perl($Input);
 212         sanity_check();
 213     }
 214
 215 }
 216
 217 sub opt(*) {
 218     my $opt = shift;
 219     return exists($Options->{$opt}) && ($Options->{$opt} || 0);
 220 }
 221
 222 sub compile_module {
 223     die "$0: Compiling to shared libraries is currently disabled\n";
 224 }
 225
 226 sub compile_byte {
 227     require ByteLoader;
 228     my $stash = grab_stash();
 229     my $command = "$BinPerl -MO=Bytecode,$stash $Input";
 230     # The -a option means we'd have to close the file and lose the
 231     # lock, which would create the tiniest of races. Instead, append
 232     # the output ourselves.
 233     vprint 1, "Writing on $Output";
 234
 235     my $openflags = O_WRONLY | O_CREAT;
 236     $openflags |= O_BINARY if eval { O_BINARY; 1 };
 237     $openflags |= O_EXLOCK if eval { O_EXLOCK; 1 };
 238
 239     # these dies are not "$0: .... \n" because they "can't happen"
 240
 241     sysopen(OUT, $Output, $openflags)
 242         or die "can't write to $Output: $!";
 243
 244     # this is blocking; hold on; why are we doing this??
 245     # flock OUT, LOCK_EX or die "can't lock $Output: $!"
 246     #    unless eval { O_EXLOCK; 1 };
 247
 248     truncate(OUT, 0)
 249         or die "couldn't trunc $Output: $!";
 250
 251     print OUT <<EOF;
 252 #!$^X
 253 use ByteLoader $ByteLoader::VERSION;
 254 EOF
 255
 256     # Now the compile:
 257     vprint 1, "Compiling...";
 258     vprint 3, "Calling $command";
 259
 260     my ($output_r, $error_r) = spawnit($command);
 261
 262     if (@$error_r && $? != 0) {
 263         _die("$0: $Input did not compile, which can't happen:\n@$error_r\n");
 264     } else {
 265         my @error = grep { !/^$Input syntax OK$/o } @$error_r;
 266         warn "$0: Unexpected compiler output:\n@error" if @error;
 267     }
 268
 269     # Write it and leave.
 270     print OUT @$output_r               or _die("can't write $Output: $!");
 271     close OUT                          or _die("can't close $Output: $!");
 272
 273     # wait, how could it be anything but what you see next?
 274     chmod 0777 & ~umask, $Output    or _die("can't chmod $Output: $!");
 275     exit 0;
 276 }
 277
 278 sub compile_cstyle {
 279     my $stash = grab_stash();
 280     my $taint = opt(T) ? '-T' :
 281                 opt(t) ? '-t' : '';
 282
 283     # What are we going to call our output C file?
 284     my $lose = 0;
 285     my ($cfh);
 286     my $testsuite = '';
 287
 288     if (opt(testsuite)) {
 289         my $bo = join '', @begin_output;
 290         $bo =~ s/\\/\\\\\\\\/gs;
 291         $bo =~ s/\n/\\n/gs;
 292         $bo =~ s/,/\\054/gs;
 293         # don't look at that: it hurts
 294         $testsuite = q{-fuse-script-name,-fsave-data,-fsave-sig-hash,}.
 295             qq[-e"print q{$bo}",] .
 296             q{-e"open(Test::Builder::TESTOUT\054 '>&STDOUT') or die $!",} .
 297             q{-e"open(Test::Builder::TESTERR\054 '>&STDERR') or die $!",};
 298     }
 299     if (opt(S) || opt(c)) {
 300         # We need to keep it.
 301         if (opt(e)) {
 302             $cfile = "a.out.c";
 303         } else {
 304             $cfile = $Input;
 305             # File off extension if present
 306             # hold on: plx is executable; also, careful of ordering!
 307             $cfile =~ s/\.(?:p(?:lx|l|h)|m)\z//i;
 308             $cfile .= ".c";
 309             $cfile = $Output if opt(c) && $Output =~ /\.c\z/i;
 310         }
 311         check_write($cfile);
 312     } else {
 313         # Don't need to keep it, be safe with a tempfile.
 314         $lose = 1;
 315         ($cfh, $cfile) = tempfile("pccXXXXX", SUFFIX => ".c");
 316         close $cfh; # See comment just below
 317     }
 318     vprint 1, "Writing C on $cfile";
 319
 320     my $max_line_len = '';
 321     if ($^O eq 'MSWin32' && $Config{cc} =~ /^cl/i) {
 322         $max_line_len = '-l2000,';
 323     }
 324
 325     # This has to do the write itself, so we can't keep a lock. Life
 326     # sucks.
 327     my $command = "$BinPerl $taint -MO=$Backend,$testsuite$max_line_len$stash,-o$cfile $Input";
 328     vprint 1, "Compiling...";
 329     vprint 1, "Calling $command";
 330
 331         my ($output_r, $error_r) = spawnit($command);
 332         my @output = @$output_r;
 333         my @error = @$error_r;
 334
 335     if (@error && $? != 0) {
 336         _die("$0: $Input did not compile, which can't happen:\n@error\n");
 337     }
 338
 339     is_msvc ?
 340         cc_harness_msvc($cfile,$stash) :
 341         cc_harness($cfile,$stash) unless opt(c);
 342
 343     if ($lose) {
 344         vprint 2, "unlinking $cfile";
 345         unlink $cfile or _die("can't unlink $cfile: $!");
 346     }
 347 }
 348
 349 sub cc_harness_msvc {
 350     my ($cfile,$stash)=@_;
 351     use ExtUtils::Embed ();
 352     my $obj = "${Output}.obj";
 353     my $compile = ExtUtils::Embed::ccopts." -c -Fo$obj $cfile ";
 354     my $link = "-out:$Output $obj";
 355     $compile .= " -I".$_ for split /\s+/, opt(I);
 356     $link .= " -libpath:".$_ for split /\s+/, opt(L);
 357     my @mods = split /-?u /, $stash;
 358     $link .= " ".ExtUtils::Embed::ldopts("-std", \@mods);
 359     $link .= " perl57.lib msvcrt.lib";
 360     vprint 3, "running $Config{cc} $compile";
 361     system("$Config{cc} $compile");
 362     vprint 3, "running $Config{ld} $link";
 363     system("$Config{ld} $link");
 364 }
 365
 366 sub cc_harness {
 367         my ($cfile,$stash)=@_;
 368         use ExtUtils::Embed ();
 369         my $command = ExtUtils::Embed::ccopts." -o $Output $cfile ";
 370         $command .= " -I".$_ for split /\s+/, opt(I);
 371         $command .= " -L".$_ for split /\s+/, opt(L);
 372         my @mods = split /-?u /, $stash;
 373         $command .= " ".ExtUtils::Embed::ldopts("-std", \@mods);
 374         $command .= " -lperl";
 375         vprint 3, "running $Config{cc} $command";
 376         system("$Config{cc} $command");
 377 }
 378
 379 # Where Perl is, and which include path to give it.
 380 sub yclept {
 381     my $command = "$^X ";
 382
 383     # DWIM the -I to be Perl, not C, include directories.
 384     if (opt(I) && $Backend eq "Bytecode") {
 385         for (split /\s+/, opt(I)) {
 386             if (-d $_) {
 387                 push @INC, $_;
 388             } else {
 389                 warn "$0: Include directory $_ not found, skipping\n";
 390             }
 391         }
 392     }
 393
 394     $command .= "-I$_ " for @INC;
 395     return $command;
 396 }
 397
 398 # Use B::Stash to find additional modules and stuff.
 399 {
 400     my $_stash;
 401     sub grab_stash {
 402
 403         warn "already called get_stash once" if $_stash;
 404
 405         my $taint = opt(T) ? '-T' :
 406                     opt(t) ? '-t' : '';
 407         my $command = "$BinPerl $taint -MB::Stash -c $Input";
 408         # Filename here is perfectly sanitised.
 409         vprint 3, "Calling $command\n";
 410
 411                 my ($stash_r, $error_r) = spawnit($command);
 412                 my @stash = @$stash_r;
 413                 my @error = @$error_r;
 414
 415         if (@error && $? != 0) {
 416             _die("$0: $Input did not compile:\n@error\n");
 417         }
 418
 419         # band-aid for modules with noisy BEGIN {}
 420         foreach my $i ( @stash ) {
 421             $i =~ m/-u(?:[\w:]+|\<none\>)$/ and $stash[0] = $i and next;
 422             push @begin_output, $i;
 423         }
 424         chomp $stash[0];
 425         $stash[0] =~ s/,-u\<none\>//;
 426         $stash[0] =~ s/^.*?-u/-u/s;
 427         vprint 2, "Stash: ", join " ", split /,?-u/, $stash[0];
 428         chomp $stash[0];
 429         return $_stash = $stash[0];
 430     }
 431
 432 }
 433
 434 # Check the consistency of options if -B is selected.
 435 # To wit, (-B|-O) ==> no -shared, no -S, no -c
 436 sub checkopts_byte {
 437
 438     _die("$0: Please choose one of either -B and -O.\n") if opt(O);
 439
 440     if (opt(shared)) {
 441         warn "$0: Will not create a shared library for bytecode\n";
 442         delete $Options->{shared};
 443     }
 444
 445     for my $o ( qw[c S] ) {
 446         if (opt($o)) {
 447             warn "$0: Compiling to bytecode is a one-pass process--",
 448                   "-$o ignored\n";
 449             delete $Options->{$o};
 450         }
 451     }
 452
 453 }
 454
 455 # Check the input and output files make sense, are read/writeable.
 456 sub sanity_check {
 457     if ($Input eq $Output) {
 458         if ($Input eq 'a.out') {
 459             _die("$0: Compiling a.out is probably not what you want to do.\n");
 460             # You fully deserve what you get now. No you *don't*. typos happen.
 461         } else {
 462             warn "$0: Will not write output on top of input file, ",
 463                 "compiling to a.out instead\n";
 464             $Output = "a.out";
 465         }
 466     }
 467 }
 468
 469 sub check_read {
 470     my $file = shift;
 471     unless (-r $file) {
 472         _die("$0: Input file $file is a directory, not a file\n") if -d _;
 473         unless (-e _) {
 474             _die("$0: Input file $file was not found\n");
 475         } else {
 476             _die("$0: Cannot read input file $file: $!\n");
 477         }
 478     }
 479     unless (-f _) {
 480         # XXX: die?  don't try this on /dev/tty
 481         warn "$0: WARNING: input $file is not a plain file\n";
 482     }
 483 }
 484
 485 sub check_write {
 486     my $file = shift;
 487     if (-d $file) {
 488         _die("$0: Cannot write on $file, is a directory\n");
 489     }
 490     if (-e _) {
 491         _die("$0: Cannot write on $file: $!\n") unless -w _;
 492     }
 493     unless (-w cwd()) {
 494         _die("$0: Cannot write in this directory: $!\n");
 495     }
 496 }
 497
 498 sub check_perl {
 499     my $file = shift;
 500     unless (-T $file) {
 501         warn "$0: Binary `$file' sure doesn't smell like perl source!\n";
 502         print "Checking file type... ";
 503         system("file", $file);
 504         _die("Please try a perlier file!\n");
 505     }
 506
 507     open(my $handle, "<", $file)    or _die("XXX: can't open $file: $!");
 508     local $_ = <$handle>;
 509     if (/^#!/ && !/perl/) {
 510         _die("$0: $file is a ", /^#!\s*(\S+)/, " script, not perl\n");
 511     }
 512
 513 }
 514
 515 # File spawning and error collecting
 516 sub spawnit {
 517         my ($command) = shift;
 518         my (@error,@output);
 519         my $errname;
 520         (undef, $errname) = tempfile("pccXXXXX");
 521         {
 522         open (S_OUT, "$command 2>$errname |")
 523                 or _die("$0: Couldn't spawn the compiler.\n");
 524         @output = <S_OUT>;
 525         }
 526         open (S_ERROR, $errname) or _die("$0: Couldn't read the error file.\n");
 527         @error = <S_ERROR>;
 528         close S_ERROR;
 529         close S_OUT;
 530         unlink $errname or _die("$0: Can't unlink error file $errname");
 531         return (\@output, \@error);
 532 }
 533
 534 sub helpme {
 535        print "perlcc compiler frontend, version $VERSION\n\n";
 536        { no warnings;
 537        exec "pod2usage $0";
 538        exec "perldoc $0";
 539        exec "pod2text $0";
 540        }
 541 }
 542
 543 sub relativize {
 544         my ($args) = @_;
 545
 546         return() if ($args =~ m"^[/\\]");
 547         return("./$args");
 548 }
 549
 550 sub _die {
 551     $logfh->print(@_) if opt('log');
 552     print STDERR @_;
 553     exit(); # should die eventually. However, needed so that a 'make compile'
 554             # can compile all the way through to the end for standard dist.
 555 }
 556
 557 sub _usage_and_die {
 558     _die(<<EOU);
 559 $0: Usage:
 560 $0 [-o executable] [-r] [-O|-B|-c|-S] [-log log] [source[.pl] | -e oneliner]
 561 EOU
 562 }
 563
 564 sub run {
 565     my (@commands) = @_;
 566
 567     print interruptrun(@commands) if (!opt('log'));
 568     $logfh->print(interruptrun(@commands)) if (opt('log'));
 569 }
 570
 571 sub interruptrun
 572 {
 573     my (@commands) = @_;
 574
 575     my $command = join('', @commands);
 576     local(*FD);
 577     my $pid = open(FD, "$command |");
 578     my $text;
 579
 580     local($SIG{HUP}) = sub { kill 9, $pid; exit };
 581     local($SIG{INT}) = sub { kill 9, $pid; exit };
 582
 583     my $needalarm =
 584           ($ENV{PERLCC_TIMEOUT} &&
 585           $Config{'osname'} ne 'MSWin32' &&
 586           $command =~ m"(^|\s)perlcc\s");
 587
 588     eval
 589     {
 590          local($SIG{ALRM}) = sub { die "INFINITE LOOP"; };
 591          alarm($ENV{PERLCC_TIMEOUT}) if ($needalarm);
 592          $text = join('', <FD>);
 593          alarm(0) if ($needalarm);
 594     };
 595
 596     if ($@)
 597     {
 598         eval { kill 'HUP', $pid };
 599         vprint 0, "SYSTEM TIMEOUT (infinite loop?)\n";
 600     }
 601
 602     close(FD);
 603     return($text);
 604 }
 605
 606 sub is_win32() { $^O =~ m/^MSWin/ }
 607 sub is_msvc() { is_win32 && $Config{cc} =~ m/^cl/i }
 608
 609 END {
 610     unlink $cfile if ($cfile && !opt(S) && !opt(c));
 611 }
 612
 613 __END__
 614
 615 =head1 NAME
 616
 617 perlcc - generate executables from Perl programs
 618
 619 =head1 SYNOPSIS
 620
 621     $ perlcc hello              # Compiles into executable 'a.out'
 622     $ perlcc -o hello hello.pl  # Compiles into executable 'hello'
 623
 624     $ perlcc -O file            # Compiles using the optimised C backend
 625     $ perlcc -B file            # Compiles using the bytecode backend
 626
 627     $ perlcc -c file            # Creates a C file, 'file.c'
 628     $ perlcc -S -o hello file   # Creates a C file, 'file.c',
 629                                 # then compiles it to executable 'hello'
 630     $ perlcc -c out.c file      # Creates a C file, 'out.c' from 'file'
 631
 632     $ perlcc -e 'print q//'     # Compiles a one-liner into 'a.out'
 633     $ perlcc -c -e 'print q//'  # Creates a C file 'a.out.c'
 634
 635     $ perlcc -I /foo hello      # extra headers (notice the space after -I)
 636     $ perlcc -L /foo hello      # extra libraries (notice the space after -L)
 637
 638     $ perlcc -r hello           # compiles 'hello' into 'a.out', runs 'a.out'.
 639     $ perlcc -r hello a b c     # compiles 'hello' into 'a.out', runs 'a.out'.
 640                                 # with arguments 'a b c'
 641
 642     $ perlcc hello -log c       # compiles 'hello' into 'a.out' logs compile
 643                                 # log into 'c'.
 644
 645 =head1 DESCRIPTION
 646
 647 F<perlcc> creates standalone executables from Perl programs, using the
 648 code generators provided by the L<B> module. At present, you may
 649 either create executable Perl bytecode, using the C<-B> option, or
 650 generate and compile C files using the standard and 'optimised' C
 651 backends.
 652
 653 The code generated in this way is not guaranteed to work. The whole
 654 codegen suite (C<perlcc> included) should be considered B<very>
 655 experimental. Use for production purposes is strongly discouraged.
 656
 657 =head1 OPTIONS
 658
 659 =over 4
 660
 661 =item -LI<library directories>
 662
 663 Adds the given directories to the library search path when C code is
 664 passed to your C compiler.
 665
 666 =item -II<include directories>
 667
 668 Adds the given directories to the include file search path when C code is
 669 passed to your C compiler; when using the Perl bytecode option, adds the
 670 given directories to Perl's include path.
 671
 672 =item -o I<output file name>
 673
 674 Specifies the file name for the final compiled executable.
 675
 676 =item -c I<C file name>
 677
 678 Create C code only; do not compile to a standalone binary.
 679
 680 =item -e I<perl code>
 681
 682 Compile a one-liner, much the same as C<perl -e '...'>
 683
 684 =item -S
 685
 686 Do not delete generated C code after compilation.
 687
 688 =item -B
 689
 690 Use the Perl bytecode code generator.
 691
 692 =item -O
 693
 694 Use the 'optimised' C code generator. This is more experimental than
 695 everything else put together, and the code created is not guaranteed to
 696 compile in finite time and memory, or indeed, at all.
 697
 698 =item -v
 699
 700 Increase verbosity of output; can be repeated for more verbose output.
 701
 702 =item -r
 703
 704 Run the resulting compiled script after compiling it.
 705
 706 =item -log
 707
 708 Log the output of compiling to a file rather than to stdout.
 709
 710 =back
 711
 712 =cut
 713
 714 !NO!SUBS!
 715
 716 close OUT or die "Can't close $file: $!";
 717 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
 718 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
 719 chdir $origdir;