From: Ed Peschko <epeschko@den-mdev1>
Date: Wed, 29 Apr 1998 21:02:36 +0000 (-0600)
Subject: [ PATCH 5.004_64 ] Integrated regression tests for compiler
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=52cebf5efc9883c776f89be24e988c47ceba2a42;p=p5sagit%2Fp5-mst-13.2.git

[ PATCH 5.004_64 ] Integrated regression tests for compiler

p4raw-id: //depot/perl@963
---

diff --git a/MANIFEST b/MANIFEST
index 3e117e8..c4c816d 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -910,6 +910,7 @@ utils/perlbug.PL	A simple tool to submit a bug report
 utils/perldoc.PL	A simple tool to find & display perl's documentation
 utils/pl2pm.PL		A pl to pm translator
 utils/splain.PL		Stand-alone version of diagnostics.pm
+utils/perlcc.PL		Front-end for compiler
 vms/config.vms		default config.h for VMS
 vms/descrip.mms		MM[SK] description file for build
 vms/ext/DCLsym/0README.txt	ReadMe file for VMS::DCLsym
diff --git a/Makefile.SH b/Makefile.SH
index b9c8cdb..a70b53e 100644
--- a/Makefile.SH
+++ b/Makefile.SH
@@ -233,6 +233,12 @@ lintflags = -hbvxac
 all: $(FIRSTMAKEFILE) miniperl $(private) $(plextract) $(public) $(dynamic_ext)
 	@echo " "; echo "	Everything is up to date."
 
+compile: all
+	echo "testing compilation" > testcompile;
+	cd utils;  $(MAKE) compile;
+	cd x2p; $(MAKE) compile; 
+	cd pod; $(MAKE) compile;
+
 translators:	miniperl lib/Config.pm FORCE
 	@echo " "; echo "	Making x2p stuff"; cd x2p; $(LDLIBPTH) $(MAKE) all
 
@@ -373,6 +379,12 @@ $(plextract):	miniperl lib/Config.pm
 install: all install.perl install.man
 
 install.perl:	all installperl
+	if [ -n "$(COMPILE)" ]; \
+	then \
+		cd utils; $(MAKE) compile; \
+		cd ../x2p; $(MAKE) compile; \
+		cd ../pod; $(MAKE) compile; \
+	fi
 	$(LDLIBPTH) ./perl installperl
 
 install.man:	all installman
@@ -485,6 +497,7 @@ _tidy:
 	-@for x in $(DYNALOADER) $(dynamic_ext) $(static_ext) ; do \
 	sh ext/util/make_ext clean $$x MAKE=$(MAKE) ; \
 	done
+	rm -f testcompile compilelog
 
 # Do not 'make _cleaner' directly.
 _cleaner:
@@ -503,6 +516,7 @@ _cleaner:
 	rm -f lib/.exists
 	rm -f h2ph.man pstruct
 	rm -rf .config
+	rm -f testcompile compilelog
 
 # The following lint has practically everything turned on.  Unfortunately,
 # you have to wade through a lot of mumbo jumbo that can't be suppressed.
diff --git a/installperl b/installperl
index b422018..a8bcd35 100755
--- a/installperl
+++ b/installperl
@@ -38,8 +38,8 @@ while (@ARGV) {
 umask 022 unless $Is_VMS;
 
 @scripts = qw(	utils/c2ph utils/h2ph utils/h2xs
-		utils/perlbug utils/perldoc utils/pl2pm utils/splain
-		x2p/s2p x2p/find2perl
+		utils/perlbug utils/perldoc utils/pl2pm utils/splain utils/perlcc
+		x2p/s2p x2p/find2perl 
 		pod/pod2man pod/pod2html pod/pod2latex pod/pod2text);
 
 if ($Is_VMS) { @scripts = map { "$_.Com" } @scripts; }
@@ -53,6 +53,11 @@ if ($^O eq 'dos') {
     $archpms{config} = $archpms{filehand} = 1;
 }
 
+if ((-e "testcompile") && (defined($ENV{'COMPILE'})))
+{
+	push(@scripts, map("$_.exe", @scripts));
+}
+
 find(sub {
 	if ("$File::Find::dir/$_" =~ m{^ext/[^/]+/(.*)\.pm$}) {
 	    (my $pm = $1) =~ s{^lib/}{};
diff --git a/lib/Test/Harness.pm b/lib/Test/Harness.pm
index 8102ff4..e2c47d6 100644
--- a/lib/Test/Harness.pm
+++ b/lib/Test/Harness.pm
@@ -68,7 +68,9 @@ sub runtests {
 	my $s = $switches;
 	$s .= q[ "-T"] if $first =~ /^#!.*\bperl.*-\w*T/;
 	$fh->close or print "can't close $test. $!\n";
-	my $cmd = "$^X $s $test|";
+	my $cmd = ($ENV{'COMPILE_TEST'})? 
+"./perl -I../lib ../utils/perlcc $test -run -verbose dcf -log ./compilelog |" 
+															:  "$^X $s $test|";
 	$cmd = "MCR $cmd" if $^O eq 'VMS';
 	$fh->open($cmd) or print "can't run $test. $!\n";
 	$ok = $next = $max = 0;
diff --git a/pod/Makefile b/pod/Makefile
index 7eeabd9..e9623a6 100644
--- a/pod/Makefile
+++ b/pod/Makefile
@@ -9,6 +9,7 @@ POD2HTML = pod2html \
 all: $(CONVERTERS) man
 
 PERL = ../miniperl
+REALPERL = ../perl
 
 POD = \
 	perl.pod	\
@@ -240,7 +241,7 @@ toc:
 clean:
 	rm -f $(MAN) $(HTML) $(TEX)
 	rm -f pod2html-*cache
-	rm -f *.aux *.log
+	rm -f *.aux *.log *.exe
 
 realclean:	clean
 	rm -f $(CONVERTERS)
@@ -267,4 +268,7 @@ pod2text:	pod2text.PL ../lib/Config.pm
 checkpods:	checkpods.PL ../lib/Config.pm
 	$(PERL) -I ../lib checkpods.PL
 
+compile: all
+	$(REALPERL) -I../lib ../utils/perlcc -regex 's/$$/.exe/' pod2latex pod2man pod2text checkpods -prog -verbose dcf -log ../compilelog;
 
+	
diff --git a/t/TEST b/t/TEST
index a684b2a..81d5650 100755
--- a/t/TEST
+++ b/t/TEST
@@ -38,12 +38,34 @@ else {
     close(CONFIG);
 }
 
-$bad = 0;
-$good = 0;
-$total = @ARGV;
-$files  = 0;
-$totmax = 0;
-while ($test = shift) {
+%infinite = ( 'comp/require.t', 1, 'op/bop.t', 1, 'lib/hostname.t', 1 ); 
+
+_testprogs('perl', @ARGV);
+_testprogs('compile', @ARGV) if (-e "../testcompile"); 
+
+sub _testprogs
+{
+	$type = shift @_;
+	@tests = @_;
+
+
+	print "
+--------------------------------------------------------------------------------
+TESTING COMPILER
+--------------------------------------------------------------------------------
+" if ($type eq 'compile');
+
+	$bad = 0;
+	$good = 0;
+	$total = @tests;
+	$files  = 0;
+	$totmax = 0;
+while ($test = shift @tests) {
+
+    if ( $infinite{$test} && $type eq 'compile' ) {
+		print STDERR "$test creates infinite loop! Skipping.\n"; 
+        next;
+	}
     if ($test =~ /^$/) {
 	next;
     }
@@ -52,7 +74,14 @@ while ($test = shift) {
     print "$te" . '.' x (18 - length($te));
     if ($sharpbang) {
 	-x $test || (print "isn't executable.\n");
-	open(RESULTS,"./$test |") || (print "can't run.\n");
+
+	if ($type eq 'perl')
+		{ open(RESULTS, "./$test |") || (print "can't run.\n"); }
+	else
+	{ 
+		open(RESULTS, "./perl -I../lib ../utils/perlcc ./$test -run -verbose dcf -log ../compilelog |") 
+											|| (print "can't compile.\n");
+	}
     } else {
 	open(SCRIPT,"$test") || die "Can't run $test.\n";
 	$_ = <SCRIPT>;
@@ -66,7 +95,16 @@ while ($test = shift) {
 	} else {
 	    $switch = '';
 	}
-	open(RESULTS,"./perl$switch $test |") || (print "can't run.\n");
+
+	if ($type eq 'perl')
+	{
+		open(RESULTS,"./perl$switch $test |") || (print "can't run.\n");
+	}
+	else
+	{
+		open(RESULTS, "./perl -I../lib ../utils/perlcc ./$test -run -verbose dcf -log ../compilelog |") 
+											|| (print "can't compile.\n");
+	}
     }
     $ok = 0;
     $next = 0;
@@ -129,16 +167,21 @@ if ($bad == 0) {
    ### Since not all tests were successful, you may want to run some
    ### of them individually and examine any diagnostic messages they
    ### produce.  See the INSTALL document's section on "make test".
+   ### If you are testing the compiler, then ignore this message 
+   ### and run 
+   ###      ./perl harness
+   ### in the directory ./t.
 SHRDLU
        warn <<'SHRDLU' if $good / $total > 0.8;
    ###
    ### Since most tests were successful, you have a good chance to
    ### get information with better granularity by running
-   ###     ./perl harness
+   ###     ./perl harness 
    ### in directory ./t.
 SHRDLU
 }
 ($user,$sys,$cuser,$csys) = times;
 print sprintf("u=%g  s=%g  cu=%g  cs=%g  scripts=%d  tests=%d\n",
     $user,$sys,$cuser,$csys,$files,$totmax);
+}
 exit ($bad != 0);
diff --git a/t/harness b/t/harness
index af92a8b..f6d94de 100644
--- a/t/harness
+++ b/t/harness
@@ -17,4 +17,17 @@ $Test::Harness::verbose = shift if @ARGV && $ARGV[0] eq '-v';
 
 @tests = @ARGV;
 @tests = <base/*.t comp/*.t cmd/*.t io/*.t op/*.t pragma/*.t lib/*.t> unless @tests;
+
 Test::Harness::runtests @tests;
+
+%infinite = ('comp/require.t', 1, 'op/bop.t', 1, 'lib/hostname.t', 1 );
+
+@tests = grep (!$infinite{$_}, @tests);
+
+if (-e "../testcompile") 
+{ 
+	print "The tests ", join(' ', keys(%infinite)), 
+							" generate infinite loops! Skipping!\n";
+
+	$ENV{'COMPILE_TEST'} = 1; Test::Harness::runtests @tests; 
+}
diff --git a/utils/Makefile b/utils/Makefile
index 3c343c8..2df16d8 100644
--- a/utils/Makefile
+++ b/utils/Makefile
@@ -1,13 +1,18 @@
 
 PERL = ../miniperl
+REALPERL = ../perl
 
 # Files to be built with variable substitution after miniperl is
 # available.  Dependencies handled manually below (for now).
 
-pl = c2ph.PL h2ph.PL h2xs.PL perlbug.PL perldoc.PL pl2pm.PL splain.PL
-plextract  = c2ph h2ph h2xs perlbug perldoc pl2pm splain
+pl = c2ph.PL h2ph.PL h2xs.PL perlbug.PL perldoc.PL pl2pm.PL splain.PL perlcc.PL
+plextract  = c2ph h2ph h2xs perlbug perldoc pl2pm splain perlcc
+plextractexe  = c2ph.exe h2ph.exe h2xs.exe perlbug.exe perldoc.exe pl2pm.exe splain.exe perlcc.exe
 
-all: $(plextract)
+all: $(plextract) 
+
+compile: all
+	$(REALPERL) -I../lib perlcc -regex 's/$$/.exe/' $(plextract) -prog -verbose dcf -log ../compilelog;
 
 $(plextract):
 	$(PERL) -I../lib $@.PL
@@ -26,10 +31,12 @@ pl2pm:		pl2pm.PL ../config.sh
 
 splain:		splain.PL ../config.sh ../lib/diagnostics.pm
 
+perlcc:     perlcc.PL ../config.sh
+
 clean:
 
 realclean:
-	rm -rf $(plextract) pstruct
+	rm -rf $(plextract) pstruct $(plextractexe)
 
 clobber:	realclean
 
diff --git a/utils/perlcc.PL b/utils/perlcc.PL
new file mode 100644
index 0000000..af7488f
--- /dev/null
+++ b/utils/perlcc.PL
@@ -0,0 +1,935 @@
+#!/usr/local/bin/perl
+ 
+use Config;
+use File::Basename qw(&basename &dirname);
+ 
+# 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.
+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 Getopt::Long;
+
+$Getopt::Long::bundling_override = 1;
+$Getopt::Long::passthrough = 0;
+$Getopt::Long::ignore_case = 0;
+
+my $options = {};
+my $_fh;
+
+main();
+
+sub main
+{
+
+    GetOptions
+            (
+            $options,   "L:s",
+                        "I:s",
+                        "C:s",
+                        "o:s",
+                        "e:s",
+                        "regex:s",
+                        "verbose:s",
+                        "log:s",
+						"argv:s",
+                        "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);
+
+    if  (
+            (($file =~ m"@$program_ext") && ($file !~ m"@$module_ext"))
+            || (defined($options->{'prog'}) || defined($options->{'run'}))
+        )
+    {
+        $objfile = ($options->{'C'}) ?     $options->{'C'} : "$file.c";
+        $type = 'program';
+
+        $obj =         ($options->{'o'})?     $options->{'o'} : 
+                                            _getExecutable( $file,$program_ext);
+
+        return() if (!$obj);
+
+    }
+    elsif (($file =~ m"@$module_ext") || ($options->{'mod'}))
+    {
+        die "Shared objects are not supported on Win32 yet!!!!\n"
+                                      if ($Config{'osname'} eq 'MSWin32');
+
+        $obj =         ($options->{'o'})?    $options->{'o'} :
+                                            _getExecutable($file, $module_ext);
+        $so = "$obj.so";
+        $type = 'sharedlib';
+        return() if (!$obj);
+    }
+    else
+    {
+        _error("noextension", $file, $program_ext, $module_ext);
+        return();
+    }
+
+    if ($type eq 'program')
+    {
+        _print("Making C($objfile) for $file!\n", 36 );
+
+        my $errcode = _createCode($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'});
+        my $errcode = _compileCode($file, $objfile, $obj) 
+                                            if (!$options->{'gen'});
+
+        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($obj) if ($options->{'run'});
+
+        _removeCode($objfile) if (!$options->{'sav'} || 
+                                    ($options->{'e'} && !$options->{'C'}));
+
+        _removeCode($file) if ($options->{'e'}); 
+
+        _removeCode($obj) if (($options->{'e'} && 
+                                ((!$options->{'sav'}) || !$options->{'o'})) || 
+                                ($options->{'run'} && (!$options->{'sav'})));
+    }
+    else
+    {
+        _print( "Making C($objfile) for $file!\n", 36 );
+        my $errcode = _createCode($objfile, $file, $obj);
+        (_print( "ERROR: In generating code for $file!\n", -1), return()) 
+                                                                if ($errcode);
+    
+        _print( "Compiling C($obj) for $file!\n", 36 ) if (!$options->{'gen'});
+
+        my $errorcode = 
+            _compileCode($file, $objfile, $obj, $so ) if (!$options->{'gen'});
+
+        (_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 ( $generated_cfile, $file, $final_output ) = @_;
+    my $return;
+
+    local($") = " -I";
+
+    if (@_ == 2)                                   # compiling a program   
+    {
+        _print( "$^X -I@INC -MO=CC,-o$generated_cfile $file\n", 36);
+        $return =  _run("$ -I@INC -MO=CC,-o$generated_cfile $file", 9);
+        $return;
+    }
+    else                                           # compiling a shared object
+    {            
+        _print( 
+            "$ -I@INC -MO=CC,-m$final_output,-o$generated_cfile $file\n", 36);
+        $return = 
+        _run("$ -I@INC -MO=CC,-m$final_output,-o$generated_cfile $file", 9);
+        $return;
+    }
+}
+
+sub _compileCode
+{
+    my ($sourceprog, $generated_cfile, $output_executable, $shared_object) = @_;
+    my @return;
+
+    if (@_ == 3)                            # just compiling a program 
+    {
+        $return[0] = 
+        _ccharness($sourceprog, "-o", $output_executable, $generated_cfile);  
+        $return[0];
+    }
+    else
+    {
+        my $object_file = $generated_cfile;
+        $object_file =~ s"\.c$"\.o";   
+
+        $return[0] = _ccharness($sourceprog, "-c", $generated_cfile);
+        $return[1] = _ccharness
+                            (
+                                $sourceprog, "-shared","-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 (@args) = @_;
+    local($") = " ";
+
+    my $sourceprog = shift(@args);
+    my ($libdir, $incdir);
+
+    if (-d "$Config{installarchlib}/CORE")
+    {
+        $libdir = "-L$Config{installarchlib}/CORE";
+        $incdir = "-I$Config{installarchlib}/CORE";
+    }
+    else
+    {
+        $libdir = "-L.."; 
+        $incdir = "-I..";
+    }
+
+    $libdir .= " -L$options->{L}" if (defined($options->{L}));
+    $incdir .= " -I$options->{L}" if (defined($options->{L}));
+
+    my $linkargs;
+
+    if (!grep(/^-[cS]$/, @ARGV))
+    {
+        $linkargs = sprintf("%s $libdir -lperl %s",@Config{qw(ldflags libs)});
+    }
+
+    my @sharedobjects = _getSharedObjects($sourceprog); 
+
+    my $cccmd = 
+        "$Config{cc} $Config{ccflags} $incdir @sharedobjects @args $linkargs";
+
+
+    _print ("$cccmd\n", 36);
+    _run("$cccmd", 18 );
+}
+
+sub _getSharedObjects
+{
+    my ($sourceprog) = @_;
+    my ($tmpfile, $incfile);
+    my (@return);
+    local($") = " -I";
+
+    if ($Config{'osname'} eq 'MSWin32') 
+    { 
+        # _addstuff;    
+    }
+    else
+    {
+        my ($tmpprog);
+        ($tmpprog = $sourceprog) =~ s"(.*)[\/\\](.*)"$2";
+        $tmpfile = "/tmp/$tmpprog.tst";
+        $incfile = "/tmp/$tmpprog.val";
+    }
+
+    my $fd = new FileHandle("> $tmpfile") || die "Couldn't open $tmpfile!\n";
+    my $fd2 = 
+        new FileHandle("$sourceprog") || die "Couldn't open $sourceprog!\n";
+
+    my $perl = <$fd2>;  # strip off header;
+
+    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("$ -I@INC $tmpfile\n", 36);
+    _run("$ -I@INC $tmpfile", 9 );
+
+    my $fd = new FileHandle ("$incfile"); 
+    my @lines = <$fd>;    
+
+    unlink($tmpfile);
+    unlink($incfile);
+
+    my $line;
+    my $autolib;
+
+    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 $relshared;
+    my $return;
+
+    ($relshared = $file) =~ s"(.*)\.pm"$1";
+
+    my ($tmp, $modname) = ($relshared =~ m"(?:(.*)[\\/]){0,1}(.*)"s);
+
+    $relshared .= 
+        ($Config{'osname'} eq 'MSWin32')? "\\$modname.dll" : "/$modname.so";
+    
+
+
+    if (-e ($return = "$Config{'installarchlib'}/auto/$relshared") )
+    {
+        return($return);    
+    }
+    elsif (-e ($return = "$Config{'installsitearch'}/auto/$relshared"))
+    {
+        return($return);
+    }
+    elsif (-e ($return = "$dir/arch/auto/$relshared"))
+    {
+        return($return);    
+    }
+    else
+    {
+        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\x0\\."g, @$regexp);
+    grep(s"(^|[^\x0])\\\."$1\."g,  @$regexp);
+    grep(s"\x0""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->{'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 executable, hence, with more than 
+       one file the names clash)\n");
+    }
+
+    if ($options->{'e'} && $options->{'sav'} && !$options->{'o'} && 
+                                                            !$options->{'C'})
+    {
+        push(@errors, 
+"ERROR: You need to specify where you are going to save the resulting 
+       executable or C code,  when using '-sav' and '-e'. Use '-o' or '-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) 
+            { system("$command"); }
+
+        elsif ($doreg && $dolog) 
+            { my $text = `$command 2>&1`; print $_fh $text; print STDERR $text;}
+        else 
+            { my $text = `$command 2>&1`; print $_fh $text; }
+    }
+    else 
+    {
+        `$command 2>&1`; 
+    }
+    return($?);
+}
+
+sub _usage
+{
+    _print
+    ( 
+    <<"EOF"
+
+Usage: $0 <file_list> 
+
+    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
+        -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 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 -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 '-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 '-run' or '-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 '-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.
+
+=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
+
+perlcc currently cannot compile shared objects on Win32. This should be fixed
+by perl5.005.
+
+=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 ':';
diff --git a/x2p/Makefile.SH b/x2p/Makefile.SH
index bf7495a..30201bd 100755
--- a/x2p/Makefile.SH
+++ b/x2p/Makefile.SH
@@ -61,6 +61,7 @@ FIRSTMAKEFILE = $firstmakefile
 
 cat >>Makefile <<'!NO!SUBS!'
 
+REALPERL = ../perl
 CCCMD = `sh $(shellflags) cflags $@`
 
 public = a2p s2p find2perl
@@ -76,6 +77,8 @@ shextract = Makefile cflags
 
 pl = find2perl.PL s2p.PL
 plextract = find2perl s2p
+plexe = find2perl.exe s2p.exe
+plc   = find2perl.c s2p.c
 
 addedbyconf = $(shextract) $(plextract)
 
@@ -94,6 +97,9 @@ lintflags = -phbvxac
 all: $(public) $(private) $(util)
 	touch all
 
+compile: all
+	$(REALPERL) -I../lib ../utils/perlcc -regex 's/$$/.exe/' $(plextract) -prog -verbose dcf -log ../compilelog;  
+
 a2p: $(obj) a2p$(OBJ_EXT)
 	$(CC) $(LDFLAGS) $(obj) a2p$(OBJ_EXT) $(libs) -o a2p
 
@@ -116,7 +122,7 @@ a2p$(OBJ_EXT): a2p.c a2py.c a2p.h EXTERN.h util.h INTERN.h \
 	$(CCCMD) $(LARGE) a2p.c
 
 clean:
-	rm -f a2p *$(OBJ_EXT)
+	rm -f a2p *$(OBJ_EXT) $(plexe) $(plc)
 
 realclean: clean
 	rm -f *.orig core $(addedbyconf) all malloc.c