[p5sagit/p5-mst-13.2.git] / utils / perlcc.PL

#!/usr/local/bin/perl
 
use Config;
use File::Basename qw(&basename &dirname);
use File::Spec;
use Cwd;
 
# List explicitly here the variables you want Configure to
# generate.  Metaconfig only looks for shell variables, so you
# have to mention them as if they were shell variables, not
# %Config entries.  Thus you write
#  $startperl
# to ensure Configure will look for $Config{startperl}.
# Wanted:  $archlibexp
 
# This forces PL files to create target in same directory as PL file.
# This is so that make depend always knows where to find PL derivatives.
$origdir = cwd;
chdir dirname($0);
$file = basename($0, '.PL');
$file .= '.com' if $^O eq 'VMS';
 
open OUT,">$file" or die "Can't create $file: $!";
 
print "Extracting $file (with variable substitutions)\n";
 
# In this section, perl variables will be expanded during extraction.
# You can use $Config{...} to use Configure variables.
 
print OUT <<"!GROK!THIS!";
$Config{startperl}
    eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
    if \$running_under_some_shell;
!GROK!THIS!
 
# In the following, perl variables are not expanded during extraction.
 
print OUT <<'!NO!SUBS!';

use Config;
use strict;
use FileHandle;
use File::Basename qw(&basename &dirname);
use Cwd;

use Getopt::Long;

$Getopt::Long::bundling_override = 1;
$Getopt::Long::passthrough = 0;
$Getopt::Long::ignore_case = 0;

my $pathsep = ($Config{'osname'} eq 'MSWin32')? "\\" : "/"; # MAJOR HACK. SHOULD
                                                            # BE IN Config.pm

my $options = {};
my $_fh;
unshift @ARGV, split ' ', $ENV{PERLCC_OPTS} if $ENV{PERLCC_OPTS};

main();

sub main
{

    GetOptions
            (
            $options,   "L:s",
                        "I:s",
                        "C:s",
                        "o:s",
                        "e:s",
                        "regex:s",
                        "verbose:s",
                        "log:s",
                        "argv:s",
                        "b",
                        "opt",
                        "gen",
                        "sav",
                        "run",
                        "prog",
                        "mod"
            );


    my $key;

    local($") = "|";

    _usage() if (!_checkopts());
    push(@ARGV, _maketempfile()) if ($options->{'e'});

    _usage() if (!@ARGV);
                
    my $file;
    foreach $file (@ARGV)
    {
        _print("
--------------------------------------------------------------------------------
Compiling $file:
--------------------------------------------------------------------------------
", 36 );
        _doit($file);
    }
}
        
sub _doit
{
    my ($file) = @_;

    my ($program_ext, $module_ext) = _getRegexps();
    my ($obj, $objfile, $so, $type, $backend, $gentype);

    $backend = $options->{'b'} ? 'Bytecode' : $options->{'opt'} ? 'CC' : 'C';

    $gentype = $options->{'b'} ? 'Bytecode' : 'C';

    if  (
            (($file =~ m"@$program_ext") && ($file !~ m"@$module_ext"))
            || (defined($options->{'prog'}) || defined($options->{'run'}))
        )
    {
        $type = 'program';

        if ($options->{'b'})
        {
            $obj = $objfile = $options->{'o'} ? $options->{'o'} : "${file}c";
        }
        else
        {
            $objfile = $options->{'C'} ? $options->{'C'} : "$file.c";
            $obj = $options->{'o'} ? $options->{'o'}
                                   : _getExecutable( $file,$program_ext);
        }

        return() if (!$obj);

    }
    elsif (($file =~ m"@$module_ext") || ($options->{'mod'}))
    {
        $type = 'module';

        if ($options->{'b'})
        {
            $obj = $objfile = $options->{'o'} ? $options->{'o'} : "${file}c";
        }
        else
        {
            die "Shared objects are not supported on Win32 yet!!!!\n"
                                          if ($Config{'osname'} eq 'MSWin32');

            $objfile = $options->{'C'} ? $options->{'C'} : "$file.c";
            $obj = $options->{'o'} ? $options->{'o'}
                                   : _getExecutable($file, $module_ext);
            $so = "$obj.$Config{so}";
        }

        return() if (!$obj);
    }
    else
    {
        _error("noextension", $file, $program_ext, $module_ext);
        return();
    }

    if ($type eq 'program')
    {
        _print("Making $gentype($objfile) for $file!\n", 36 );

        my $errcode = _createCode($backend, $objfile, $file);
        (_print( "ERROR: In generating code for $file!\n", -1), return()) 
                                                                if ($errcode);

        _print("Compiling C($obj) for $file!\n", 36 ) if (!$options->{'gen'} &&
                                                          !$options->{'b'});
        $errcode = _compileCode($file, $objfile, $obj) 
                                            if (!$options->{'gen'} &&
                                                !$options->{'b'});

        if ($errcode)
		{
			_print( "ERROR: In compiling code for $objfile !\n", -1);
			my $ofile = File::Basename::basename($objfile);
			$ofile =~ s"\.c$"\.o"s;
			
			_removeCode("$ofile"); 
			return()
		}
    
        _runCode($objfile) if ($options->{'run'} && $options->{'b'});
        _runCode($obj) if ($options->{'run'} && !$options->{'b'});

        _removeCode($objfile) if (($options->{'b'} &&
                                   ($options->{'e'} && !$options->{'o'})) ||
                                  (!$options->{'b'} &&
                                   (!$options->{'sav'} || 
                                    ($options->{'e'} && !$options->{'C'}))));

        _removeCode($file) if ($options->{'e'}); 

        _removeCode($obj) if (!$options->{'b'} &&
                              (($options->{'e'} &&
			        !$options->{'sav'} && !$options->{'o'}) ||
			       ($options->{'run'} && !$options->{'sav'})));
    }
    else
    {
        _print( "Making $gentype($objfile) for $file!\n", 36 );
        my $errcode = _createCode($backend, $objfile, $file, $obj);
        (_print( "ERROR: In generating code for $file!\n", -1), return()) 
                                                                if ($errcode);
    
        _print( "Compiling C($so) for $file!\n", 36 ) if (!$options->{'gen'} &&
                                                          !$options->{'b'});

        $errcode = 
            _compileCode($file, $objfile, $obj, $so ) if (!$options->{'gen'} &&
                                                          !$options->{'b'});

        (_print( "ERROR: In compiling code for $objfile!\n", -1), return()) 
                                                                if ($errcode);
    }
}

sub _getExecutable
{
    my ($sourceprog, $ext) = @_;
    my ($obj);

    if (defined($options->{'regex'}))
    {
        eval("(\$obj = \$sourceprog) =~ $options->{'regex'}");
        return(0) if (_error('badeval', $@));
        return(0) if (_error('equal', $obj, $sourceprog));
    }
    elsif (defined ($options->{'ext'}))
    {
        ($obj = $sourceprog) =~ s"@$ext"$options->{ext}"g;        
        return(0) if (_error('equal', $obj, $sourceprog));
    }
    elsif (defined ($options->{'run'}))
    {
	    $obj = "perlc$$";
    }
    else
    {
        ($obj = $sourceprog) =~ s"@$ext""g;
        return(0) if (_error('equal', $obj, $sourceprog));
    }
    return($obj);
}

sub _createCode
{
    my ( $backend, $generated_file, $file, $final_output ) = @_;
    my $return;
    my $output_switch = "o";
    my $max_line_len = '';

    local($") = " -I";

    if ($^O eq 'MSWin32' && $backend =~ /^CC?$/ && $Config{cc} =~ /^cl/i) {
	$max_line_len = '-l2000,';
    }

    if ($backend eq "Bytecode")
    {
        require ByteLoader;

	open(GENFILE, "> $generated_file") || die "Can't open $generated_file: $!";
	binmode GENFILE;
        print GENFILE "#!$^X\n" if @_ == 3;
        print GENFILE "use ByteLoader $ByteLoader::VERSION;\n";
	close(GENFILE);

	$output_switch ="a";
    }

    if (@_ == 3)                                   # compiling a program   
    {
        chmod $generated_file, 0777 & ~umask if $backend eq "Bytecode";
	my $null=File::Spec->devnull;
        _print( "$^X -I@INC -MB::Stash -c  $file\n", 36);
        my @stash=`$^X -I@INC -MB::Stash -c  $file 2>$null`;
	my $stash=$stash[-1];
        chomp $stash;

        _print( "$^X -I@INC -MO=$backend,$max_line_len$stash $file\n", 36);
        $return =  _run("$^X -I@INC -MO=$backend,$max_line_len$stash,-$output_switch$generated_file $file", 9);
        $return;
    }
    else                                           # compiling a shared object
    {            
        _print( 
            "$^X -I@INC -MO=$backend,$max_line_len-m$final_output $file\n", 36);
        $return = 
        _run("$^X -I@INC -MO=$backend,$max_line_len-m$final_output,-$output_switch$generated_file $file  ", 9);
        $return;
    }
}

sub _compileCode
{
    my ($sourceprog, $generated_cfile, $output_executable, $shared_object) = @_;
    my @return;

    if (@_ == 3)                            # just compiling a program 
    {
        $return[0] = 
        _ccharness('static', $sourceprog, "-o", $output_executable,
		   $generated_cfile);  
        $return[0];
    }
    else
    {
        my $object_file = $generated_cfile;
        $object_file =~ s"\.c$"$Config{_o}";   

        $return[0] = _ccharness('compile', $sourceprog, "-c", $generated_cfile);
        $return[1] = _ccharness
                            (
                                'dynamic', 
                                $sourceprog, "-o", 
                                $shared_object, $object_file 
                            );
        return(1) if (grep ($_, @return));
        return(0);
    }
}

sub _runCode
{
    my ($executable) = @_;
    _print("$executable $options->{'argv'}\n", 36);
    _run("$executable $options->{'argv'}", -1 );
}

sub _removeCode
{
    my ($file) = @_;
    unlink($file) if (-e $file);
}

sub _ccharness
{
    my $type = shift;
    my (@args) = @_;
    local($") = " ";

    my $sourceprog = shift(@args);
    my ($libdir, $incdir);

    my $L = '-L';
    $L = '-libpath:' if $^O eq 'MSWin32' && $Config{cc} =~ /^cl/i;

    if (-d "$Config{installarchlib}/CORE")
    {
        $libdir = "$L$Config{installarchlib}/CORE";
        $incdir = "-I$Config{installarchlib}/CORE";
    }
    else
    {
        $libdir = "$L.. $L."; 
        $incdir = "-I.. -I.";
    }

    $libdir .= " $L$options->{L}" if (defined($options->{L}));
    $incdir .= " -I$options->{L}" if (defined($options->{L}));

    my $linkargs = '';
    my $dynaloader = '';
    my $optimize = '';
    my $flags = '';

    if (!grep(/^-[cS]$/, @args))
    {
	my $lperl = $^O eq 'os2' ? '-llibperl' 
	   : $^O eq 'MSWin32' ? "$Config{archlibexp}\\CORE\\$Config{libperl}"
	   : '-lperl';
       ($lperl = $Config{libperl}) =~ s/lib(.*)\Q$Config{_a}\E/-l$1/
	    if($^O eq 'cygwin');

	$optimize = $Config{'optimize'} =~ /-O\d/ ? '' : $Config{'optimize'};

	$flags = $type eq 'dynamic' ? $Config{lddlflags} : $Config{ldflags};
	$linkargs = "$flags $libdir $lperl @Config{libs}";
	$linkargs = "/link $linkargs" if $^O eq 'MSWin32' && $Config{cc} =~ /^cl/i;
    }

    my $libs = _getSharedObjects($sourceprog);
    @$libs = grep { !(/DynaLoader\.a$/ && ($dynaloader = $_)) } @$libs
	if($^O eq 'cygwin');

    my $args = "@args";
    if ($^O eq 'MSWin32' && $Config{cc} =~ /^bcc/i) {
        # BC++ cmd line syntax does not allow space between -[oexz...] and arg
        $args =~ s/(^|\s+)-([oe])\s+/$1-$2/g;
    }

    my $ccflags = $Config{ccflags};
    $ccflags .= ' -DUSEIMPORTLIB' if $^O eq 'cygwin';
    my $cccmd = "$Config{cc} $ccflags $optimize $incdir "
		."$args $dynaloader $linkargs @$libs";

    _print ("$cccmd\n", 36);
    _run("$cccmd", 18 );
}

sub _getSharedObjects
{
    my ($sourceprog) = @_;
    my ($tmpfile, $incfile);
    my (@sharedobjects, @libraries);
    local($") = " -I";

    my ($tmpprog);
    ($tmpprog = $sourceprog) =~ s"(.*)[\\/](.*)"$2";

    my $tempdir= File::Spec->tmpdir;

    $tmpfile = "$tempdir/$tmpprog.tst";
    $incfile = "$tempdir/$tmpprog.val";

    my $fd = new FileHandle("> $tmpfile") || die "Couldn't open $tmpfile!\n";
    my $fd2 = 
        new FileHandle("$sourceprog") || die "Couldn't open $sourceprog!\n";

    print $fd <<"EOF";
        use FileHandle;
        my \$fh3  = new FileHandle("> $incfile") 
                                        || die "Couldn't open $incfile\\n";

        my \$key;
        foreach \$key (keys(\%INC)) { print \$fh3 "\$key:\$INC{\$key}\\n"; }
        close(\$fh3);
        exit();
EOF

    print $fd (   <$fd2>    );
    close($fd);

    _print("$^X -I@INC $tmpfile\n", 36);
    _run("$^X -I@INC $tmpfile", 9 );

    $fd = new FileHandle ("$incfile"); 
    my @lines = <$fd>;    

    unlink($tmpfile);
    unlink($incfile);

    my $line;
    my $autolib;

    my @return;

    foreach $line (@lines) 
    {
        chomp($line);

        my ($modname, $modpath) = split(':', $line);
        my ($dir, $file) = ($modpath=~ m"(.*)[\\/]($modname)");

        if ($autolib = _lookforAuto($dir, $file)) { push(@return, $autolib); }
    }
    return(\@return);
}

sub _maketempfile
{
    my $return;

#    if ($Config{'osname'} eq 'MSWin32') 
#            { $return = "C:\\TEMP\\comp$$.p"; }
#    else
#            { $return = "/tmp/comp$$.p"; }

    $return = "comp$$.p"; 

    my $fd = new FileHandle( "> $return") || die "Couldn't open $return!\n";
    print $fd $options->{'e'};
    close($fd);

    return($return);
}
    
    
sub _lookforAuto
{
    my ($dir, $file) = @_;    

    my ($relabs, $relshared);
    my ($prefix);
    my $return;
    my $sharedextension = $^O =~ /MSWin32|cygwin|os2/i
			  ? $Config{_a} : ".$Config{so}";
    ($prefix = $file) =~ s"(.*)\.pm"$1";

    my ($tmp, $modname) = ($prefix =~ m"(?:(.*)[\\/]){0,1}(.*)"s);

    $relshared = "$pathsep$prefix$pathsep$modname$sharedextension";
    $relabs    = "$pathsep$prefix$pathsep$modname$Config{_a}";
                                               # HACK . WHY DOES _a HAVE A '.'
                                               # AND so HAVE NONE??

    my @searchpaths =   map("$_${pathsep}auto", @INC);
    
    my $path;
    foreach $path (@searchpaths)
    {
        if (-e ($return = "$path$relshared")) { return($return); } 
        if (-e ($return = "$path$relabs"))    { return($return); }
    }
   return(undef);
}

sub _getRegexps    # make the appropriate regexps for making executables, 
{                  # shared libs

    my ($program_ext, $module_ext) = ([],[]); 


    @$program_ext = ($ENV{PERL_SCRIPT_EXT})? split(':', $ENV{PERL_SCRIPT_EXT}) :
                                            ('.p$', '.pl$', '.bat$');


    @$module_ext  = ($ENV{PERL_MODULE_EXT})? split(':', $ENV{PERL_MODULE_EXT}) :
                                            ('.pm$');

    _mungeRegexp( $program_ext );
    _mungeRegexp( $module_ext  );    

    return($program_ext, $module_ext);
}

sub _mungeRegexp
{
    my ($regexp) = @_;

    grep(s:(^|[^\\])\.:$1\x00\\.:g, @$regexp);
    grep(s:(^|[^\x00])\\\.:$1\.:g,  @$regexp);
    grep(s:\x00::g,                 @$regexp);
}

sub _error
{
    my ($type, @args) = @_;

    if ($type eq 'equal')
    {
            
        if ($args[0] eq $args[1])
        {
            _print ("ERROR: The object file '$args[0]' does not generate a legitimate executable file! Skipping!\n", -1);
            return(1);
        }
    }
    elsif ($type eq 'badeval')
    {
        if ($args[0])
        {
            _print ("ERROR: $args[0]\n", -1);
            return(1);
        }
    }
    elsif ($type eq 'noextension')
    {
        my $progext = join(',', @{$args[1]});
        my $modext  = join(',', @{$args[2]});

        $progext =~ s"\\""g;
        $modext  =~ s"\\""g;

        $progext =~ s"\$""g;
        $modext  =~ s"\$""g;

        _print 
        (
"
ERROR: '$args[0]' does not have a proper extension! Proper extensions are:

    PROGRAM:       $progext 
    SHARED OBJECT: $modext

Use the '-prog' flag to force your files to be interpreted as programs.
Use the '-mod' flag to force your files to be interpreted as modules.
", -1
        );
        return(1);
    }

    return(0);
}

sub _checkopts
{
    my @errors;
    local($") = "\n";

    if ($options->{'log'})
    {
        $_fh = new FileHandle(">> $options->{'log'}") || push(@errors, "ERROR: Couldn't open $options->{'log'}\n");
    }

    if ($options->{'b'} && $options->{'c'})
    {
        push(@errors,
"ERROR: The '-b' and '-c' options are incompatible. The '-c' option specifies
       a name for the intermediate C code but '-b' generates byte code
       directly.\n");
    }
    if ($options->{'b'} && ($options->{'sav'} || $options->{'gen'}))
    {
        push(@errors,
"ERROR: The '-sav' and '-gen' options are incompatible with the '-b' option.
       They ask for intermediate C code to be saved by '-b' generates byte
       code directly.\n");
    }

    if (($options->{'c'}) && (@ARGV > 1) && ($options->{'sav'} ))
    {
        push(@errors, 
"ERROR: The '-sav' and '-C' options are incompatible when you have more than 
       one input file! ('-C' explicitly names resulting C code, '-sav' saves it,
       and hence, with more than one file, the c code will be overwritten for 
       each file that you compile)\n");
    }
    if (($options->{'o'}) && (@ARGV > 1))
    {
        push(@errors, 
"ERROR: The '-o' option is incompatible when you have more than one input 
       file! (-o explicitly names the resulting file, hence, with more than 
       one file the names clash)\n");
    }

    if ($options->{'e'} && ($options->{'sav'} || $options->{'gen'}) &&
                                                            !$options->{'C'})
    {
        push(@errors, 
"ERROR: You need to specify where you are going to save the resulting 
       C code when using '-sav' and '-e'. Use '-C'.\n");
    }

    if (($options->{'regex'} || $options->{'run'} || $options->{'o'}) 
                                                    && $options->{'gen'})
    {
        push(@errors, 
"ERROR: The options '-regex', '-run', and '-o' are incompatible with '-gen'. 
       '-gen' says to stop at C generation, and the other three modify the 
       compilation and/or running process!\n");
    }

    if ($options->{'run'} && $options->{'mod'})
    {
        push(@errors, 
"ERROR: Can't run modules that you are compiling! '-run' and '-mod' are 
       incompatible!\n"); 
    }

    if ($options->{'e'} && @ARGV)
    {
        push (@errors, 
"ERROR: The option '-e' needs to be all by itself without any other 
       file arguments!\n");
    }
    if ($options->{'e'} && !($options->{'o'} || $options->{'run'}))
    {
        $options->{'run'} = 1;
    }

    if (!defined($options->{'verbose'})) 
    { 
        $options->{'verbose'} = ($options->{'log'})? 64 : 7; 
    }

    my $verbose_error;

    if ($options->{'verbose'} =~ m"[^tagfcd]" && 
            !( $options->{'verbose'} eq '0' || 
                ($options->{'verbose'} < 64 && $options->{'verbose'} > 0)))
    {
        $verbose_error = 1;
        push(@errors, 
"ERROR: Illegal verbosity level.  Needs to have either the letters 
       't','a','g','f','c', or 'd' in it or be between 0 and 63, inclusive.\n");
    }

    $options->{'verbose'} = ($options->{'verbose'} =~ m"[tagfcd]")? 
                            ($options->{'verbose'} =~ m"d") * 32 +     
                            ($options->{'verbose'} =~ m"c") * 16 +     
                            ($options->{'verbose'} =~ m"f") * 8     +     
                            ($options->{'verbose'} =~ m"t") * 4     +     
                            ($options->{'verbose'} =~ m"a") * 2     +     
                            ($options->{'verbose'} =~ m"g") * 1     
                                                    : $options->{'verbose'};

    if     (!$verbose_error && (    $options->{'log'} && 
                                !(
                                    ($options->{'verbose'} & 8)   || 
                                    ($options->{'verbose'} & 16)  || 
                                    ($options->{'verbose'} & 32 ) 
                                )
                            )
        )
    {
        push(@errors, 
"ERROR: The verbosity level '$options->{'verbose'}' does not output anything 
       to a logfile, and you specified '-log'!\n");
    } # }

    if     (!$verbose_error && (    !$options->{'log'} && 
                                (
                                    ($options->{'verbose'} & 8)   || 
                                    ($options->{'verbose'} & 16)  || 
                                    ($options->{'verbose'} & 32)  || 
                                    ($options->{'verbose'} & 64)
                                )
                            )
        )
    {
        push(@errors, 
"ERROR: The verbosity level '$options->{'verbose'}' requires that you also 
       specify a logfile via '-log'\n");
    } # }


    (_print( "\n". join("\n", @errors), -1), return(0)) if (@errors);
    return(1);
}

sub _print
{
    my ($text, $flag ) = @_;
    
    my $logflag = int($flag/8) * 8;
    my $regflag = $flag % 8;

    if ($flag == -1 || ($flag & $options->{'verbose'}))
    {
        my $dolog = ((($logflag & $options->{'verbose'}) || $flag == -1) 
                                                        && $options->{'log'}); 

        my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
        
        if ($doreg) { print( STDERR $text ); }
        if ($dolog) { print $_fh $text; }
    }
}

sub _run
{
    my ($command, $flag) = @_;

    my $logflag = ($flag != -1)? int($flag/8) * 8 : 0;
    my $regflag = $flag % 8;

    if ($flag == -1 || ($flag & $options->{'verbose'}))
    {
        my $dolog = ($logflag & $options->{'verbose'} && $options->{'log'});
        my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);

        if ($doreg && !$dolog) 
        {
	    print _interruptrun("$command");
	}
        elsif ($doreg && $dolog) 
        { 
	    my $text = _interruptrun($command); 
	    print $_fh $text; 
	    print STDERR $text;
	}
        else 
        { 
	    my $text = _interruptrun($command);
	    print $_fh $text; 
	}
    }
    else 
    {
	_interruptrun($command);
    }
    return($?);
}

sub _interruptrun
{
    my ($command) = @_;
    my $pid = open (FD, "$command  |");

    local($SIG{HUP}) = sub { 
#	kill 9, $pid + 1;  
#	HACK... 2>&1 doesn't propogate
#	kill, comment out for quick and dirty
#	process killing of child.

	kill 9, $pid;  
	exit(); 
    };
    local($SIG{INT}) = sub { 
#	kill 9, $pid + 1;  
#	HACK... 2>&1 doesn't propogate
#	kill, comment out for quick and dirty
#	process killing of child.
	kill 9, $pid; 
	exit(); 
    }; 

    my $needalarm = 
            ($ENV{'PERLCC_TIMEOUT'} && 
                    $Config{'osname'} ne 'MSWin32' && $command =~ m"^perlc");
    my $text;

    eval
    {
        local($SIG{ALRM}) = sub { die "INFINITE LOOP"; };
        alarm($ENV{'PERLCC_TIMEOUT'}) if ($needalarm);
        $text = join('', <FD>); 
        alarm(0) if ($needalarm);
    };

    if ($@) 
    { 
        eval { kill 'HUP', $pid; };
        _print("SYSTEM TIMEOUT (infinite loop?)\n", 36); 
    }
        
    close(FD);
    return($text);
}

sub _usage
{
    _print
    ( 
    <<"EOF"

Usage: $0 <file_list> 

WARNING: The whole compiler suite ('perlcc' included) is considered VERY
experimental.  Use for production purposes is strongly discouraged.

    Flags with arguments
        -L       < extra library dirs for installation (form of 'dir1:dir2') >
        -I       < extra include dirs for installation (form of 'dir1:dir2') >
        -C       < explicit name of resulting C code > 
        -o       < explicit name of resulting executable >
        -e       < to compile 'one liners'. Need executable name (-o) or '-run'>
        -regex   < rename regex, -regex 's/\.p/\.exe/' compiles a.p to a.exe >
        -verbose < verbose level < 1-63, or following letters 'gatfcd' >
        -argv    < arguments for the executables to be run via '-run' or '-e' > 

    Boolean flags
        -b       ( to generate byte code )
        -opt     ( to generated optimised C code. May not work in some cases. )
        -gen     ( to just generate the C code. Implies '-sav' )
        -sav     ( to save intermediate C code, (and executables with '-run'))
        -run     ( to run the compiled program on the fly, as were interpreted.)
        -prog    ( to indicate that the files on command line are programs )
        -mod     ( to indicate that the files on command line are modules  )

EOF
, -1

    );
    exit(255);
}


__END__

=head1 NAME

perlcc - frontend for perl compiler

=head1 SYNOPSIS

    %prompt  perlcc a.p        # compiles into executable 'a'

    %prompt  perlcc A.pm       # compile into 'A.so'

    %prompt  perlcc a.p -o execute  # compiles 'a.p' into 'execute'.

    %prompt  perlcc a.p -o execute -run # compiles 'a.p' into execute, runs on
                                        # the fly

    %prompt  perlcc a.p -o execute -run -argv 'arg1 arg2 arg3' 
                                        # compiles into execute, runs with 
                                        # arg1 arg2 arg3 as @ARGV

    %prompt perlcc a.p b.p c.p -regex 's/\.p/\.exe'
                                        # compiles into 'a.exe','b.exe','c.exe'.

    %prompt perlcc a.p -log compilelog  # compiles into 'a', saves compilation
                                        # info into compilelog, as well
                                        # as mirroring to screen

    %prompt perlcc a.p -log compilelog -verbose cdf 
                                        # compiles into 'a', saves compilation
                                        # info into compilelog, being silent
                                        # on screen.

    %prompt perlcc a.p -C a.c -gen      # generates C code (into a.c) and 
                                        # stops without compile.

    %prompt perlcc a.p -L ../lib a.c 
                                        # Compiles with the perl libraries 
                                        # inside ../lib included.

=head1 DESCRIPTION

'perlcc' is the frontend into the perl compiler. Typing 'perlcc a.p'
compiles the code inside a.p into a standalone executable, and 
perlcc A.pm will compile into a shared object, A.so, suitable for inclusion 
into a perl program via "use A".

There are quite a few flags to perlcc which help with such issues as compiling 
programs in bulk, testing compiled programs for compatibility with the 
interpreter, and controlling.

=head1 OPTIONS 

=over 4

=item -L < library_directories >

Adds directories in B<library_directories> to the compilation command.

=item -I  < include_directories > 

Adds directories inside B<include_directories> to the compilation command.

=item -C   < c_code_name > 

Explicitly gives the name B<c_code_name> to the generated file containing
the C code which is to be compiled. Can only be used if compiling one file
on the command line.

=item -o   < executable_name >

Explicitly gives the name B<executable_name> to the executable which is to be
compiled. Can only be used if compiling one file on the command line.

=item -e   < perl_line_to_execute>

Compiles 'one liners', in the same way that B<perl -e> runs text strings at 
the command line. Default is to have the 'one liner' be compiled, and run all
in one go (see B<-run>); giving the B<-o> flag saves the resultant executable, 
rather than throwing it away. Use '-argv' to pass arguments to the executable
created.

=item -b

Generates bytecode instead of C code.

=item -opt

Uses the optimized C backend (C<B::CC>)rather than the simple C backend
(C<B::C>).  Beware that the optimized C backend creates very large
switch structures and structure initializations.  Many C compilers
find it a challenge to compile the resulting output in finite amounts
of time.  Many Perl features such as C<goto LABEL> are also not
supported by the optimized C backend.  The simple C backend should
work in more instances, but can only offer modest speed increases.

=item -regex   <rename_regex>

Gives a rule B<rename_regex> - which is a legal perl regular expression - to 
create executable file names.

=item -verbose <verbose_level>

Show exactly what steps perlcc is taking to compile your code. You can
change the verbosity level B<verbose_level> much in the same way that
the C<-D> switch changes perl's debugging level, by giving either a
number which is the sum of bits you want or a list of letters
representing what you wish to see. Here are the verbosity levels so
far :

    Bit 1(g):      Code Generation Errors to STDERR
    Bit 2(a):      Compilation Errors to STDERR
    Bit 4(t):      Descriptive text to STDERR 
    Bit 8(f):      Code Generation Errors to file (B<-log> flag needed)
    Bit 16(c):     Compilation Errors to file (B<-log> flag needed)
    Bit 32(d):     Descriptive text to file (B<-log> flag needed) 

If the B<-log> tag is given, the default verbose level is 63 (ie: mirroring 
all of perlcc's output to both the screen and to a log file). If no B<-log>
tag is given, then the default verbose level is 7 (ie: outputting all of 
perlcc's output to STDERR).

NOTE: Because of buffering concerns, you CANNOT shadow the output of '-run' to
both a file, and to the screen! Suggestions are welcome on how to overcome this
difficulty, but for now it simply does not work properly, and hence will only go
to the screen.

=item -log <logname>

Opens, for append, a logfile to save some or all of the text for a given 
compile command. No rewrite version is available, so this needs to be done 
manually.

=item -argv <arguments>

In combination with C<-run> or C<-e>, tells perlcc to run the resulting 
executable with the string B<arguments> as @ARGV.

=item -sav

Tells perl to save the intermediate C code. Usually, this C code is the name
of the perl code, plus '.c'; 'perlcode.p' gets generated in 'perlcode.p.c',
for example. If used with the C<-e> operator, you need to tell perlcc where to 
save resulting executables.

=item -gen

Tells perlcc to only create the intermediate C code, and not compile the 
results. Does an implicit B<-sav>, saving the C code rather than deleting it.

=item -run

Immediately run the perl code that has been generated. NOTE: IF YOU GIVE THE 
B<-run> FLAG TO B<perlcc>, THEN THE REST OF @ARGV WILL BE INTERPRETED AS 
ARGUMENTS TO THE PROGRAM THAT YOU ARE COMPILING.

=item -prog

Indicate that the programs at the command line are programs, and should be
compiled as such. B<perlcc> will automatically determine files to be 
programs if they have B<.p>, B<.pl>, B<.bat> extensions.

=item -mod

Indicate that the programs at the command line are modules, and should be
compiled as such. B<perlcc> will automatically determine files to be 
modules if they have the extension B<.pm>.

=back

=head1 ENVIRONMENT

Most of the work of B<perlcc> is done at the command line. However, you can 
change the heuristic which determines what is a module and what is a program.
As indicated above, B<perlcc> assumes that the extensions:

.p$, .pl$, and .bat$

indicate a perl program, and:

.pm$

indicate a library, for the purposes of creating executables. And furthermore,
by default, these extensions will be replaced (and dropped) in the process of 
creating an executable. 

To change the extensions which are programs, and which are modules, set the
environmental variables:

PERL_SCRIPT_EXT
PERL_MODULE_EXT

These two environmental variables take colon-separated, legal perl regular 
expressions, and are used by perlcc to decide which objects are which. 
For example:

setenv PERL_SCRIPT_EXT  '.prl$:.perl$'
prompt%   perlcc sample.perl

will compile the script 'sample.perl' into the executable 'sample', and

setenv PERL_MODULE_EXT  '.perlmod$:.perlmodule$'

prompt%   perlcc sample.perlmod

will  compile the module 'sample.perlmod' into the shared object 
'sample.so'

NOTE: the '.' in the regular expressions for PERL_SCRIPT_EXT and PERL_MODULE_EXT
is a literal '.', and not a wild-card. To get a true wild-card, you need to 
backslash the '.'; as in:

setenv PERL_SCRIPT_EXT '\.\.\.\.\.'

which would have the effect of compiling ANYTHING (except what is in 
PERL_MODULE_EXT) into an executable with 5 less characters in its name.

The PERLCC_OPTS environment variable can be set to the default flags
that must be used by the compiler.

The PERLCC_TIMEOUT environment variable can be set to the number of
seconds to wait for the backends before giving up.  This is sometimes
necessary to avoid some compilers taking forever to compile the
generated output.  May not work on Windows and similar platforms.

=head1 FILES

'perlcc' uses a temporary file when you use the B<-e> option to evaluate 
text and compile it. This temporary file is 'perlc$$.p'. The temporary C code is
perlc$$.p.c, and the temporary executable is perlc$$.

When you use '-run' and don't save your executable, the temporary executable is
perlc$$

=head1 BUGS

The whole compiler suite (C<perlcc> included) should be considered very
experimental.  Use for production purposes is strongly discouraged.

perlcc currently cannot compile shared objects on Win32. This should be fixed
in future.

Bugs in the various compiler backends still exist, and are perhaps too
numerous to list here.

=cut

!NO!SUBS!

close OUT or die "Can't close $file: $!";
chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
chdir $origdir;