#!/usr/bin/env perl
# www.mindstab.net/primes
# Run prime number finders 
# haplo@mindstab.net

print "Mindstab Development Multi-language Prime Number Project v1.02\n(www.mindstab.net/tag/primes/)\nhaplo\@mindstab.net\n\n";

# results file
$RESULTS="results.txt";
$TIME="time -p";
$os = `uname`;

$debug=0;

@langs = ("cgcc", "cclang",
#	Uncomment for alternat C algorithms      	
#	"c2", "ca", "ca2", "ca3", 
	"objc", "cpp",  "asm", "for", "pas", "go", "rs", "ada", "hs", "e", "cbl", "oml", "java", "scala", "cs", "vb", "erl", "awk", "pl", "php", "py", "tcl", "rb", "dart", "cl", "scm", "st", "sml", "4th", "pro", "m3", "pike", "lua", "rexx", "r", "fe", "5c", "m4", "sh");

$llen = $#langs+1;

print "Number of iterations to run tests [3]: ";
$itr = <stdin>;
chomp($itr);
print "\n";
if($itr < 1) { $itr = 3; }

print "Maximun number to search to [1000000]: ";
$max = <stdin>;
chomp($max);
print "\n";
if($max < 1) { $max = 1000000; }

#sources

$data{'cgcc'}{'name'} = "C (gcc)";
$data{'cgcc'}{'src'}= "primes.c";
$data{'cgcc'}{'prog'} = "primesgcc";
$data{'cgcc'}{'compiler0'} = "gcc";
$data{'cgcc'}{'cflags0'} = "-lm -O3 -o " . $data{'cgcc'}{'prog'};

$data{'cclang'}{'name'} = "C (clang)";
$data{'cclang'}{'src'}= "primes.c";
$data{'cclang'}{'prog'} = "primesclang";
$data{'cclang'}{'compiler0'} = "clang";
$data{'cclang'}{'cflags0'} = "-lm -O3 -o " . $data{'cclang'}{'prog'};

$data{'c2'}{'name'} = "C Sieve";
$data{'c2'}{'src'}= "primes.sieve.c";
$data{'c2'}{'prog'} = "primescsieve";
$data{'c2'}{'compiler0'} = "gcc";
$data{'c2'}{'cflags0'} = "-lm -O3 -o " . $data{'c2'}{'prog'};

$data{'ca'}{'name'} = "C Alternate Algorithm (Variable sqrt monitoring)";
$data{'ca'}{'src'}= "primes.alt.c";
$data{'ca'}{'prog'} = "primesaltc";
$data{'ca'}{'compiler0'} = "gcc";
$data{'ca'}{'cflags0'} = "-lm -O3 -o " . $data{'ca'}{'prog'};

$data{'ca2'}{'name'} = "C Alternate2 Algorithm (Variable sqrt monitoring and c math modulus)";
$data{'ca2'}{'src'}= "primes.alt2.c";
$data{'ca2'}{'prog'} = "primesalt2c";
$data{'ca2'}{'compiler0'} = "gcc";
$data{'ca2'}{'cflags0'} = "-lm -O3 -o " . $data{'ca2'}{'prog'};

$data{'ca3'}{'name'} = "C Alternate3 Algorithm (Variable sqrt monitoring and recursion)";
$data{'ca3'}{'src'}= "primes.alt3.c";
$data{'ca3'}{'prog'} = "primesalt3c";
$data{'ca3'}{'compiler0'} = "gcc";
$data{'ca3'}{'cflags0'} = "-lm -O3 -o " . $data{'ca3'}{'prog'};


$data{'asm'}{'name'} = "x86 Assembly";
$data{'asm'}{'src'} = "primes.x86.s";
$data{'asm'}{'prog'} = "primesasm";
$data{'asm'}{'compiler0'} = "gcc";
$data{'asm'}{'cflags0'} = "-O3 -o ". $data{'asm'}{'prog'};
$data{'asm'}{'pre'} = "echo \"$max\" | ";
$data{'asm'}{'osfilter'} = "OpenBSD";

$data{'objc'}{'name'} = "Objective C";
$data{'objc'}{'src'}= "primes.m";
$data{'objc'}{'compiler0'} = "gcc";
$data{'objc'}{'prog'} = "primesobjc";
$data{'objc'}{'cflags0'} = "-lobjc -lm -O3 -o " . $data{'objc'}{'prog'};
$data{'objc'}{'osfilter'} = "FreeBSD";

$data{'cpp'}{'name'} = "C++";
$data{'cpp'}{'src'}= "primes.cpp";
$data{'cpp'}{'compiler0'} = "g++";
$data{'cpp'}{'prog'} = "primescpp";
$data{'cpp'}{'cflags0'} = "-lm -O3 -o " . $data{'cpp'}{'prog'};

$data{'for'}{'name'} = "Fortran";
$data{'for'}{'src'} = "primes.f";
$data{'for'}{'compiler0'} = "gfortran";
$data{'for'}{'prog'} = "primesfor";
$data{'for'}{'cflags0'} = "-O3 -o $data{'for'}{'prog'}";

$data{'pas'}{'name'} = "Pascal";
$data{'pas'}{'src'} = "primes.pas";
$data{'pas'}{'compiler0'} = "fpc";
$data{'pas'}{'prog'} = "primespas";
$data{'pas'}{'cflags0'} = "-o$data{'pas'}{'prog'}";

$data{'ada'}{'name'} = "Ada";
$data{'ada'}{'src'} = "primes.adb";
$data{'ada'}{'compiler0'} = "gnatmake";
$data{'ada'}{'prog'} = "primesada";
$data{'ada'}{'cflags0'} = "-o $data{'ada'}{'prog'}";
$data{'ada'}{'cflagspre0'}  = "rm -f primes.ali primes.o && ";

$data{'e'}{'name'} = "Eiffel";
$data{'e'}{'src'}= "primes.e";
$data{'e'}{'compiler0'} = "compile_to_c";
$data{'e'}{'prog'} = "primese";
$data{'e'}{'cflags0'} = "$data{'e'}{'src'} -boost -O3 -o " . $data{'e'}{'prog'}. " && sh primes.make";
$data{'e'}{'cflagspre0'} = "rm -f primes1.o && ";

$data{'awk'}{'name'} = "AWK";
$data{'awk'}{'src'} = "primes.awk";
$data{'awk'}{'pre0'} = "echo $max | ";
$data{'awk'}{'interp0'} = "awk";
$data{'awk'}{'iflags0'} = "-f " . $data{'awk'}{'src'};

$data{'go'}{'name'} = "Go";
$data{'go'}{'src'} = "primes.go";
$data{'go'}{'compiler0'} = 'go';
$data{'go'}{'cflags0'} = 'build -o primesgo ';
$data{'go'}{'prog'} = 'primesgo';

$data{'rs'}{'name'} = "Rust";
$data{'rs'}{'src'} = "primes.rs";
$data{'rs'}{'compiler0'} = 'rustc';
$data{'rs'}{'cflags0'} = ' -o primesrs ';
$data{'rs'}{'prog'} = 'primesrs';

$data{'sml'}{'name'} = "SML";
$data{'sml'}{'src'} = "primes.sml";
#$data{'sml'}{'iflagspre0'} = "echo primes $max | ";
$data{'sml'}{'iflagspre0'} = "cat $data{'sml'}{'src'} | sed -e 's/.*autotest.*/primes $max/' |";
$data{'sml'}{'interp0'} = "sml";
$data{'sml'}{'filter0'} = "sed -e '/[a-zA-Z\\-\\=]/g'";

$data{'m4'}{'name'} = "M4";
$data{'m4'}{'src'} = "primes.m4";
$data{'m4'}{'iflagspre0'} = "cat $data{'m4'}{'src'} | sed -e 's/.*autotest.*/PRIMES(3,$max,2,4)/' |";
$data{'m4'}{'interp0'} = "m4";
$data{'m4'}{'noarg'} = 1;
$data{'m4'}{'warn'} = "Execution is approximately 20-30 times slower than perl.";
$data{'m4'}{'reprompt'} = 1;

$data{'rexx'}{'name'} = "REXX";
$data{'rexx'}{'interp0'} = "rexx";
$data{'rexx'}{'prog'} = "primes.rexx";

$data{'r'}{'name'} = "REBOL";
$data{'r'}{'src'} = "primes.r";
$data{'r'}{'interp0'} = "rebol";
$data{'r'}{'iflags0'} = "--quiet $data{'r'}{'src'} $max";

$data{'oml'}{'name'} = "OCaml";
$data{'oml'}{'src'} = "primes.ml";
$data{'oml'}{'prog'} = "primesocaml";
$data{'oml'}{'compiler0'} = "ocamlopt";
$data{'oml'}{'cflags0'} = "-o $data{'oml'}{'prog'}";
$data{'oml'}{'cflagspre0'}  = "rm -f primes.cmi primes.cmx && ";

$data{'erl'}{'name'} = "Erlang";
$data{'erl'}{'src'} = "primes.erl";
$data{'erl'}{'compiler0'} = "erlc";
$data{'erl'}{'interp0'} = "erl";
$data{'erl'}{'iflags0'} = "-noshell -s primes primes '$max'";

$data{'4th'}{'name'} = "Forth";
$data{'4th'}{'src'} = "primes.fs";
$data{'4th'}{'interp0'} = "gforth-fast";
$data{'4th'}{'iflags0'} = "$data{'4th'}{'src'} -e '$max 2 4 primes bye'";

$data{'cbl'}{'name'} = "COBOL";
$data{'cbl'}{'src'} = "primes.cbl";
$data{'cbl'}{'prog'} = "primescbl"; 
$data{'cbl'}{'compiler'} = 2;
$data{'cbl'}{'compiler0'} = "cobc";
$data{'cbl'}{'cflags0'} = "-o $data{'cbl'}{'prog'} -x";
$data{'cbl'}{'compiler1'} = "htcobolpp";
$data{'cbl'}{'cflags1'} = "-o $data{'cbl'}{'prog'} -x ";
$data{'cbl'}{'pre'} = "echo \"$max\" | ";
$data{'cbl'}{'warn'} = "Execution is a slower than average, but nothing to worry about";

$data{'scm'}{'name'} = "Scheme";
$data{'scm'}{'src'} = "primes.scm";
$data{'scm'}{'interp'} = 3;
$data{'scm'}{'interp0'} = "scm";
$data{'scm'}{'iflags0'} = "-f ". $data{'scm'}{'src'}." -e \\\\\\\"(primes 3 $max)\\\\\\\"";
$data{'scm'}{'interp1'} = "mzscheme";
$data{'scm'}{'iflags1'} = "-m -f ". $data{'scm'}{'src'}." -e \\\\\\\"(and (primes 3 $max) (exit))\\\\\\\"";
$data{'scm'}{'interp2'} = "guile";
$data{'scm'}{'iflags2'} = "-l $data{'scm'}{'src'} -c '(primes 3 $max)'";

$data{'cl'}{'name'} = "Common Lisp";
$data{'cl'}{'src'} = "primes.lisp";
#$data{'cl'}{'compiler'} = 1;
#$data{'cl'}{'compiler0'} = "clisp";
#$data{'cl'}{'compiler0'} = "gcl";
#$data{'cl'}{'cflagspre0'} = "rm -f primes_clisp.lib primes_clisp.fas && ";
#$data{'cl'}{'cflagspre0'} = "rm -f primes2.o && ";
#$data{'cl'}{'cflags0'} = "-c";
#$data{'cl'}{'cflags0'} = "-compile";
$data{'cl'}{'interp'} = 1;#2
#$data{'cl'}{'interp0'} = "clisp";
#$data{'cl'}{'interp0'} = "gcl";
#$data{'cl'}{'iflags0'} = "-q -i primes2.fas -x '(primes $max)'";
#$data{'cl'}{'iflags0'} = "-load primes2.o -eval '(progn (primes $max) (bye))'";
$data{'cl'}{'interp0'} = "sbcl";
#$data{'cl'}{'interp0'} = "lisp";
$data{'cl'}{'iflags0'} = "--noinform --load primes.lisp --eval '(progn (primes $max) (quit))'";
#$data{'cl'}{'iflags0'} = "-quiet  -load primes2.cl -eval '(progn (primes $max) (quit))'";
#"--noinform --load primes_clisp.cl --eval '(progn (primes $max) (quit))'";
$data{'cl'}{'filter0'} = "sed -e '/[;N]/g'";
#$data{'cl'}{'filter0'} = "sed -e '/[A-Z]/g'";

$data{'pro'}{'name'} = "Prolog";
$data{'pro'}{'src'} = "primes.prolog.pl";
$data{'pro'}{'interp'} = 2;
$data{'pro'}{'interp0'} = "pl";
$data{'pro'}{'iflagspre0'} = "echo '[primes_prolog]. primes($max).' | ";
$data{'pro'}{'iflags0'} = "-q";
$data{'pro'}{'filter0'} = "sed -e '/?/g'";
$data{'pro'}{'interp1'} = "gprolog";
$data{'pro'}{'iflags1'} = "--init-goal '[primes_prolog]' --entry-goal 'primes($max)' --query-goal 'halt(0)'";
$data{'pro'}{'iflagspre1'} = "export  GLOBALSZ=40000; ";
$data{'pro'}{'filter1'} = "sed -e '/[?A-Za-z]/g'";

$data{'pl'}{'name'} = "PERL";
$data{'pl'}{'prog'} = "primes.perl.pl";
$data{'pl'}{'interp0'} = "perl";

$data{'dart'}{'name'} = "Dart";
$data{'dart'}{'prog'} = "primes.dart";
$data{'dart'}{'interp0'} = "dart";

$data{'5c'}{'name'} = "Nickle";
$data{'5c'}{'prog'} = "primes.5c";
$data{'5c'}{'interp0'} = "nickle";
$data{'5c'}{'warn'} = "Execution is approximately 20-30 times slower than perl.";
$data{'5c'}{'reprompt'} = 1;

$data{'st'}{'name'} = "Smalltalk";
$data{'st'}{'prog'} = "primes.st";
$data{'st'}{'interp0'} = "gst";
$data{'st'}{'iflags0'} = "-g $data{'st'}{'prog'} -a $max";

$data{'lua'}{'name'} = "Lua";
$data{'lua'}{'src'} = "primes.5.lua";
#$data{'lua'}{'versionedsrc'} = 1;
# No one has version 4 anymore (right?)
#$data{'lua'}{'versionfinder'} = "lua -v 2>&1 | awk '{print \$2}' | sed -e 's/[^54]//g'";
$data{'lua'}{'interp0'} = "lua";
$data{'lua'}{'iflagspre4'} = "echo $max | ";

$data{'pike'}{'name'} = "Pike";
$data{'pike'}{'prog'} = "primes.pike";
$data{'pike'}{'interp0'} = "pike";

$data{'m3'}{'name'} = "Modula-3";
$data{'m3'}{'compiler0'} = "m3build";
$data{'m3'}{'prog'} = "`ls */primesm3`";

$data{'tcl'}{'name'} = "TCL";
$data{'tcl'}{'src'} = "primes.tcl";
$data{'tcl'}{'interp'} = 2;
$data{'tcl'}{'interp0'} = "tclsh";
$data{'tcl'}{'iflags0'} = "$data{'tcl'}{'src'} $max";
$data{'tcl'}{'interp1'} = "tclsh8.3";
$data{'tcl'}{'iflags1'} = "$data{'tcl'}{'src'} $max";
$data{'tcl'}{'warn'} = "Execution is slower than average, but nothing to worry about";

$data{'sh'}{'name'} = "Shell";
$data{'sh'}{'prog'} = "primes.sh";
$data{'sh'}{'reprompt'} = 1;
$data{'sh'}{'interp0'} = "sh";
$data{'sh'}{'warn'} = "Execution is painfully slow.\n\t\t    Do not try with numbers greater than a few thousand.";

$data{'hs'}{'name'} = "Haskell";
$data{'hs'}{'src'} = "primes.hs";
$data{'hs'}{'prog'} = "primeshs";
$data{'hs'}{'compiler'} = 2;
$data{'hs'}{'compiler0'} = "ghc";
$data{'hs'}{'cflags0'} = "-O -o $data{'hs'}{'prog'}";
$data{'hs'}{'filter0'} = "sed -e 's/\.\]/\ /g'";
$data{'hs'}{'cflagspre0'} = "rm -f Main.hi primes.o && ";
$data{'hs'}{'warn'} = "Compiler is slow";
$data{'hs'}{'compiler1'} = "interpB";
# Uncomment for Hugs, appears to be crazy slow or broken?
#$data{'hs'}{'interpB'} = "hugs";
#$data{'hs'}{'preB'} = "echo \'primes 3 $max 2 4\' | ";
#$data{'hs'}{'iflagsB'} = $data{'hs'}{'src'};
#$data{'hs'}{'filterB'} = "sed -e 's/\.\]/\ /g' | sed -e 's/Main>/\ /g' | sed -e '/[a-zA-Z\/]/g' | sed -e '/     /g' ";
#$data{'hs'}{'warnB'} = "Haskell compiler (ghc) not found.\nFalling back to Haskell interpreter (hugs).\nThis method is very slow!";

$data{'py'}{'name'} = "Python";
$data{'py'}{'prog'} = "primes.py";
$data{'py'}{'interp0'} = "python3";

$data{'php'}{'name'} = "PHP";
$data{'php'}{'prog'} = "primes.php";
$data{'php'}{'interp0'} = "php";

$data{'fe'}{'name'} = "Ferite";
$data{'fe'}{'prog'} = "primes.fe";
$data{'fe'}{'interp0'} = "ferite";
$data{'fe'}{'pre0'}  = "echo $max | ";

#$data{'rb1.8'}{'name'} = "Ruby 1.8";
#$data{'rb1.8'}{'prog'} = "primes.rb";
#$data{'rb1.8'}{'interp0'} = "ruby1.8";
 
$data{'rb'}{'name'} = "Ruby";
$data{'rb'}{'prog'} = "primes.rb";
$data{'rb'}{'interp0'} = "ruby";

$data{'java'}{'name'} = "Java";
$data{'java'}{'src'} = "primes.java";
$data{'java'}{'compiler0'} = "javac";
$data{'java'}{'interp0'} = "java";
$data{'java'}{'prog'} = "primes";
$data{'java'}{'osfilter'} = "FreeBSD";
$data{'java'}{'osreprompt'} = "OpenBSD";
$data{'java'}{'oswarn'} = "OpenBSD";
$data{'java'}{'oswarnmsg'} = "This language has been flagged as unstable on this operating system";

$data{'scala'}{'name'} = "Scala";
$data{'scala'}{'src'} = "primes.scala";
$data{'scala'}{'compiler0'} = "scalac";
$data{'scala'}{'interp0'} = "scala";
$data{'scala'}{'prog'} = "Primes";

$data{'cs'}{'name'} = "C# (Mono)";
$data{'cs'}{'src'} = "primes.cs";
$data{'cs'}{'compiler0'} = "mcs";
$data{'cs'}{'prog'} = "primescs.exe";
$data{'cs'}{'cflags0'} = "-o $data{'cs'}{'prog'}";
$data{'cs'}{'interp'} = 2;
$data{'cs'}{'interp0'} = "mono";
$data{'cs'}{'interp1'} = "mint";

$data{'vb'}{'name'} = "Visual Basic .Net (Mono)";
$data{'vb'}{'src'} = "primes.vb";
$data{'vb'}{'compiler0'} = "mbas";
$data{'vb'}{'prog'} = "primesvb.exe";
$data{'vb'}{'cflags0'} = "-o $data{'vb'}{'prog'}";
$data{'vb'}{'interp'} = 2;
$data{'vb'}{'interp0'} = "mono";
$data{'vb'}{'interp1'} = "mint";
$data{'vb'}{'osfilter'} = "FreeBSD";

sub checkValid 
{
	print "Checking outputed results for validity...\n";
	local(@res) = `wc primes.*.txt`;
	local($i);
	for($i=0; $i < $#res; $i++)
	{
		$arr[$i][0] = `echo \"$res[$i]\" | awk '{print \$2}'`;
		chomp($arr[$i][0]);
		chomp($arr[$i][0]);
		$arr[$i][1] = `echo \"$res[$i]\" | awk '{print \$4}'`;
		chomp($arr[$i][1]);
		chomp($arr[$i][1]);
	}

	# scan all others for differencees, for each match add 1 to [i][2]
	$pt = 0;
	for($i=0; $i<=$#arr; $i++)
	{
		$arr[$i][2] = 0;
		for($p=0; $p <= $#arr; $p++)
		{
			if($p==$i) { next; }
			if($arr[$i][0]  == $arr[$p][0]) { $arr[$i][2]++; }
		}
		if($arr[$i][2] > $pt) {$pt = $arr[$i][2];}
	}
	
	print "Checked ". ($#arr+1)." ouput files of $execd executed languages for validity:\n";
	
	if($pt != $#arr )
	{
		print "Differences detected in ".(($#arr+1)-($pt+1)) ." output files:\n";
		for($i=0; $i<= $#arr; $i++)
		{
			if($arr[$i][2] < $pt || $pt == 0) {
				print "\t". $arr[$i][1]."\n";
			}
		}
	} else {
		print "All output appears to be valid!\n";
	}
	print "View benchmark results in 'results.txt'\n";
}


sub parseTimes
{
	if($debug) {
		print "\n$cmd\n";
	}
	for($i=0; $i< $itr; $i++)
	{
		if($rcmd ne "") { `$rcmd`; }
		my $tstr = `$cmd`;
		print ".";
		($tm[$i][0], $tm[$i][1], $tm[$i][2]) = $tstr =~ 
	/[^\d]*(\d*\.\d*)[^\d]*(\d*\.\d*)[^\d]*(\d*\.\d*).*/;
	}
	my $tr = $tu = $ts =0.0;
	for($i=0; $i< $itr; $i++)
	{
		$tr += $tm[$i][0];
		$tu += $tm[$i][1];
		$ts += $tm[$i][2];
	}
	$tr /= $itr;
	$tu /= $itr;
	$ts /= $itr;
	$tr = substr($tr, 0,4);
	$tu = substr($tu, 0,4);
	$ts = substr($ts, 0,4);
	#print results "$tr real\t$tu user\t$ts sys\n";	
	if(length($tr) == 1) { $tr .= "."; }
	if(length($tr) == 2) { $tr .= "0"; }
	if(length($tr) == 3) { $tr .= "0"; }
	print results "$tr seconds\n";	
}

sub getByLocate
{
	local($where) = `locate $_[0] | grep bin | grep -v cgi | grep -v port | grep -v src`;
	($where) = $where =~ /(.*\/$_[0])\n.*$/;
	#print "WHERE: '$where'\n";
	if($where eq "") { return ""; } else { return $where; }
}
	

sub getInterp
{
	local($where) = `/usr/bin/whereis $_[0] | grep -v port`;
	if(! ($where =~ "\:")) {
		if($where eq "") { return getByLocate($_[0]); }
		else { return "/usr/bin/env $_[0]";
		}
	} else
	{
		local($t1, $t2) = split(":", $where);
		chomp($t2);
		if($t2 ne "") {
		  	return "/usr/bin/env $_[0]";
		} else { 
		 	return getByLocate($_[0]);
		}
	}
}

# HEADER

open(results, ">".$RESULTS) || die("Cannot open $RESULTS\n");

print results "Prime number benchmarks\n";

$mach = `uname -a`;
print results "Benchmark machine: " . $mach;

print results "Iterations: " . $itr . "\n";
print results "Max number searched to: " . $max . "\n\n";

# TESTS

$yesall = 0;
$item = 0;
$execd = 0;
$compiler="";
foreach $l (@langs)
{
	$item++;
	$interpB = 0;
	$compiler = "";
	$version = "";

	if($data{$l}{'osreprompt'} && $os =~ $data{$l}{'osreprompt'}) {
		$data{$l}{'reprompt'} = 1;
	}
	if($data{$l}{'osreprompt'} && $os =~ $data{$l}{'oswarn'}) {
		$data{$l}{'warn'} = $data{$l}{'oswarnmsg'};
	}
	
	if($yesall == 0 || $data{$l}{'reprompt'}){
		print "($item/$llen) Run ".$data{$l}{"name"}." test\n";
		if($data{$l}{'warn'} && !$data{$l}{"reprompt"}) { print "WARNING: $data{$l}{'warn'}\n";}
		
		if($data{$l}{'reprompt'}) { 
			print "RE-PROMPT: WARNING: ";
			if($data{$l}{"warn"}) {
				print $data{$l}{'warn'};
			} else {
				print "Execution is excessively slow."; 
			}
			print "\n";
		}
		
		print "(Y)es yes(A)ll (Q)uit [N]o : ";
		$query = <stdin>;
		$query = substr($query,0,1);
	}
	if($query eq "a" || $query eq "A")
	{
		$yesall = 1;
	}
	if(($yesall == 1 && !$data{$l}{'reprompt'}) || $query eq "y"  || $query eq "Y" )
	{	
		if($yesall == 1) {
			if($query eq "n" || $query eq "N") { $query = "y";}
		}
		if($query eq "Y") {$query eq "y"; }
		if($yesall == 1 && $query eq "y" && !$data{$l}{'reprompt'}) {
			print  "($item/$llen) ";
		}

		print "Testing ". $data{$l}{"name"}.":\n";
		
		if($data{$l}{'warn'} && $yesall && $query eq "y") { print "WARNING: $data{$l}{'warn'}\n";}
		
		if($query eq "A" || $query eq "a") {$query = "y";}
	
		print results "($item/$llen) ". $data{$l}{"name"}." results:\n";
		
		if( $data{$l}{'osfilter'} and $os =~ $data{$l}{'osfilter'})
		{
			print "ERROR: This language is flagged as incompatible with this operating system\n\n";
			print results "ERROR: This language is flagged as incompatible with this operating system\n\n";
			next;
		}
		
		$cmd="";
		if( $data{$l}{"compiler0"})
		{	
			print "Compiling";
			print results "Compile";
			if($l ne "java" && $l ne "m3") {$rcmd = "rm -f $data{$l}{'prog'}";}
			else { $rcmd = "";}
			$cmd .= "sh ";
			if(!$debug) { $cmd .= "2>&1 "; }
			$cmd .= "-c \"" .$TIME . " sh -c \\\"";
			
			$cp = 0;
			if(! $data{$l}{'compiler'})
			{
				$data{$l}{'compiler'} = 1;
			}
				
				for(; $cp < $data{$l}{'compiler'}; $cp++)
				{
					if($data{$l}{"compiler$cp"} eq "interpB")
					{
						$cp = $data{$l}{'compiler'};
						$interpB = 1;
						last;
					}
					$comp = getInterp($data{$l}{"compiler$cp"});
					last if($comp ne "");
				}
			if($cp == $data{$l}{'compiler'}) {
				$clist = "";
				for($p=0;$p<$data{$l}{'compiler'};$p++)
				{
					last if($data{$l}{"compiler$p"} eq "interpB");
					$clist .= "\t\t\t($p) ".  $data{$l}{"compiler$p"}."\n";
				}
				print ":\tERROR - Unable to find one of the following compiler(s):\n$clist\n";
				print results ":\tERROR - Unable to find one of the following compiler(s):\n$clist\n";
				if(! $interpB) { next; }
			}
			if(!$interpB) {
				$compiler = $data{$l}{"compiler$cp"};
				print " [$compiler] ";
				print results " [$compiler]:\t";
				if(length($compiler) < 5) {print results "\t";}
				if($data{$l}{"cflagspre$cp"}) { $cmd .= $data{$l}{"cflagspre$cp"};}	
				$cmd .= "$comp ";
				# So gcc stoped compiling if thh linking was done before the soruce file was specified
				# go figure
				$gcc_code = 0;
				if ($l =~  /^o?b?j?ca?[23]?(gcc)?$/) {
					$gcc_code = 1;
				}
				
				if( $gcc_code) {
					$cmd .= " ".$data{$l}{"src"}." ";
				}
				if( $data{$l}{"cflags$cp"} )
				{
					$cmd .= $data{$l}{"cflags$cp"};
				} 
				if ( ! $gcc_code) {
					$cmd .= " ".$data{$l}{"src"}." ";
				}
				$cmd .= "\\\"\"";
				
				#printf "CMD: '$cmd'\n";
				parseTimes();
				$rcmd = "";
				print "\n";
			}

		}
		
		if($interpB && $data{$l}{'warnB'}) 
		{
			print "WARNING: ".$data{$l}{'warnB'}."\n";
		}
		
		print "Executing";
		print results "Execute";
	
		$filter = "";
		$interpreter = "";
		$cmd = "sh ";
		if(!$debug) { $cmd .= "2>&1 "; }
		$cmd .= "-c \"". $TIME . " sh -c \\\"";
		if( $data{$l}{"interp0"} or $interpB)
		{
			$ip=0;
			if(! $data{$l}{'interp'}) {
				$data{$l}{'interp'} = 1;
			}
				
				if($interpB) {
					$interp = getInterp($data{$l}{'interpB'});
					if($interp eq "") {
						$ip =  $data{$l}{'interp'};
					} else {
						$ip = "B";
					}
				}
				else {
					for(; $ip < $data{$l}{'interp'}; $ip++)
					{
						
						$interp = getInterp($data{$l}{"interp$ip"});
						
						last if($interp ne "");
					}
				}
			if($ip == $data{$l}{'interp'}) 
			{

				$ilist = "";
				if($interpB) { 
					$ilist = "\t".$data{$l}{'interpB'}."\n";
				} else 
				{
					for($p=0;$p<$data{$l}{'interp'};$p++)
					{
						$ilist .= "\t\t\t($p) " .$data{$l}{"interp$p"}."\n";
					}
				}
				print ":\tERROR - Unable to find one of the following interpreter(s):\n$ilist\n";
				print results ":\tERROR - Unable to find one of the following interpreter(s):\n$ilist\n";
				next;
			} 
			
			$interpreter = $data{$l}{"interp$ip"};
			print " [$interpreter]";
			print results " [$interpreter]";
				
			$filter = $data{$l}{"filter$ip"};
			$cmd .= $data{$l}{"pre$ip"};
			$cmd .= $data{$l}{"iflagspre$ip"};
			$cmd .= "$interp ";
			if(!$data{$l}{'noarg'})
			{
			if( $data{$l}{"iflags$ip"})
			{
				$cmd .= $data{$l}{"iflags$ip"}. " ";
			} elsif( $data{$l}{"prog"} )
			{
				$cmd .= $data{$l}{"prog"}." $max ";
			} else 
			{
				if($data{$l}{"versionfinder"}) {
					$version = `$data{$l}{"versionfinder"}`;
					chomp($version);
					$data{$l}{'src'} =~ s/#VERSION#/$version/;
				}
				if($version) {
					if($data{$l}{"iflagspre$version"})
					{
						$cmd = $data{$l}{"iflagspre$version"} . $cmd;
					}
				}
				$cmd .= $data{$l}{"src"}. " ";
				$cmd .= "$max ";
			}
			}
		} else
		{
			if($data{$l}{'pre'}) { $cmd .= $data{$l}{'pre'};}
			$cmd .= "./" . $data{$l}{"prog"} . " $max";
			$filter = $data{$l}{"filter$cp"};
		}
		if($filter) { $cmd .= " | $filter "; }
		$cmd .= " > primes.$l.txt"; 
		$cmd .= "\\\"\"";
		print " ";
		print results ":\t";	
		if(length($interpreter) < 5) { print results "\t";}
		parseTimes();
		print "\n";

		print results "\n";
		sleep 1;
		$execd++;
	}
	elsif( $query eq "q" || $query eq "Q")
	{
		print "\n";
		checkValid();
		print "Quiting\n";
		close(results);
		exit;
	}
	print "\n";
}

checkValid();

close(results);