#**************************************************************
#
#  Licensed to the Apache Software Foundation (ASF) under one
#  or more contributor license agreements.  See the NOTICE file
#  distributed with this work for additional information
#  regarding copyright ownership.  The ASF licenses this file
#  to you under the Apache License, Version 2.0 (the
#  "License"); you may not use this file except in compliance
#  with the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing,
#  software distributed under the License is distributed on an
#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#  KIND, either express or implied.  See the License for the
#  specific language governing permissions and limitations
#  under the License.
#
#**************************************************************

#
# configure.pl - a perl script to set a minimal environment for the SDK.
#
# Copyright 2000, 2010 Oracle and/or its affiliates.
#

use IO::File;
use File::Basename;

$main::hostname= $ARGV[0];
$main::sdkpath= $ARGV[1];
$main::OO_SDK_NAME= $ARGV[2];

$main::OO_MAJORVERSION=$main::OO_SDK_NAME;
$main::OO_MINORVERSION=$main::OO_SDK_NAME;
$main::OO_MAJORVERSION =~ s#[^\d]+(\d).(\d).+#$1#go;
$main::OO_MINORVERSION =~ s#[^\d]+(\d).(\d).+#$2#go;

$main::OO_SDK_CONFIG_HOME= "$ENV{HOME}/$main::OO_SDK_NAME";

$main::operatingSystem = `$main::sdkpath/config.guess | cut -d"-" -f3,4`;
chomp ($main::operatingSystem);

$main::OO_SDK_HOME = $main::sdkpath;
$main::OO_SDK_HOME_SUGGESTION = $main::sdkpath;

$main::OFFICE_HOME = "";

#$main::OFFICE_BASE_HOME = substr($main::sdkpath, 0, rindex($main::sdkpath, "/sdk"));

$main::OO_SDK_MAKE_HOME = "";
$main::makeName = "make";
if ( $main::operatingSystem =~ m/solaris/ ||
	 $main::operatingSystem =~ m/freebsd/ )
{
	$main::makeName = "gmake";
}
$main::OO_SDK_MAKE_HOME_SUGGESTION = searchprog($main::makeName);
$main::makeVersion = "3.79.1";
$main::correctVersion = 0;

$main::OO_SDK_ZIP_HOME = "";
$main::OO_SDK_ZIP_HOME_SUGGESTION = searchprog("zip");
$main::zipVersion = "2.3";

$main::OO_SDK_CAT_HOME = "";
$main::OO_SDK_CAT_HOME_SUGGESTION = searchprog("cat");
# TODO cat version
# $main::catVersion = "";

$main::OO_SDK_SED_HOME = "";
$main::OO_SDK_SED_HOME_SUGGESTION = searchprog("sed");
# TODO sed version
# $main::sedVersion = "";

$main::OO_SDK_CPP_HOME = "";
$main::cppName = "gcc";
$main::cppVersion = "4.0.1";
if ( $main::operatingSystem =~ m/solaris/ )
{
	$main::cppName = "CC";
	$main::cppVersion = "5.2";
}
if ( $main::operatingSystem =~ m/darwin/ )
{
	$main::cppName = "clang";
	$main::cppVersion = "4.2";
}
$main::OO_SDK_CC_55_OR_HIGHER = "";
if ( $main::operatingSystem =~ m/darwin/ )
{
	$clangpath = `xcrun -f clang++`;
	$main::OO_SDK_CPP_HOME_SUGGESTION = substr($clangpath, 0, rindex($clangpath, "/"));
} else {
	$main::OO_SDK_CPP_HOME_SUGGESTION = searchprog($main::cppName);
}

$main::OO_SDK_JAVA_HOME = "";
$main::OO_SDK_JAVA_BIN_DIR = "bin";
if ( $main::operatingSystem =~ m/darwin/ )
{
	$main::OO_SDK_JAVA_BIN_DIR="Commands";
}
$main::OO_SDK_JAVA_HOME_SUGGESTION = searchprog("javac");
$main::javaVersion = "1.5.0_01";

$main::OO_SDK_BOOST_HOME_SUGGESTION = "";
$main::boostVersion = "1.48.0";
$main::skipBoostDir = 0;

$main::SDK_AUTO_DEPLOYMENT = "";
$main::SDK_AUTO_DEPLOYMENT_SUGGESTION = "YES";

$main::OO_SDK_OUTPUT_DIR_SUGGESTION = "$ENV{HOME}";
$main::OO_SDK_OUTPUT_DIR = "";
$main::skipOutputDir = 0;

$main::return = 0;

if ( $main::operatingSystem =~ m/darwin/ )
{
# used for a SDK as part of the office installation
#    $main::OFFICE_HOME = `cd $main::sdkpath/../../.. && pwd`;
#    chomp($main::OFFICE_HOME);
#    print " Used Office = $main::OFFICE_HOME\n";
	print " Used SDK = $main::OO_SDK_HOME\n\n";

	$main::OFFICE_HOME_SUGGESTION = searchMacOffice();
	while ( (! -d "$main::OFFICE_HOME" ) ||
		((-d "$main::OFFICE_HOME") && (! -d "$main::OFFICE_HOME/Contents/MacOS")) )
	{
	print " Enter the Office installation directory [$main::OFFICE_HOME_SUGGESTION]: ";
	$main::OFFICE_HOME = readStdIn();
	chop($main::OFFICE_HOME);
	if ( $main::OFFICE_HOME eq "" )
	{
		$main::OFFICE_HOME = $main::OFFICE_HOME_SUGGESTION;
	}

	if ( ! -d "$main::OFFICE_HOME" )
	{
		$main::OFFICE_HOME = "";
		print " Error: An office installation is required, please specify the path to a valid installation.\n";
	}

#	$main::OFFICE_BASE_HOME = "$main::OFFICE_HOME/Contents";
	}
} else
{
	$main::OFFICE_HOME_SUGGESTION = searchoffice();

	if ( $main::OFFICE_HOME_SUGGESTION eq "" ) {
	# prepare Office path
	$main::OFFICE_HOME_SUGGESTION = searchprog("soffice");
	}

	if ( ! $main::OFFICE_HOME_SUGGESTION eq "" )
	{
	my $tmpOffice = readlink "$main::OFFICE_HOME_SUGGESTION/soffice";

	if ( $tmpOffice eq "" )
	{
		$tmpOffice = "$main::OFFICE_HOME_SUGGESTION/soffice";
	}

	my $offset = rindex($tmpOffice, "/program/soffice");
	if ( $offset != -1 )
	{
		$main::OFFICE_HOME_SUGGESTION = substr($tmpOffice, 0, $offset);
	} else
	{
		$offset = rindex($tmpOffice, "/soffice");
		if ( $offset != -1 )
		{
		$main::OFFICE_HOME_SUGGESTION = substr($tmpOffice, 0, $offset);
		} else
		{
		$main::OFFICE_HOME_SUGGESTION = "";
		}
	}
	}

	while ( (! -d "$main::OFFICE_HOME" ) ||
		((-d "$main::OFFICE_HOME") && (! -d "$main::OFFICE_HOME/program")) )
	{
	print " Enter the Office installation directory [$main::OFFICE_HOME_SUGGESTION]: ";
	$main::OFFICE_HOME = readStdIn();
	chop($main::OFFICE_HOME);
	if ( $main::OFFICE_HOME eq "" )
	{
		$main::OFFICE_HOME = $main::OFFICE_HOME_SUGGESTION;
	}

	if ( ! -d "$main::OFFICE_HOME" )
	{
		$main::OFFICE_HOME = "";
		print " Error: An office installation is required, please specify the path to a valid installation.\n";
	} else
	{
		# special work for a network installation, no program directory but a link to the soffice binary
		if ( (! -d "$main::OFFICE_HOME/program") && (-e "$main::OFFICE_HOME/soffice") )
		{
		my $soserver = `ls -l $OFFICE_HOME_SUGGESTION/soffice | sed -n 's/.* -> //p'`;
		$soserver= substr($soserver, 0, rindex($soserver, "program") - 1);

		if ( ! -d $soserver )
		{
			$main::OFFICE_HOME = "";
			print " Error: An office installation is required, please specify the path to a valid installation.\n";
		} else
		{
			$main::OFFICE_HOME = $soserver;
		}
		}
	}
	}
}


# prepare GNU make path
while ( (!$main::correctVersion) &&
		((! -d "$main::OO_SDK_MAKE_HOME" ) ||
		 ((-d "$main::OO_SDK_MAKE_HOME") && (! -e "$main::OO_SDK_MAKE_HOME/$main::makeName"))) )
{
	print " Enter GNU make ($main::makeVersion or higher) tools directory [$main::OO_SDK_MAKE_HOME_SUGGESTION]: ";
	$main::OO_SDK_MAKE_HOME = readStdIn();
	chop($main::OO_SDK_MAKE_HOME);
	if ( $main::OO_SDK_MAKE_HOME eq "" )
	{
		$main::OO_SDK_MAKE_HOME = $main::OO_SDK_MAKE_HOME_SUGGESTION;
	}
	if ( (! -d "$main::OO_SDK_MAKE_HOME") ||
		 ((-d "$main::OO_SDK_MAKE_HOME") && (! -e "$main::OO_SDK_MAKE_HOME/$main::makeName")) )
	{
		$main::OO_SDK_MAKE_HOME = "";
		print " Error: GNU make is required, please specify a GNU make tools directory.\n";
	} else
	{
		#check version
		my $testVersion = `$OO_SDK_MAKE_HOME/$main::makeName --version`;
		if ( $testVersion eq "")
		{
			print " Set the environment variable OO_SDK_MAKE_HOME to your GNU build tools directory.\n";
			print " GNU make version $main::makeVersion can be obtained at ftp://ftp.gnu.org/gnu/make/\n";
		} else
		{
			if ($testVersion =~ m#((\d+\.)+\d+)# )
			{
				$testVersion = $1;
			}
			$main::correctVersion = testVersion($main::makeVersion, $testVersion, "$main::OO_SDK_MAKE_HOME/$main::makeName", 1);
			if ( !$main::correctVersion )
			{
				print " The '$main::makeName' command found at '$main::OO_SDK_MAKE_HOME' has a wrong version\n";
				$main::OO_SDK_MAKE_HOME = "";
			}
		}
	}
}

# prepare zip path
$main::correctVersion = 0;
while ( (!$main::correctVersion) &&
		((! -d "$main::OO_SDK_ZIP_HOME" ) ||
		 ((-d "$main::OO_SDK_ZIP_HOME") && (! -e "$main::OO_SDK_ZIP_HOME/zip"))) )
{
	print " Enter zip ($main::zipVersion or higher) tool directory [$main::OO_SDK_ZIP_HOME_SUGGESTION]: ";
	$main::OO_SDK_ZIP_HOME = readStdIn();
	chop($main::OO_SDK_ZIP_HOME);
	if ( $main::OO_SDK_ZIP_HOME eq "" )
	{
		$main::OO_SDK_ZIP_HOME = $main::OO_SDK_ZIP_HOME_SUGGESTION;
	}
	if ( (! -d "$main::OO_SDK_ZIP_HOME") ||
		 ((-d "$main::OO_SDK_ZIP_HOME") && (! -e "$main::OO_SDK_ZIP_HOME/zip")) )
	{
		$main::OO_SDK_ZIP_HOME = "";
		print " Error: zip tool is required, please specify a zip tool directory.\n";
	} else
	{
		#check version
		my $testVersion = `$OO_SDK_ZIP_HOME/zip -h 2>&1 | grep -E Zip | head -n 1`;
		$testVersion =~ s#Zip ([\d.]+) .*#$1#go;
		if ( $testVersion eq "")
		{
			print " Set the environment variable OO_SDK_ZIP_HOME to your zip tool directory.\n";
			print " zip version $main::zipVersion can be obtained at ftp://www.info-zip.org/\n";
		} else
		{
			if ($testVersion =~ m#((\d+\.)+\d+)# )
			{
				$testVersion = $1;
			}
			$main::correctVersion = testVersion($main::zipVersion, $testVersion, "$main::OO_SDK_MAKE_HOME/zip", 1);
			if ( !$main::correctVersion )
			{
				print " The 'zip' command found at '$main::OO_SDK_ZIP_HOME' has a wrong version\n";
				$main::OO_SDK_ZIP_HOME = "";
			}
		}
	}
}

# prepare cat path
$main::correctVersion = 0;
while ( (!$main::correctVersion) &&
		((! -d "$main::OO_SDK_CAT_HOME" ) ||
		((-d "$main::OO_SDK_CAT_HOME") && (! -e "$main::OO_SDK_CAT_HOME/cat"))) )
{
	print " Enter cat tool directory [$main::OO_SDK_CAT_HOME_SUGGESTION]: ";
	$main::OO_SDK_CAT_HOME = readStdIn();
	chop($main::OO_SDK_CAT_HOME);
	if ( $main::OO_SDK_CAT_HOME eq "" )
	{
		$main::OO_SDK_CAT_HOME = $main::OO_SDK_CAT_HOME_SUGGESTION;
	}
	if ( (! -d "$main::OO_SDK_CAT_HOME") ||
		((-d "$main::OO_SDK_CAT_HOME") && (! -e "$main::OO_SDK_CAT_HOME/cat")) )
	{
		$main::OO_SDK_CAT_HOME = "";
		print " Error: cat tool is required, please specify a cat tool directory.\n";
	}
	# else ...
	# TODO check version
	# NOTE: only Linux cat understands --version
}

# prepare sed path
$main::correctVersion = 0;
while ( (!$main::correctVersion) &&
		((! -d "$main::OO_SDK_SED_HOME" ) ||
		((-d "$main::OO_SDK_SED_HOME") && (! -e "$main::OO_SDK_SED_HOME/sed"))) )
{
	print " Enter sed tool directory [$main::OO_SDK_SED_HOME_SUGGESTION]: ";
	$main::OO_SDK_SED_HOME = readStdIn();
	chop($main::OO_SDK_SED_HOME);
	if ( $main::OO_SDK_SED_HOME eq "" )
	{
		$main::OO_SDK_SED_HOME = $main::OO_SDK_SED_HOME_SUGGESTION;
	}
	if ( (! -d "$main::OO_SDK_SED_HOME") ||
		((-d "$main::OO_SDK_SED_HOME") && (! -e "$main::OO_SDK_SED_HOME/sed")) )
	{
		$main::OO_SDK_SED_HOME = "";
		print " Error: sed tool is required, please specify a sed tool directory.\n";
	}
	# else ...
	# TODO check version
	# NOTE: only Linux sed understands --version
}

# prepare C++ compiler path
$main::correctVersion = 0;
while ( (!$main::correctVersion) &&
		((! -d "$main::OO_SDK_CPP_HOME" ) ||
		 ((-d "$main::OO_SDK_CPP_HOME") && (! -e "$main::OO_SDK_CPP_HOME/$main::cpp"))) )
{
	print " C++ compilers where for example a language binding exist:\n";
	print "  - Solaris, Sun WorkShop 6 update 1 C++ 5.2 2000/09/11 or higher\n";
	print "  - Linux, GNU C++ compiler, gcc version 4.0.1 or higher\n";
	print "  - MacOS 64bit, Apple LLVM version 4.2 (clang-425.0.28) or higher\n";
	print "    on MacOS auto detected using xcrun -f clang'\n";

	if ( $main::operatingSystem =~ m/darwin/ )
	{
		# xcrun is used to find the correct clang compiler, just print the result as information
		$main::OO_SDK_CPP_HOME = $main::OO_SDK_CPP_HOME_SUGGESTION;
		print " Used clang compiler: $main::OO_SDK_CPP_HOME\n";
	} else
	{
		print " Enter the directory of the C++ compiler, the directory\n";
		print " where the compiler is located (optional) [$main::OO_SDK_CPP_HOME_SUGGESTION]: ";

		$main::OO_SDK_CPP_HOME = readStdIn();
		chop($main::OO_SDK_CPP_HOME);
		if ( $main::OO_SDK_CPP_HOME eq "" )
		{
			$main::OO_SDK_CPP_HOME = $main::OO_SDK_CPP_HOME_SUGGESTION;
		}
	}

	if ( (!$main::operatingSystem =~ m/darwin/) && (! $main::OO_SDK_CPP_HOME eq "") )
	{
		if ( (! -d "$main::OO_SDK_CPP_HOME") ||
			 ((-d "$main::OO_SDK_CPP_HOME") && (! -e "$main::OO_SDK_CPP_HOME/$main::cppName")) )
		{
			print " Error: Could not find directory '$main::OO_SDK_CPP_HOME'.\n";
			if ( skipChoice("C++ compiler") == 1 )
			{
				$main::correctVersion = 1;
			}
			$main::OO_SDK_CPP_HOME = "";
		} else
		{
			#check version
			if ( $main::cppName eq "gcc" )
			{
				my $testVersion = `$OO_SDK_CPP_HOME/$main::cppName -dumpversion`;
				if ( $testVersion eq "")
				{
					print " The '$main::cppName' command found at $main::OO_SDK_CPP_HOME/$main::cppName is not a ";
					print " GNU compiler.\nSet the environment variable OO_SDK_CPP_HOME to your GNU build tools ";
					print " directory.\nA GNU compiler version $main::cppVersion can be obtained at ";
					print " ftp://ftp.gnu.org/gnu/gcc/\n";
				} else
				{
					$main::correctVersion = testVersion($main::cppVersion, $testVersion, "$main::OO_SDK_CPP_HOME/$main::cppName", 1);
					if ( !$main::correctVersion )
					{
						print " The '$main::cppName' command found at '$main::OO_SDK_CPP_HOME' has a wrong version\n";
						if ( skipChoice("C++ compiler") == 1 )
						{
							$main::correctVersion = 1;
						}

						$main::OO_SDK_CPP_HOME = "";
					}
				}
			} else
			{
				# for Solaris we have to check the version too
				open(FILE, "$OO_SDK_CPP_HOME/$main::cppName -V 2>&1 |");
				my @lines = <FILE>;
				my $testVersion = $lines[0];
				if ( $testVersion eq "")
				{
					print " The '$main::cppName' command found at $main::OO_SDK_CPP_HOME/$main::cppName is not a ";
					print " Solaris C++ compiler.\nSet the environment variable OO_SDK_CPP_HOME to your Solaris C++ compiler directory.\n";
				} else
				{
					if ($testVersion =~ m#((\d+\.)+\d+)# )
					{
						$testVersion = $1;
					}
					$main::correctVersion = testVersion($main::cppVersion, $testVersion, "$main::OO_SDK_CPP_HOME/$main::cppName", 1);
					if ( !$main::correctVersion )
					{
						print " The '$main::cppName' command found at '$main::OO_SDK_CPP_HOME' has a wrong version\n";
						if ( skipChoice("C++ compiler") == 1 )
						{
							$main::correctVersion = 1;
						}

						$main::OO_SDK_CPP_HOME = "";
					} else {
						$main::correctVersion = testVersion("5.5", $testVersion, "$main::OO_SDK_CPP_HOME/$main::cppName", 2);
						if ( $main::correctVersion ) {
							$main::OO_SDK_CC_55_OR_HIGHER = $testVersion;
						}
					}
				}
			}
		}
	} else
	{
		# the C++ compiler is optional
		$main::correctVersion = 1;
	}
}


# prepare Java path
$main::correctVersion = 0;

# prepare Java suggestion (cut bin or Commands directory to be in the root of the Java SDK)
$main::offset = rindex($main::OO_SDK_JAVA_HOME_SUGGESTION, "/$main::OO_SDK_JAVA_BIN_DIR");
if ( $main::offset != -1 )
{
	$main::OO_SDK_JAVA_HOME_SUGGESTION = substr($main::OO_SDK_JAVA_HOME_SUGGESTION, 0, $main::offset);
}

while ( (!$main::correctVersion) &&
		((! -d "$main::OO_SDK_JAVA_HOME" ) ||
		 ((-d "$main::OO_SDK_JAVA_HOME") && (! -e "$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/javac"))) )
{
	print " Enter Java SDK (1.5, recommendation is 1.6 or higher) installation directory (optional) [$main::OO_SDK_JAVA_HOME_SUGGESTION]: ";
	$main::OO_SDK_JAVA_HOME = readStdIn();
	chop($main::OO_SDK_JAVA_HOME);
	if ( $main::OO_SDK_JAVA_HOME eq "" )
	{
		$main::OO_SDK_JAVA_HOME = $main::OO_SDK_JAVA_HOME_SUGGESTION;
	}
	if ( ! $main::OO_SDK_JAVA_HOME eq "" )
	{
		if ( (! -d "$main::OO_SDK_JAVA_HOME") ||
			 ((-d "$main::OO_SDK_JAVA_HOME") && (! -e "$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/javac")) )
		{
			print " Error: Could not find directory '$main::OO_SDK_JAVA_HOME' or '$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/javac'.\n";
			if ( skipChoice("JAVA SDK") == 1 )
			{
				$main::correctVersion = 1;
			}
			$main::OO_SDK_JAVA_HOME = "";
		} else
		{
			#check version
			my $testVersion = `$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/java -version 2>&1 | grep -E "java version" | head -n 1 | sed -e 's#.*version "##' | sed -e 's#".*##'`;
			$testVersion =~ s#([^\n]+)\n#$1#go;

			$main::correctVersion = testVersion($main::javaVersion, $testVersion, "$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/java", 1);
			if ( !$main::correctVersion )
			{
				if ( skipChoice("JAVA SDK") == 1 )
				{
					$main::correctVersion = 1;
				}
				$main::OO_SDK_JAVA_HOME = "";
			}
		}
	}else
	{
		# the Java SDK is optional
		$main::correctVersion = 1;
	}
}

# prepare boost directory (optional)
while ( (!$main::skipBoostDir) &&
		((! -d "$main::OO_SDK_BOOST_HOME" ) ||
		((-d "$main::OO_SDK_BOOST_HOME") && (! -e "$main::OO_SDK_BOOST_HOME/boost/tr1/unordered_map.hpp"))) )
{

	print " Enter boost directory [$main::OO_SDK_BOOST_HOME_SUGGESTION]: ";
	$main::OO_SDK_BOOST_HOME = readStdIn();
	chop($main::OO_SDK_BOOST_HOME);
	if ( $main::OO_SDK_BOOST_HOME eq "" )
	{
		$main::OO_SDK_BOOST_HOME = $main::OO_SDK_BOOST_HOME_SUGGESTION;
	}
	if ( (! -d "$main::OO_SDK_BOOST_HOME") ||
		((-d "$main::OO_SDK_BOOST_HOME") && (! -e "$main::OO_SDK_BOOST_HOME/boost/tr1/unordered_map.hpp")) )
	{
		print " Error: boost couldn't be find or verified, please specify a boost directory.\n";
		if ( skipChoice("optional output directory") == 1 )
		{
			$main::skipBoostDir = 1;
		}
		$main::OO_SDK_BOOST_HOME = "";
	} else
	{
		# the boost directory is optional
		$main::skipBoostDir = 1;
	}
}

# prepare output directory (optional)
while ( (!$main::skipOutputDir) &&
		(! -d "$main::OO_SDK_OUTPUT_DIR") )
{
	print " Default output directory is in your HOME directory.\n";
	print " Enter an existent directory if you prefer a different output directory (optional) [$main::OO_SDK_OUTPUT_DIR_SUGGESTION]: ";

	$main::OO_SDK_OUTPUT_DIR = readStdIn();

	chop($main::OO_SDK_OUTPUT_DIR);
	if ( $main::OO_SDK_OUTPUT_DIR eq "" )
	{
		$main::OO_SDK_OUTPUT_DIR = $main::OO_SDK_OUTPUT_DIR_SUGGESTION;
	}
	if ( ! $main::OO_SDK_OUTPUT_DIR eq "" )
	{
		if ( ! -d "$main::OO_SDK_OUTPUT_DIR" )
		{
			print " Error: Could not find directory '$main::OO_SDK_OUTPUT_DIR'.\n";
			if ( skipChoice("optional output directory") == 1 )
			{
				$main::skipOutputDir = 1;
			}
			$main::OO_SDK_OUTPUT_DIR = "";
		}
	} else
	{
		# the output directory is optional
		$main::skipOutputDir = 1;
	}
}

# prepare auto deployment
while ( $main::SDK_AUTO_DEPLOYMENT eq "" ||
	((! $main::SDK_AUTO_DEPLOYMENT eq "YES") &&
	 (! $main::SDK_AUTO_DEPLOYMENT eq "NO")) )
{
	print " Automatic deployment of UNO components (YES/NO) [$main::SDK_AUTO_DEPLOYMENT_SUGGESTION]: ";
	$main::SDK_AUTO_DEPLOYMENT = uc <STDIN>;
	chop($main::SDK_AUTO_DEPLOYMENT);
	if ( $main::SDK_AUTO_DEPLOYMENT eq "" )
	{
	$main::SDK_AUTO_DEPLOYMENT = "YES";
	}
}

prepareScriptFile("setsdkenv_unix.sh.in", "setsdkenv_unix.sh");
chmod 0644, "$main::OO_SDK_CONFIG_HOME/$main::hostname/setsdkenv_unix.sh";

print "\n";
print " ************************************************************************\n";
print " * ... your SDK environment has been prepared.\n";
print " * For each time you want to use this configured SDK environment, you\n";
print " * have to run the \"setsdkenv_unix\" script file!\n";
print " * Alternatively can you source one of the scripts\n";
print " *   \"$main::OO_SDK_CONFIG_HOME/$main::hostname/setsdkenv_unix.sh\"\n";
print " * to get an environment without starting a new shell.\n";
print " ************************************************************************\n\n";

exit $return;

sub skipChoice
{
	my $msg = shift;
	my $skip = "";
	while ( !( $skip eq "yes" || $skip eq "no") )
	{
		print " Do you want to skip the choice of the '$msg' (YES/NO): [YES] ";
		$skip = lc <STDIN>;
		chop($skip);
		if ( $skip eq "" ) { $skip = "yes"; } # default
		if ( $skip eq "yes" )
		{
			return 1;
		}
	}
	return 0;
}

sub resolveLink
{
	my $base= shift;
	my $link= shift;

	my $resolvedpath = "$base/$link";
	my $linktarget = readlink "$resolvedpath";
	my $resolvedlink = "";

	while ( $linktarget ne "") {

	if ( $linktarget =~ m/^\/.*/ )
	{
		$resolvedpath = "$linktarget";
	} else {
		$resolvedpath = `cd $base/$linktarget; pwd`;
		chop $resolvedpath;
	}
	$base = dirname("$resolvedpath");

	$linktarget = readlink "$resolvedpath";
	}

	$resolvedlink = `cd $resolvedpath; pwd`;
	chop $resolvedlink;
	return $resolvedlink;
}

sub searchprog
{
	my $_search= shift;
	my $tmpPath = `echo "\$PATH"`;
	my @pathList = split(":" , $tmpPath);
	my $progDir = "";

	if ( $_search eq "javac" )
	{
		if ( $main::operatingSystem =~ m/darwin/ ) {
			$progDir = resolveLink("/System/Library/Frameworks/JavaVM.Framework/Versions", "CurrentJDK");

			if ( -e "$progDir/$main::OO_SDK_JAVA_BIN_DIR/javac" )
			{
				return "$progDir/$main::OO_SDK_JAVA_BIN_DIR";
			}
		}

		if ( $main::operatingSystem =~ m/solaris/ ) {
			$progDir = resolveLink("/usr/jdk", "latest");
			if ( -e "$progDir/$main::OO_SDK_JAVA_BIN_DIR/javac" )
			{
				return "$progDir/$main::OO_SDK_JAVA_BIN_DIR";
			}
		}
	}

	if ( $_search eq "gmake" && $main::operatingSystem =~ m/solaris/ ) {
		if ( -e "/usr/sfw/bin/gmake" )
		{
			return "/usr/sfw/bin";
		}
	}

	foreach $i (@pathList)
	{
		chomp ($i);

		if ( -e "$i/$_search" )
		{

			if ( index($i, "/") == 0 )
			{
				# # absolute path; leave unchanged
				$progDir = $i;
			} else
			{
				$progDir = `cd "$i"; pwd`;
			}
			return $progDir
		}
	}
	return $progDir
}

sub searchMacOffice
{
	if (-d "/Applications/OpenOffice.app" ) {
		return "/Applications/OpenOffice.app"
	}
	return "";
}

sub searchoffice
{
	my $offset = rindex($main::sdkpath, "/openoffice");
	my $tmpOffice = substr($main::sdkpath, 0, $offset);
	my $officepath = "$tmpOffice/openoffice$main::OO_MAJORVERSION";

#	if ( $main::OO_MINORVERSION > 0) {
#		$officepath = "$officepath$main::OO_MINORVERSION";
#	}

	# search corresponding office for this SDK
	if (-d $officepath && -e "$officepath/program/soffice") {
		return $officepath;
	}
	return "";
}


sub testVersion
{
	my $tmpMustBeVersion = shift;
	my $tmpTestVersion = shift;
	my $toolName = shift;
	# 1=check + message 2=check only
	my $checkOnly = shift;
	my @mustBeVersion = split(/\.|_|-/,$tmpMustBeVersion);
	my @testVersion = split(/\.|_|-/,$tmpTestVersion);
	my $length = $#mustBeVersion;

	if ($#testVersion < $#mustBeVersion) {
		$length = $#testVersion;
	}

	for ($i=0; $i <= $length; $i++ )
	{
		if ( @testVersion[$i] > @mustBeVersion[$i] )
		{
			return 1; # 1 indicates a correct version
		}

		if ( @testVersion[$i] < @mustBeVersion[$i] )
		{
			if ( $#checkOnly == 1 ) {
				print " The command '$toolName' has the version $tmpTestVersion.\n";
				print " The SDK requires at least the version $tmpMustBeVersion.\n";
			}
			return 0;
		}
	}

	return 1; # 1 indicates a correct version
}

sub readStdIn
{
	my $tmpstdin = <STDIN>;
	if ( index($tmpstdin, "\$") != -1)
	{
		return `echo $tmpstdin`;
	}

	return $tmpstdin;
}

sub prepareScriptFile()
{
	my $inputFile = shift;
	my $outputFile = shift;

	if ( ! -d "$main::OO_SDK_CONFIG_HOME/$main::hostname" )
	{
		system("mkdir -p $main::OO_SDK_CONFIG_HOME/$main::hostname");
	}

	open ( FILEIN, "$main::sdkpath/$inputFile" ) || die "\nERROR: could not open '$main::sdkpath/$inputFile' for reading";
	open ( FILEOUT, ">$main::OO_SDK_CONFIG_HOME/$main::hostname/$outputFile" ) || die "\nERROR: could not open '$main::OO_SDK_CONFIG_HOME/$main::hostname/$outputFile' for writing";

	while ( <FILEIN> )
	{
		$_ =~ s#\@OO_SDK_NAME\@#$main::OO_SDK_NAME#go;
		$_ =~ s#\@OO_SDK_HOME\@#$main::OO_SDK_HOME#go;
		$_ =~ s#\@OFFICE_HOME\@#$main::OFFICE_HOME#go;
		$_ =~ s#\@OO_SDK_MAKE_HOME\@#$main::OO_SDK_MAKE_HOME#go;
		$_ =~ s#\@OO_SDK_ZIP_HOME\@#$main::OO_SDK_ZIP_HOME#go;
		$_ =~ s#\@OO_SDK_CAT_HOME\@#$main::OO_SDK_CAT_HOME#go;
		$_ =~ s#\@OO_SDK_SED_HOME\@#$main::OO_SDK_SED_HOME#go;
		$_ =~ s#\@OO_SDK_CPP_HOME\@#$main::OO_SDK_CPP_HOME#go;
		$_ =~ s#\@OO_SDK_CC_55_OR_HIGHER\@#$main::OO_SDK_CC_55_OR_HIGHER#go;
		$_ =~ s#\@OO_SDK_JAVA_HOME\@#$main::OO_SDK_JAVA_HOME#go;
		$_ =~ s#\@OO_SDK_BOOST_HOME\@#$main::OO_SDK_BOOST_HOME#go;
		$_ =~ s#\@SDK_AUTO_DEPLOYMENT\@#$main::SDK_AUTO_DEPLOYMENT#go;
		$_ =~ s#\@OO_SDK_OUTPUT_DIR\@#$main::OO_SDK_OUTPUT_DIR#go;

		print FILEOUT $_;
	}

	close FILEIN;
	close FILEOUT;
}