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