#!/usr/bin/perl -w

#
# configure
# part of Equivalence, version 0.2.x
#
# Copyright (c) 2005-2008 Operational Dynamics Consulting Pty Ltd, and Others
# 
# The code in this file, and the library it is a part of, are made available
# to you by the authors under the terms of the "GNU General Public Licence,
# version 2". See the LICENCE file for the terms governing usage and
# redistribution.
#

#
# THIS IS A PROTOTYPE. Although functional enough, this has grown to the point
# of being a somewhat embarrassing and monolithic piece of code. Patches are
# gladly accepted to this file to fix bugs and improve prerequisite detection,
# but be aware that a new and refactored version is in progress.  With any
# luck, it will be easier to extend and suitable for use by other projects. See
# http://research.operationaldynamics.com/projects/equivalence/ In the mean
# time, see README for instructions on how to use this one.
#

use strict;

use File::Basename;

#
# Configure slashtime for building. We:
#
# - determine the operating system
#
# - set known defaults that correspond to that OS
#
# - for items where we have multiple possibilities, work through the
#   possibilities until we find one
#
# - for items where there are options to choose from (notably which java
#   compiler and VM we're using), we select a sensible default unless
#   instructed otherwise on the command line.
#

my $os;
my $quiet;

# There's nothing worse than having an old config file, getting half way
# through this, having it break, and then being able to build, but getting
# errors because configure really didn't finish. We do leave .config.tmp 
# in place on error to facilitate troubleshooting.

`rm -f .config`;
`rm -f Hello.java Hello.class`;


# --------------------------------------------------------------------
# Utility and checking functions
# --------------------------------------------------------------------

#
# Very simply: if the msg does not contain a newline, then it is assumed
# to introduce a statement, so we print it and left pad it with spaces.
# If the text does contain a newline, then probably it is concluding a 
# statement (ok, failed, whatever) but not necessarily - just print the thing
# without any padding.
#
sub output {
	my $str = shift;
	if ($str =~ /\n/) {
		print $str unless $quiet;
	} else {
		printf "%-35s", $str unless $quiet;
	}
}

sub which {
	use Cwd 'abs_path';
	my $program = shift;
	my $path = $ENV{'PATH'};
	my @path_dirs = split /:+/, $path;
	foreach my $dir (@path_dirs) {
		if (-f "$dir/$program") {
			return abs_path("$dir/$program");
		}
	}
	return $program;
}

sub bail {
	my $status = shift || "failed";
	my $msg = shift || "";

	# assuming that we're in an incomplete line 
	output "$status\n\n";


	print "$msg\n\n" if $msg;
	print "Failed to complete configuration.\n";
	exit(1);
}

# The files (jars) to check for should be listed in order of preference, as the
# first one found will be the one selected.  For example, if you want version 3
# but version 2 will do, list them in that order.  Typically, this means that
# you list newer libraries first, on the presumption that you'd rather use the
# newer one than the older one; when adding upgrades put them above the
# already present entries.

sub check_prereq (\@$$@) {
	my ($jararrayref, $item, $package, @files) = @_;

	output " - ".$item;

	my $str;
	my $tries = "";
	my $found = "";

	foreach my $file ( @files ) {
		if ( -f "$file" ) {
			$found = $file;
			last;
		}
		$tries .= ($tries ? ", or" : "" ) . "\n\t".  basename($file) . "\t(looked in ".dirname($file).")";
	}

	if ( ! "$found" ) {
		$str = "In order to build slashtime, you need\n".$tries;
		$str .= "\n\nwhich is part of the $item Java library.\n";
		$str .= "On a ".ucfirst($os)." system, you should be able to get this requirement by doing:\n\n";
		$str .= "     # ";

		if ($os eq "gentoo") {
			$str .= "emerge";
		} elsif ($os eq "debian") {
			$str .= "apt-get install";
		} elsif ($os eq "fedora") {
			$str .= "yum install";
		} elsif ($os eq "suse") {
			$str .= "zypper install";
		} elsif ($os eq "mandriva") {
			$str .= "urpmi";
		} elsif ($os eq "solaris") {
			$str .= "pkgadd";
		} else {
			$str .= "[FIXME fetch and install command for this OS]"; 
		}
		$str .= " $package";

		bail "not found!", $str;
	}
	print "found\n";

	push (@$jararrayref, $found);
}

# if we return without setting the variable pointed at by scalarref, its being
# empty will be used later to indicate that this compiler wasn't present /
# usable.
#
# The "not present" check is somewhat spurious given the input in many cases
# is the result of a `which` call.

sub check_compiler (\$$$$) {
	my $scalarref = $_[0];
	my $item = $_[1];
	my $program = $_[2];
	my $args = $_[3];

	chomp $program;
	if ( ! -f "$program") {
		$$scalarref = "";
		return;
	}

	# appealing to my sense of economy, we only print something out if 
	# it's there - that way we can list lots of options to check without
	# cluttering things endlessly.
	output " - ".$item;

	if ( ! -x "$program") {
		output "found but not executable\n";
		$$scalarref = "";
		return;
	}

	# Ok, so inline code is lame, but it's so small, and only one,
	# and, avoids having a file in tests/ that will be picked up later
	# as neededing compiling.
	if (! -f "Hello.java") {
		open HELLO, ">Hello.java";
		print HELLO <<HERE ;
public class Hello {
	public static void main(String[] args) {
		System.out.println("Hello");
	}
}
HERE
		close HELLO;
	}

	`$program $args Hello.java >/dev/null 2>&1`;
	if ($? != 0) {
		output "doesn't work\n";
		$$scalarref = "";
		return
	}

	output "works\n";
	$$scalarref = "$program $args";
}

#
# Check that a jar program somewhere works.
#

sub check_jar (\$$$$) {
	my $scalarref = $_[0];
	my $item = $_[1];
	my $program = $_[2];
	my $args = $_[3];

	chomp $program;
	if ( ! -f "$program") {
		$$scalarref = "";
		return;
	}

	# appealing to my sense of economy, we only print something out if 
	# it's there - that way we can list lots of options to check without
	# cluttering things endlessly.
	output " - ".$item;

	if ( ! -x "$program") {
		output "found but not executable\n";
		$$scalarref = "";
		return;
	}

	`$program cf Hello.jar $args Hello.class >/dev/null 2>&1`;
	if (($? != 0) || (! -f "Hello.jar")) {
		output "doesn't work\n";
		$$scalarref = "";
		return
	}

	# TODO validate the result

	output "works\n";
	$$scalarref = "$program $args";
}

#
# Check that a javadoc program somewhere works.
#

sub check_javadoc (\$$$$) {
	my $scalarref = $_[0];
	my $item = $_[1];
	my $program = $_[2];
	my $args = $_[3];

	chomp $program;
	if ( ! -f "$program") {
		$$scalarref = "";
		return;
	}

	# appealing to my sense of economy, we only print something out if 
	# it's there - that way we can list lots of options to check without
	# cluttering things endlessly.
	output " - ".$item;

	if ( ! -x "$program") {
		output "found but not executable\n";
		$$scalarref = "";
		return;
	}

	# TODO validate the result

	output "found\n";
	$$scalarref = "$program $args";
}


sub check_runtime (\$$$$) {
	my $scalarref = $_[0];
	my $item = $_[1];
	my $program = $_[2];
	my $args = $_[3];

	chomp $program;
	if ( ! -f "$program") {
		$$scalarref = "";
		return;
	}

	output " - ".$item;

	if ( ! -x "$program") {
		output "found but not executable\n";
		$$scalarref = "";
		return;
	}

	my $output = `$program -version 2>&1 | grep 'version "'`;
	$output =~ s/.*version \"(.*)\".*/$1/g;
	my @version = split(/[\.\-\_]/, $output);
	for (my $i = 0; $i < 3; $i++) {
		chomp $version[$i];

		if (!($version[$i] =~ /^\d+$/)) {
			output "can't parse version\n";
			$$scalarref = "";
			return
		}
	}
	if (
		($version[0] < 1) ||
	   	($version[0] == 1 && ($version[1] < 4 ||
				     ($version[1] == 4 && $version[2] < 2)))
	) {
		output "not >= 1.4.2\n";
		$$scalarref = "";
		return
	}

	$output = `$program $args Hello 2>/dev/null`;
	chomp $output;

	if (($? != 0) || ($output ne "Hello")) {
		output "doesn't work\n";
		$$scalarref = "";
		return
	}

	output "works\n";
	$$scalarref = "$program $args";
}

# --------------------------------------------------------------------
# Process command line arguments for overrides
# --------------------------------------------------------------------

my $prefix;
my $jardir;
my $compiler;
my $runtime;
my $jdk_home;
my $java_gnome_home = "";
my $jamvm_bin;
my $cacao_bin;

foreach my $arg (@ARGV) {
	my ($key, $value) = split /=/, "$arg";

	if ($key eq "quiet") {
		$quiet = 1;
	} elsif (($key =~ /^-\?$/) ||
		 ($key =~ /^-h$/) ||
		 ($key =~ /^--help$/) ||
		 ($key =~ /^-help$/) ||
		 ($key =~ /^help$/)) {
		print <<HERE ;

This is Equivalence, a simple build system suited to the
unique needs of configuring and compiling Java programs on
Linux and Unix.

Look at the README file in this directory for information
about this project and instructions on how to adjust the
./configure script's behaviour.

HERE
		exit 4;
	} elsif (($key =~ /^--prefix$/) ||
		 ($key =~ /^prefix$/)) {
		$prefix="$value";
	} elsif (($key =~ /^--jardir$/) ||
		 ($key =~ /^jardir$/)) {
		$jardir="$value";
	} elsif ($key =~ /^runtime/) {
		$runtime="$value";
	} elsif ($key =~ /^compiler/) {
		$compiler="$value";
	} elsif ($key =~ /^jdk/) {
		$jdk_home="$value";
	} elsif ($key =~ /^cacao/) {
		$cacao_bin="$value";
	} elsif ($key =~ /^jamvm/) {
		$jamvm_bin="$value";
	} elsif ($key =~ /^java-gnome/) {
		$java_gnome_home=glob "$value";
	}
}

if (!$prefix) {
	$prefix="/usr/local";
}

if (!$jardir) {
	$jardir=$prefix . "/share/java";
}


# check jdk_home override. compiler and runtime are checked 
# later (at the end) against choices that have been validated.

if ($jdk_home) {
	$jdk_home =~ s/\/$//;
	if (! -x "$jdk_home/bin/javac") {
		bail "bad override", "jdk_home specified doesn't seem to be a Java Development Kit home directory!";
	}
}


# --------------------------------------------------------------------
# Determine Operating System
# --------------------------------------------------------------------

output "\n";

open CONFIG, ">.config.tmp";
print CONFIG <<HERE ;
# This is an automatically generated Makefile fragment which is used
# to configure slashtime for building. Do not edit (your changes will
# be overwritten next time ./configure is run), do not commit to
# repository. Anyone packaging slashtime on any operating system:
# please do not override this file by patching it! Figure out what the
# problem is, and let us know so we can improve the ./configure perl
# script which generates it.

HERE

output "equivalence, v0.2\n";
output "...configuring Java projects to build and run on Linux & Unix\n";
output "\n";

output "Identify operating system:";

if (( -f "/etc/gentoo-release" ) || ( -f "/etc/make.conf" )) {
	output "Gentoo\n";
	$os = "gentoo";
} elsif ( -f "/etc/debian_version") {
	output "Debian\n";
	# and Ubuntu
	$os = "debian";
} elsif ( -f "/etc/fedora-release" ) {
	output "Fedora Core";
	$os = "fedora";
} elsif ( -f "/etc/SuSE-release" ) {
	output "Open SuSE";
	$os = "suse";
} elsif ( -f "/etc/arch-release" ) {
	output "Arch Linux";
	$os = "arch";
} elsif ( -f "/etc/mandriva-release" ) {
	output "Mandriva";
	$os = "mandriva";
} elsif ( -f "/etc/release" ) {
	if (`grep Solaris /etc/release`) {
		output "Solaris";
		$os = "solaris";
	}
}

if ($os) {
	print CONFIG "OS=$os\n\n";
} else {
	bail "unknown!", <<HERE ;
What we really need you to do is to look into this configure program,
and tell us what to add. Based on the examples of what is specified
for other distributions, you can probably quickly figure out what the
appropriate settings are for your platform. 

Letting us know what changes you had to make here (ie, whatever
actions resulted in a .config that allows you to build and test
slashtime, and run the slashtime demo) we can help others with your
operating system take advantage of this program.

HERE
}

output "\n";

# --------------------------------------------------------------------
# Specify locations of dependencies, by operating system, and 
# verify pre-requisites are present.
# --------------------------------------------------------------------

my @java_gnome_jars;
my $jni_path;

output "Check for required jar files:\n";

if ($os eq "gentoo") {

	if ($java_gnome_home) {
		check_prereq(@java_gnome_jars,
			"java-gnome UI library",
			"java-gnome",
			"$java_gnome_home/share/java/gtk-4.0.jar",
			"$java_gnome_home/tmp/gtk-4.0.jar");
	} else {
		check_prereq(@java_gnome_jars,
			"java-gnome UI library",
			"java-gnome",
			"/usr/share/java-gnome-4.0/lib/gtk.jar");
	}


} elsif ($os eq "debian") {

	if ($java_gnome_home) {
		check_prereq(@java_gnome_jars,
			"java-gnome UI library",
			"java-gnome",
			"$java_gnome_home/share/java/gtk-4.0.jar",
			"$java_gnome_home/tmp/gtk-4.0.jar");
	} else {
		check_prereq(@java_gnome_jars,
			"java-gnome UI library",
			"java-gnome",
			"$prefix/share/java/gtk-4.0.jar",
			"/usr/share/java/gtk-4.0.jar",
			"~/share/java/gtk-4.0.jar");
	}

	
} elsif ($os eq "fedora") {

	check_prereq(@java_gnome_jars,
		"java-gnome UI library",
		"java-gnome",
		"$java_gnome_home/share/java/gtk-4.0.jar",
		"~/share/java/gtk-4.0.jar");

} elsif ($os eq "arch") {

	check_prereq(@java_gnome_jars,
		"java-gnome UI library",
		"java-gnome",
		"$java_gnome_home/share/java/gtk-4.0.jar",
		"~/share/java/gtk-4.0.jar");

} elsif ($os eq "suse") {

	check_prereq(@java_gnome_jars,
		"java-gnome UI library",
		"java-gnome",
		"$java_gnome_home/share/java-gnome/lib/gtk-4.0.jar",
		"~/share/java/gtk-4.0.jar");

} elsif ($os eq "mandriva") {

	if ($java_gnome_home) {
		check_prereq(@java_gnome_jars,
			"java-gnome UI library",
			"java-gnome",
			"$java_gnome_home/share/java/gtk-4.0.jar",
			"$java_gnome_home/tmp/gtk-4.0.jar");
	} else {
		check_prereq(@java_gnome_jars,
			"java-gnome UI library",
			"java-gnome",
			"$prefix/share/java/gtk-4.0.jar",
			"/usr/share/java/gtk-4.0.jar",
			"~/share/java/gtk-4.0.jar");
	}

} elsif ($os eq "solaris") {

	check_prereq(@java_gnome_jars,
		"java-gnome UI library",
		"java-gnome",
		"$java_gnome_home/share/java-gnome/lib/gtk-4.0.jar",
		"~/share/java/gtk-4.0.jar");
	
} else {
	bail "failed!", "This OS not configured with defaults!\nTHIS IS AN INTERNAL ERROR, PLEASE FILE A BUG.";
}


# --------------------------------------------------------------------
# Record jar locations
# --------------------------------------------------------------------

print CONFIG <<HERE ;

# The lists of jars are colon separated, suitable for being
# concatenated into a CLASSPATH

HERE

print CONFIG "JAVAGNOME_JARS=".join(":",@java_gnome_jars)."\n";

output "\n";

# --------------------------------------------------------------------
# Check compilers: locations, necessary arguments, and that they work
# --------------------------------------------------------------------

output "Check Java compilers:\n";

# compilers we will check for:
my $javac;
my $ecj;
my $kaffec;

# tools we check at same time (not switchable)
my $javah;
my $jar;
my $javadoc;

if ($os eq "gentoo") {

	if ( ! -x "/usr/bin/java-config") {
		bail "", "INTERNAL ERROR couldn't find java-config";
	}
	# this is getting ridiculous
	my $java_home;
	if ($jdk_home) {
		$java_home = "$jdk_home";
	} else {
		$java_home = `java-config -O`;
		chomp $java_home;
	}

	# check ecj, the standalone Eclipse compiler.
	check_compiler($ecj, "Eclipse ecj", "/usr/bin/ecj-3.4", "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");
	check_compiler($ecj, "Eclipse ecj", "/usr/bin/ecj-3.3", "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5") unless $ecj;

	
	# check javac (the one specified by Gentoo's java-config tool)
	# The $vendor business is just some precision prettiness for the
	# display.
	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;

	if ($jdk_home) {
		$javac_candidate = "$jdk_home/bin/javac";
		$javah_candidate = "$jdk_home/bin/javah";
		$jar_candidate = "$jdk_home/bin/jar";
		$javadoc_candidate = "$jdk_home/bin/javadoc";
		$vendor = "Specified";
	} else {
		$javac_candidate = `java-config --javac`;

		$javah_candidate = `java-config -O`;
		chomp $javah_candidate;
		$javadoc_candidate = $javah_candidate;

		$javah_candidate .= "/bin/javah";
		$javadoc_candidate .= "/bin/javadoc";

		$jar_candidate = `java-config --jar`;
		$vendor = "System";
	}

	if ($javac_candidate =~ /sun/i) {
		$vendor = "Sun";
	} elsif ($javac_candidate =~ /blackdown/i) {
		$vendor = "Blackdown";
	} elsif ($javac_candidate =~ /ibm/i) {
		$vendor = "IBM";
	}
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	# check tools
	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");

} elsif ($os eq "debian") {
	# we can do much better than this, especially for java/javac.
	# Do we access the alternatives system, or just go with known
	# paths, or...? `which` is lame

	# check ecj, the standalone Eclipse compiler.
	check_compiler($ecj, "Eclipse ecj", which("ecj"), "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");

	# check for a proper "real" JDK's javac as installed (and maybe
	# selected in the alternatives system) by the user. In other words,
	# javac -> /opt/sun-jdk-1.4.2.02/bin/javac, not javac -> kaffec.
	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;

	if ($jdk_home) {
		$javac_candidate = "$jdk_home/bin/javac";
		$javah_candidate = "$jdk_home/bin/javah";
		$jar_candidate = "$jdk_home/bin/jar";
		$javadoc_candidate = "$jdk_home/bin/javadoc";
		$vendor = "Specified";
	} else {
		$javac_candidate = which("javac");
		$javah_candidate = "";
		$jar_candidate = "";
		$javadoc_candidate = "";
		$vendor = "System";
	}
	if ($javac_candidate =~ /sun/i) {
		$vendor = "Sun";
	} elsif ($javac_candidate =~ /blackdown/i) {
		$vendor = "Blackdown";
	} elsif ($javac_candidate =~ /ibm/i) {
		$vendor = "IBM";
	}
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	# check for kaffe's compiler
	check_compiler($kaffec, "Kaffe javac", "/usr/lib/kaffe/bin/javac", "");

	# check for JDK tools. To suit Debian prejudices, use GNU tools if found.

	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_jar($jar, "GNU fastjar", which("fastjar"), "") unless $jar;
	check_jar($jar, "System jar", which("jar"), "") unless $jar;

	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");
	check_javadoc($javadoc, "GNU gjdoc", which("gjdoc"), "") unless $javadoc;
	check_javadoc($javadoc, "System javadoc", which("javadoc"), "") unless $javadoc;

} elsif ($os eq "fedora") {
	# we can do much better than this, especially for java/javac.
	# Should we just go with known paths, or...? `which` is so lame

	# check ecj, the standalone Eclipse compiler.
	check_compiler($ecj, "Eclipse ecj", which("ecj"), "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");

	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;
	if ($jdk_home) {
		$javac_candidate = "$jdk_home/bin/javac";
		$javah_candidate = "$jdk_home/bin/javah";
		$jar_candidate = "$jdk_home/bin/jar";
		$javadoc_candidate = "$jdk_home/bin/javadoc";
		$vendor = "Specified";
	} else {
		$javac_candidate = "/usr/lib/jvm/java-ibm/bin/javac";
		$javah_candidate = "/usr/lib/jvm/java-ibm/bin/javah";
		$jar_candidate = "/usr/lib/jvm/java-ibm/bin/jar";
		$javadoc_candidate = "/usr/lib/jvm/java-ibm/bin/javadoc";
		$vendor = "IBM";
	}
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	# check for kaffe's compiler
	check_compiler($kaffec, "Kaffe javac", which("kaffec"), "");

	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");

} elsif ($os eq "suse") {
	# check ecj, the standalone Eclipse compiler.
	check_compiler($ecj, "Eclipse ecj", which("ecj"), "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");

	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;
	if ($jdk_home) {
		$javac_candidate = "$jdk_home/bin/javac";
		$javah_candidate = "$jdk_home/bin/javah";
		$jar_candidate = "$jdk_home/bin/jar";
		$javadoc_candidate = "$jdk_home/bin/javadoc";
		$vendor = "Specified";
	} else {
		$javac_candidate = "/usr/lib/jvm/java/bin/javac";
		$javah_candidate = "/usr/lib/jvm/java/bin/javah";
		$jar_candidate = "/usr/lib/jvm/java/bin/jar";
		$javadoc_candidate = "/usr/lib/jvm/java/bin/javadoc";
		$vendor = "Sun";
	}
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	# check for kaffe's compiler
	check_compiler($kaffec, "Kaffe javac", which("kaffec"), "");

	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");


} elsif ($os eq "arch") {
	# we can do much better than this, especially for java/javac.
	# Should we just go with known paths, or...? `which` is so lame

	# check ecj, the standalone Eclipse compiler.
	check_compiler($ecj, "Eclipse ecj", which("ecj"), "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");

	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;
	if ($jdk_home) {
		$javac_candidate = "$jdk_home/bin/javac";
		$javah_candidate = "$jdk_home/bin/javah";
		$jar_candidate = "$jdk_home/bin/jar";
		$javadoc_candidate = "$jdk_home/bin/javadoc";
		$vendor = "Specified";
	} else {
		$javac_candidate = "/opt/java/bin/javac";
		$javah_candidate = "/opt/java/bin/javah";
		$jar_candidate = "/opt/java/bin/jar";
		$javadoc_candidate = "/opt/java/bin/javadoc";
		$vendor = "Sun";
	}
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	# check for kaffe's compiler
	check_compiler($kaffec, "Kaffe javac", which("kaffec"), "");

	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");

} elsif ($os eq "mandriva") {
	# check ecj, the standalone Eclipse compiler.
	check_compiler($ecj, "Eclipse ecj", which("ecj"), "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");

	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;
	if ($jdk_home) {
		$vendor = "Specified";
	} else {
		if ( $ENV{'JAVA_HOME'} ) {
			$jdk_home = $ENV{'JAVA_HOME'};
			$vendor = "Sun";
		} else {
			# will fail
		}
	}
	$javac_candidate = "$jdk_home/bin/javac";
	$javah_candidate = "$jdk_home/bin/javah";
	$jar_candidate = "$jdk_home/bin/jar";
	$javadoc_candidate = "$jdk_home/bin/javadoc";
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");


} elsif ($os eq "solaris") {
	check_compiler($ecj, "Eclipse ecj", which("ecj"), "-g -preserveAllLocals -nowarn -source 1.5 -target 1.5");

	my $javac_candidate;
	my $javah_candidate;
	my $jar_candidate;
	my $javadoc_candidate;
	my $vendor;
	if ($jdk_home) {
		$javac_candidate = "$jdk_home/bin/javac";
		$javah_candidate = "$jdk_home/bin/javah";
		$jar_candidate = "$jdk_home/bin/jar";
		$javadoc_candidate = "$jdk_home/bin/javadoc";
		$vendor = "Specified";
	} else {
		$javac_candidate = "/usr/java/bin/javac";
		$javah_candidate = "/usr/java/bin/javah";
		$jar_candidate = "/usr/java/bin/jar";
		$javadoc_candidate = "/usr/java/bin/javadoc";
		$vendor = "Sun";
	}
	check_compiler($javac, "$vendor javac", $javac_candidate, "-g");

	# check for kaffe's compiler
	check_compiler($kaffec, "Kaffe javac", which("kaffec"), "");

	check_jar($jar, "$vendor jar", $jar_candidate, "");
	check_javadoc($javadoc, "$vendor javadoc", $javadoc_candidate, "");

} else {
	bail "failed!", "This OS not configured with a workable Java compiler checks!\nTHIS IS AN INTERNAL ERROR, PLEASE FILE A BUG.";
}

output "\n";

# --------------------------------------------------------------------
# Check runtimes
# --------------------------------------------------------------------

output "Check Java virtual machines:\n";

# runtimes we will check for:
my $java;
my $kaffe;
my $cacao;
my $jamvm;

if ($os eq "gentoo") {
	# check java (the one specified by Gentoo's java-config tool)
	# Is there any actual scenario where the javac would be from one 
	# vendor's JDK and the java from anther's JRE? I can't imagine, but
	# do the $vendor check again. It's only cosmetic in any event.
	my $java_candidate;
	my $vendor;

	if ($jdk_home) {
		$java_candidate = "$jdk_home/bin/java";
	} else {
		$java_candidate = `java-config --java`;
	}

	if ($java_candidate =~ /sun/i) {
		$vendor = "Sun";
	} elsif ($java_candidate =~ /blackdown/i) {
		$vendor = "Blackdown";
	} elsif ($java_candidate =~ /ibm/i) {
		$vendor = "IBM";
	} else {
		$vendor = "System";
	}
	check_runtime($java, "$vendor java VM", $java_candidate, "-client -ea");

	# check kaffe
	check_runtime($kaffe, "kaffe VM", which("kaffe"), "");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");

} elsif ($os eq "debian") {
	# check for a proper JDK/JRE java Virtual Machine (presumably either
	# blackdown, or the real thing from Sun or IBM, as installed by the
	# user).  NOTE that this does *NOT* mean Sable VM or kaffe (so, if the
	# Debian alternatives system can say that's what's providing
	# java-runtime, then we need to take advantage of that. This is for a
	# real JRE only, ie java -> /opt/sun-jdk-1.4.2.02/bin/java, not for
	# java -> kaffe.
	my $java_candidate;
	my $vendor;

	if ($jdk_home) {
		$java_candidate = "$jdk_home/bin/java";
		$vendor = "Specified";
	} else {
		$java_candidate = which("java");
		$vendor = "System";
	}
	check_runtime($java, "$vendor java VM", $java_candidate, "-client -ea");

	# check kaffe. Don't take it personally, but kaffe is not meant as a
	# robust production ready VM.  It's a research tool (so described on
	# their home page) but given the progress in GNU classpath lately it
	# *may* work, so we do check for it  - we just don't pick it by
	# preference.
	check_runtime($kaffe, "Kaffe VM", "/usr/lib/kaffe/bin/java", "");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");

} elsif ($os eq "fedora") {
	# check for a proper JDK/JRE java Virtual Machine. Red Hat is using
	# the alternatives system symlinks to select JVMs, and then *again*
	# to select versions. All the symlinks end up back in /usr/lib/jvm with
	# predictable names, which makes this workable.
	my $java_candidate;
	my $vendor;
	if ($jdk_home) {
		$java_candidate = "$jdk_home/bin/java";
		$vendor = "Specified";
	} else {
		$java_candidate = "/usr/lib/jvm/jre-ibm/bin/java";
		$vendor = "IBM";
	}
	check_runtime($java, "$vendor java VM", $java_candidate, "-client -ea");

	# check kaffe. See the comment about Kaffe above in the Debian block.
	check_runtime($kaffe, "Kaffe VM", which("kaffe"), "");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");

} elsif ($os eq "suse") {
	# check for a proper JDK/JRE java Virtual Machine. 
	my $java_candidate;
	my $vendor;
	if ($jdk_home) {
		$java_candidate = "$jdk_home/bin/java";
		$vendor = "Specified";
	} else {
		$java_candidate = "/usr/lib/jvm/java/bin/java";
		$vendor = "Sun";
	}
	check_runtime($java, "$vendor java VM", $java_candidate, "-client -ea");

	# check kaffe. See the comment about Kaffe above in the Debian block.
	check_runtime($kaffe, "Kaffe VM", which("kaffe"), "");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");

} elsif ($os eq "mandriva") {
	my $java_candidate;
	my $vendor;

	if ($jdk_home) {
		$vendor = "Specified";
	} else {
		if ( $ENV{'JAVA_HOME'} ) {
			$jdk_home = $ENV{'JAVA_HOME'};
			$vendor = "Sun";
		} else {
			# will fail
		}
	}
	$java_candidate = "$jdk_home/bin/java";

	check_runtime($java, "$vendor java VM", $java_candidate, "-client -ea");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");


} elsif ($os eq "arch") {
	# check for a proper JDK/JRE java Virtual Machine. Red Hat is using
	# the alternatives system symlinks to select JVMs, and then *again*
	# to select versions. All the symlinks end up back in /usr/lib/jvm with
	# predictable names, which makes this workable.
	my $java_candidate;
	my $vendor;
	if ($jdk_home) {
		$java_candidate = "$jdk_home/bin/java";
		$vendor = "Specified";
	} else {
		$java_candidate = "/opt/java/bin/java";
		$vendor = "IBM";
	}
	check_runtime($java, "$vendor java VM", $java_candidate, "-client -ea");

	# check kaffe. See the comment about Kaffe above in the Debian block.
	check_runtime($kaffe, "Kaffe VM", which("kaffe"), "");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");

} elsif ($os eq "solaris") {
	# check for a JDK/JRE java Virtual Machine, allowing an alternate to be set
	# (no reason to disable that)
	my $java_candidate;
	if ($jdk_home) {
		$java_candidate = "$jdk_home/bin/java";
	} else {
		$java_candidate = "/usr/java/bin/java";
	}

	check_runtime($java, "Sun java VM", $java_candidate, "-client -ea");

	# check kaffe
	check_runtime($kaffe, "kaffe VM", which("kaffe"), "");

	# check jamvm (an elegant bytecode interpreter used by many in the
	# CLASSPATH project to test new releases)
	my $jamvm_candidate;
	if ($jamvm_bin) {
		$jamvm_candidate = "$jamvm_bin";
	} else {
		$jamvm_candidate = "/usr/bin/jamvm";
	}
	check_runtime($jamvm, "JamVM VM", $jamvm_candidate, "");

	my $cacao_candidate;
	if ($cacao_bin) {
		$cacao_candidate = "$cacao_bin";
	} else {
		$cacao_candidate = "/usr/bin/cacao";
	}
	check_runtime($cacao, "CACAO VM", $cacao_candidate, "");

} else {
	bail "failed!", "This OS not configured with appropriate Java VM checks!\nTHIS IS AN INTERNAL ERROR, PLEASE FILE A BUG.";
}

output "\n";


print CONFIG <<HERE ;

# the JAVAC variable contains the path to the java source compiler,
# the JAVA variable contains the path to the java runtime virtual
# machine. In both cases, the _CMD variable is for the terse output
# when make commands are running.

HERE

output "Select compiler:";

if ($compiler) {
	# if overridden, check override...
	if ($compiler eq "javac") {
		bail "bad override", "javac specified but not detected as a workable compiler." unless $javac;
	} elsif ($compiler eq "ecj") {
		bail "bad override", "ecj specified but not detected as a workable compiler." unless $ecj;
	} else {
		bail "bad override", <<HERE ;
You specified compiler=$compiler on the command line, but that's not an option.
Valid choices are ecj, javac - but of course that compiler must be
installed (and detected!) in order to be able to specify it.
HERE
	}

} else {
	# otherwise, pick a compiler.
	if ($ecj) {
		$compiler = "ecj";
	} elsif ($javac) {
		$compiler = "javac";
	} else {
		bail "failed", "No java compiler was detected.";
	}
}

if ($compiler eq "javac") {
	print CONFIG "JAVAC=$javac\n";
	print CONFIG "JAVAC_CMD=JAVAC\n";
} elsif ($compiler eq "ecj") {
	print CONFIG "JAVAC=$ecj\n";
	print CONFIG "JAVAC_CMD=ECJ\n";
} else {
	bail "failed", "INTERNAL ERROR no compiler selected.";
}


print CONFIG <<HERE ;

# the JAVAH, JAR, and JAVADOC variables simply contains a usable jar
# and javah executable, respectively, while the JAVAH_CMD, JAR_CMD,
# and JAVADOC_CMD variables is for display purposes, matching the
# pattern above.

HERE


if ($jar) {
	print CONFIG "JAR=$jar\n";
	print CONFIG "JAR_CMD=JAR\n";
} else {
	bail "failed", "No Java archive tool detected.";
}
if ($javadoc) {
	print CONFIG "JAVADOC=$javadoc\n";
	print CONFIG "JAVADOC_CMD=JAVADOC\n";
} else {
	bail "failed", "No JavaDoc tool detected.";
}

output "$compiler\n";


output "Select runtime:";

if ($runtime) {
	# if overridden, check override...
	if ($runtime eq "java")  {
		bail "bad override", "java specified but not detected." unless $java;
	} elsif ($runtime eq "kaffe") {
		bail "bad override", "kaffe specified but not detected." unless $kaffe;
	} elsif ($runtime eq "cacao") {
		bail "bad override", "cacao specified but not detected." unless $cacao;
	} elsif ($runtime eq "jamvm") {
		bail "bad override", "jamvm specified but not detected." unless $jamvm;
	} else {
		bail "bad override", <<HERE ;
You specified runtime=$runtime on the command line, but that's not an option.
Valid choices are java, jamvm, cacao, or kaffe - but of course that virtual
machine must be installed (and detected!) before you can specify it.
HERE
	}

} else {
	if ($java) {
		$runtime = "java";
	} elsif ($jamvm) {
		$runtime = "jamvm";
	} elsif ($cacao) {
		$runtime = "cacao";
	} elsif ($kaffe) {
		$runtime = "kaffe";
	} else {
		bail "failed", "No usable Java runtime environment was detected.";
	}
}

my $JAVA;

if ($runtime eq "java") {
	print CONFIG "JAVA=$java\n";
	print CONFIG "JAVA_CMD=JAVA\n";
	$JAVA=$java;
} elsif ($runtime eq "kaffe") {
	print CONFIG "JAVA=$kaffe\n";
	print CONFIG "JAVA_CMD=KAFFE\n";
	$JAVA=$kaffe
} elsif ($runtime eq "cacao") {
	print CONFIG "JAVA=$cacao\n";
	print CONFIG "JAVA_CMD=CACAO\n";
	$JAVA=$cacao
} elsif ($runtime eq "jamvm") {
	print CONFIG "JAVA=$jamvm\n";
	print CONFIG "JAVA_CMD=JAMVM\n";
	$JAVA=$jamvm
} else {
	bail "failed", "INTERNAL ERROR no virtual machine selected";
}
output "$runtime\n";
output "\n";

`rm -f Hello.java Hello.class Hello.o Hello Hello.c Hello.jar`;

print CONFIG <<HERE ;

# the install prefix. This *only* affects the location that installed
# files are sent to during the `make install` step.

HERE

print CONFIG "PREFIX=$prefix\n";
print CONFIG "JARDIR=$jardir\n";

# --------------------------------------------------------------------
# Get version constant
# --------------------------------------------------------------------

my $apiversion;
my $version;

open SOURCE, "src/java/slashtime/client/Version.java";
while (<SOURCE>) {
	chomp;
	if (/.* APIVERSION = \"([\S]+)\";/) {
		$apiversion = $1;
	}
	if (/.* VERSION = \"([\S]+)\";/) {
		$version = $1;
	}
}
close SOURCE;

if (!$version) {
	bail("","Couldn't find the release version");
}

print CONFIG <<HERE ;

# finally, we extract the version strings from the source code, for
# use in naming the target library files.

HERE

print CONFIG "APIVERSION=$apiversion\n";
print CONFIG "VERSION=$version\n";

# --------------------------------------------------------------------
# Done! Create .config file
# --------------------------------------------------------------------

output "Write .config file:";
close CONFIG;
system "mv .config.tmp .config";

output "ok\n";

# --------------------------------------------------------------------
# Create in-place launcher file
# --------------------------------------------------------------------

# We need to support specifying an alternative location for the installed
# slashtime.jar file. For now it is hard coded as follows:

my $JAVAGNOME_JARS = join(":", @java_gnome_jars);
my $SLASHTIME_JARS="$prefix/share/java/slashtime-$apiversion.jar";

output "Write launcher files:";

mkdir "tmp/";
mkdir "tmp/launcher";

open LAUNCHER, ">tmp/launcher/slashtime-local";

print LAUNCHER "#! /bin/sh\n";
print LAUNCHER join (" ",
	"exec",
	"$JAVA",
	"-classpath tmp/classes:$JAVAGNOME_JARS ",
	"slashtime.client.Master",
	"\$*") . "\n";

close LAUNCHER;

# --------------------------------------------------------------------
# Create as-installed launcher file
# --------------------------------------------------------------------


open LAUNCHER, ">tmp/launcher/slashtime-install";

print LAUNCHER "#! /bin/sh\n";
print LAUNCHER "cd $prefix\n";
print LAUNCHER join (" ",
	"exec",
	"$JAVA",
	"-classpath $SLASHTIME_JARS:$JAVAGNOME_JARS",
	"slashtime.client.Master",
	"\$*") . "\n";

close LAUNCHER;

open DESKTOP, ">tmp/launcher/slashtime.desktop";

print DESKTOP <<HERE ;
[Desktop Entry]
Version=1.0
Type=Application
Name=Slashtime
GenericName="Time Zones"
Comment=View the time at locations around the world
Categories=GNOME;GTK;Utility;
Path=$prefix
Exec=$prefix/bin/slashtime
Icon=$prefix/share/pixmaps/slashtime-marble.png
HERE

close DESKTOP;

output "ok\n";
output "\n";