#!/bin/sh
#
# configure [ <options> ]

# usage
#
# Prints usage.
#
usage()
{
	cat << EOF

Usage: $0 <options>
options:
  --bochs-debug               Enables bochs serial debug emulation (activated
                              via kernel settings file).
  --build-cross-tools <build tools dir>
                              Assume cross compilation. <build tools dir>
                              defines the location of the build tools sources.
                              They will be compiled and placed in the output
                              directory under "cross-tools". The HAIKU_* tools
                              variables will be set accordingly.
  --build-cross-tools-gcc4 <arch> <build tools dir>
                              Like "--build-cross-tools" just that gcc 4 will
                              be used for cross-compilation. Note, that the
                              resulting Haiku installation built with gcc 4
                              will not be binary compatible with BeOS R5.
                              <arch> specifies the target architecture, either
                              "x86", "ppc", "m68k", "arm" or "mipsel".
  --alternative-gcc-output-dir <dir>
                              Build a Haiku installation that supports running
                              executables built with a gcc version incompatible
                              with the primary gcc (e.g. gcc 2 executables under
                              a gcc 4 Haiku or vice versa). <dir> specifies the
                              output directory of the other gcc. The directory
                              must already be fully configured.
                              Note, that a sub-jam will be executed when
                              building Haiku. When using a jam that is not
                              simply invoked by "jam", the JAM build variable
                              needs to be set accordingly.
                              To disable building the alternative libraries
                              the variable HAIKU_ADD_ALTERNATIVE_GCC_LIBS can be
                              unset in the UserBuildConfig file.
  --cross-tools-prefix <prefix>
                              Assume cross compilation. <prefix> should be a
                              path to the directory where the cross
                              compilation tools are located, plus the platform
                              prefix, e.g. "/path/to/tools/i586-pc-haiku-".
                              This overrides the HAIKU_* tool variables.
  --distro-compatibility <level>
                              The distribution's level of compatibility with
                              the official Haiku distribution. The generated
                              files will contain the respective trademarks
                              accordingly.
                              official -- the official Haiku distribution.
                              compatible -- a Haiku Compatible (tm) distro.
                              default -- any other distro (default value).
  --help                      Prints out this help.
  --include-gpl-addons        Include GPL licensed add-ons.
  --include-patented-code     Enable code that is known to implemented patented
                              ideas and techniques. If this option is not
                              specified, the resulting distribution may still
                              implement patented ideas and techniques. This
                              option only disables code that is currently known
                              to be problematic.
  --include-3rdparty          Include 3rdparty/ in the build system.
  --enable-multiuser          Enable experimental multiuser support.
  --target=TARGET             Select build target platform. [default=${target}]
                              valid targets=r5,bone,dano,haiku
  --use-gcc-pipe              Build with GCC option -pipe. Speeds up the build
                              process, but uses more memory.
  --use-32bit                 Use -m32 flag on 64bit host gcc compiler.
  --use-xattr                 Use Linux xattr support for BeOS attribute
                              emulation. Warning: Make sure your file system
                              supports sufficient attribute sizes (4 KB per
                              file for all attributes won't suffice).

environment variables:
  HAIKU_AR                    The static library archiver. Defaults to "ar".
  HAIKU_CC                    The compiler. Defaults to "gcc".
  HAIKU_LD                    The linker. Defaults to "ld".
  HAIKU_OBJCOPY               The objcopy to be used. Defaults to "objcopy".
  HAIKU_RANLIB                The static library indexer. Defaults to "ranlib".
  HAIKU_YASM                  The yasm assembler (x86 only).
  HAIKU_CPPFLAGS              The preprocessor flags. Defaults to "".
  HAIKU_CCFLAGS               The C flags. Defaults to "".
  HAIKU_CXXFLAGS              The C++ flags. Defaults to "".
  HAIKU_LDFLAGS               The linker flags. Defaults to "".
  HAIKU_ARFLAGS               The flags passed to HAIKU_AR for archiving.
                              Defaults to "cru".
  HAIKU_UNARFLAGS             The flags passed to HAIKU_AR for unarchiving.
                              Defaults to "x".

Non-standard output directories:
  By default all objects, build configuration, and other related files are
  stored in /path/to/haiku_source/generated.  To store objects in a non-default
  location, run "../../relative/path/to/haiku_source/configure <options>" from
  within your non-default location.  "jam [ options ] targets" can then be run
  directly inside your non-default location.  Another option is to invoke "jam
  [ options ] targets" from within haiku_source.  This can be accomplished by
  either "export HAIKU_OUTPUT_DIR=your non-default location" before invoking
  jam or by creating a symlink of haiku_source/generated pointing to your
  non-default location and running jam.


EOF
}

# assertparam
#
# Checks whether at least one parameter is left.
#
assertparam()
{
	if [ $2 -lt 2 ]; then
		echo $0: \`$1\': Parameter expected.
		exit 1
	fi
}

# assertparams
#
# Checks whether at least a certain number of parameters is left.
#
assertparams()
{
	if [ $3 -le $2 ]; then
		echo $0: \`$1\': Not enough parameters.
		exit 1
	fi
}

# standard_gcc_settings
#
# Sets the variables for a GCC platform.
#
standard_gcc_settings()
{
	# PLATFORM_LINKLIBS
	gcclib=`$HAIKU_CC -print-libgcc-file-name`
	gccdir=`dirname ${gcclib}`

	haikuGCCVersion=`$HAIKU_CC -dumpversion`
	haikuGCCMachine=`$HAIKU_CC -dumpmachine`

	HAIKU_GCC_LIB_DIR=${gccdir}
	HAIKU_GCC_LIBGCC=${gccdir}/libgcc.a
	HAIKU_GCC_GLUE_CODE="crtbegin.o crtend.o"
	HAIKU_GCC_HEADERS_DIR="${gccdir}/include
		${gccdir}/include-fixed"
	HAIKU_GCC_LIBGCC_OBJECTS=`$HAIKU_AR t ${HAIKU_GCC_LIBGCC} | grep -v eabi.o`
		# Note: We filter out eabi.o. It's present in gcc's libgcc for PPC and
		# neither needed nor wanted.

	case $haikuGCCVersion in
		4.*)
			# for gcc 4 we use the libstdc++ and libsupc++ that come with the
			# compiler
			haikuStaticLibStdCxx=`$HAIKU_CC -print-file-name=libstdc++.a`
			haikuSharedLibStdCxx=`$HAIKU_CC -print-file-name=libstdc++.so`
			haikuStaticLibSupCxx=`$HAIKU_CC -print-file-name=libsupc++.a`
			haikuSharedLibSupCxx=`$HAIKU_CC -print-file-name=libsupc++.so`

			local headers
			if [ -d $gccdir/../../../../$haikuGCCMachine/include/c++/$haikuGCCVersion ]; then
				headers=$gccdir/../../../../$haikuGCCMachine/include/c++/$haikuGCCVersion
			else
				headers=$gccdir/../../../../include/c++/$haikuGCCVersion
			fi

			haikuCxxHeadersDir=$headers
			for d in $haikuGCCMachine backward ext; do
				# Note: We need the line break, otherwise the line might become
				# too long for jam (512 bytes max).
				haikuCxxHeadersDir="$haikuCxxHeadersDir
					$headers/$d"
			done


			# when not building the crosscompiler, to use cpp headers from
			# tree first, but fallback to local C++ system headers (like <new>)
			# if [ "$buildCrossTools" = "" ]; then
			#	haikuCxxHeadersDir="headers/cpp $haikuCxxHeadersDir"
			# fi

			if [ $haikuStaticLibStdCxx = libstdc++.a ]; then
				haikuStaticLibStdCxx=
			fi
			# we build libstdc++.so ourselves, so we can leave it as is
			# if [ $haikuSharedLibStdCxx = libstdc++.so ]; then
			#	haikuSharedLibStdCxx=
			# fi
			if [ $haikuStaticLibSupCxx = libsupc++.a ]; then
				haikuStaticLibSupCxx=
			fi
			# we build libsupc++.so ourselves, so we can leave it as is
			# if [ $haikuSharedLibSupCxx = libsupc++.so ]; then
			# 	haikuSharedLibSupCxx=
			# fi
		;;
		2.9*)
			# check for correct (most up-to-date) legacy compiler and complain
			# if an older one is installed
			if [ $haikuGCCVersion != $haikuRequiredLegacyGCCVersion ]; then
				echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
				echo "Please download it from www.haiku-os.org...";
				exit 1;
			fi
		;;
	esac
}

# set_default_value
#
# Set the value for a variable, if no value is set yet.
#
set_default_value()
{
	eval "$1=\${$1-$2}"
}

# get_build_tool_path
#
# Gets a usable absolute path of a build tool.
#
get_build_tool_path()
{
	local var="HAIKU_$1"
	local tool=$2
	local path="${crossToolsPrefix}$tool"

	if [ -f "$path" ]; then
		# get absolute path
		local oldPwd="`pwd`"
		cd "`dirname "$path"`"
		path="`pwd`/`basename "$path"`"
		cd $oldPwd
	else
		which "$path" &> /dev/null || {
			echo "Build tool \"$path\" not found." >&2
			exit 1
		}
	fi

	eval "$var=$path"
}

# get cwd and the source directory
currentDir=`pwd`
cd `dirname "$0"`
sourceDir=`pwd`
cd "$currentDir"

# default parameter values
#
platform=`uname`
platformMachine=`uname  -m`
haikuGCCVersion=
haikuGCCMachine=i586-pc-haiku
haikuStaticLibStdCxx=
haikuSharedLibStdCxx=
haikuStaticLibSupCxx=
haikuSharedLibSupCxx=
haikuCxxHeadersDir=
hostGCCVersion=`gcc -dumpversion`
bochsDebug=0
includeGPLAddOns=0
includePatentedCode=0
include3rdParty=0
enableMultiuser=0
distroCompatibility=default
target=haiku
targetArch=x86
useGCCPipe=0
use32bit=0
useXattr=0
crossToolsPrefix=
buildCrossTools=
buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
buildCrossToolsMachine=
alternativeGCCOutputDir=
addAlternativeGCCLibs=

haikuRequiredLegacyGCCVersion="2.95.3-haiku-090629"
export haikuRequiredLegacyGCCVersion
	# version of legacy gcc required to build haiku

set_default_value HAIKU_AR			ar
set_default_value HAIKU_CC			gcc
set_default_value HAIKU_LD			ld
set_default_value HAIKU_OBJCOPY		objcopy
set_default_value HAIKU_RANLIB		ranlib
set_default_value HAIKU_YASM		yasm
set_default_value HAIKU_CPPFLAGS	""
set_default_value HAIKU_CCFLAGS		""
set_default_value HAIKU_CXXFLAGS	""
set_default_value HAIKU_LDFLAGS		""
set_default_value HAIKU_ARFLAGS		cru
set_default_value HAIKU_UNARFLAGS	x

# parse parameters
#
while [ $# -gt 0 ] ; do
	case "$1" in
		--bochs-debug)	bochsDebug=1; shift 1;;
		--build-cross-tools) assertparam "$1" $#; buildCrossTools=$2; shift 2;;
		--build-cross-tools-gcc4)
			assertparams "$1" 2 $#
			buildCrossTools=$3
			buildCrossToolsScript="${buildCrossToolsScript}_gcc4"
			case "$2" in
				x86)	haikuGCCMachine=i586-pc-haiku;;
				ppc)	haikuGCCMachine=powerpc-apple-haiku; targetArch=ppc;;
				m68k)	haikuGCCMachine=m68k-unknown-haiku; targetArch=m86k;;
				arm)	haikuGCCMachine=arm-unknown-haiku; targetArch=arm;;
				mipsel)	haikuGCCMachine=mipsel-unknown-haiku; targetArch=mips;;
				*)		echo "Unsupported target architecture: $2"
						exit 1;;
			esac
			buildCrossToolsMachine=$haikuGCCMachine
			shift 3
			;;
		--alternative-gcc-output-dir)
			assertparam "$1" $#
			cd $2 || exit 1
			alternativeGCCOutputDir=`pwd`
			addAlternativeGCCLibs=1
			cd $currentDir
			shift 2
			;;
		--cross-tools-prefix)
			assertparam "$1" $#
			crossToolsPrefix=$2
			shift 2
			;;
		--help | -h)	usage; exit 0;;
		--include-gpl-addons)	includeGPLAddOns=1; shift 1;;
		--include-patented-code)	includePatentedCode=1; shift 1;;
		--include-3rdparty)	include3rdParty=1; shift 1;;
		--enable-multiuser)	enableMultiuser=1; shift 1;;
		--distro-compatibility)
			assertparam "$1" $#
			distroCompatibility=$2
			case "$distroCompatibility" in
				official)	;;
				compatible)	;;
				default)	;;
				*)			echo "Invalid distro compatibility" \
								"level: $distroCompatibility"
							exit 1;;
			esac
			shift 2
			;;
		--target=*)     target=`echo $1 | cut -d'=' -f2-`; shift 1;;
		--use-gcc-pipe)	useGCCPipe=1; shift 1;;
		--use-32bit)	use32bit=1; shift 1;;
		--use-xattr)	useXattr=1; shift 1;;
		*)				echo Invalid argument: \`$1\'; exit 1;;
	esac
done

# detect the build platform
case "${platform}" in
	BeOS)	revision=`uname -r`
			case "$revision" in
				6.*)	buildPlatform=dano ;;
				5.1)	buildPlatform=dano ;;
				5.0.4)	buildPlatform=bone ;;
				5.0*)	buildPlatform=r5 ;;
				*)		echo Unknown BeOS version: $revision
						exit 1 ;;
			esac
			;;
	Darwin)	buildPlatform=darwin ;;
	FreeBSD)	buildPlatform=freebsd
				if [ "$use32bit" = 1 ] ; then
					echo Unsupported platform: FreeBSD ${platformMachine}
					exit 1
				fi	;;
	Haiku)	buildPlatform=haiku_host ;;
	Linux)	buildPlatform=linux ;;
	OpenBSD) buildPlatform=openbsd ;;
	SunOS)	buildPlatform=sunos ;;
	CYGWIN_NT-*) buildPlatform=cygwin ;;
	*)		echo Unsupported platform: ${platform}
			exit 1 ;;
esac

# check yasm version
if [ $targetArch = "x86" ]; then
	$HAIKU_YASM --version > /dev/null || {
		echo "The yasm assembler version 0.7.0 or later must be installed."
		echo "Download from: http://www.tortall.net/projects/yasm/wiki/Download"
		exit 1
	}

	set -- $($HAIKU_YASM --version | head -n 1)
	versionOK=0
	case $2 in
		0.[0-6].*)		;;
		*)				versionOK=1 ;;
	esac

	if [ $versionOK = 0 ]; then
		echo "The yasm assembler version 0.7.0 or later must be installed."
		echo "The installed version is $2."
		echo "Download from: http://www.tortall.net/projects/yasm/wiki/Download"
		exit 1
	fi
fi

# check for case-sensitive filesystem if on darwin
if [ $buildPlatform = "darwin" ]; then
	diskutil info . | grep -i "case-sensitive" > /dev/null
	if [ $? != 0 ]; then
		echo "You need a case-sensitive file-system to build Haiku."
		echo "Please see the following guide on how to set one up:"
		echo "http://haiku-os.org/documents/dev/how_to_build_haiku_on_mac_os_x"
		exit 1
	fi
fi

# create output directory
if [ "$currentDir" = "$sourceDir" ]; then
	outputDir=$currentDir/generated
else
	outputDir=$currentDir
fi
buildOutputDir="$outputDir/build"
buildAttributesDir="$outputDir/attributes"
mkdir -p "$buildOutputDir" || exit 1

# build cross tools from sources
if [ -n "$buildCrossTools" ]; then
	"$buildCrossToolsScript" $buildCrossToolsMachine "$sourceDir" \
		"$buildCrossTools" "$outputDir" || exit 1
	crossToolsPrefix="$outputDir/cross-tools/bin/${haikuGCCMachine}-"
fi

# cross tools
if [ -n "$crossToolsPrefix" ]; then
	get_build_tool_path AR ar
	get_build_tool_path CC gcc
	get_build_tool_path LD ld
	get_build_tool_path OBJCOPY objcopy
	get_build_tool_path RANLIB ranlib
fi

# prepare gcc settings
standard_gcc_settings

# check whether the Haiku compiler really targets Haiku or BeOS
case "$haikuGCCMachine" in
	*-*-haiku)	;;
	*-*-beos)	;;
	*) echo The compiler specified as Haiku target compiler is not a valid \
			Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
	   echo compiler: $HAIKU_CC
	   echo compiler is configured for target: $haikuGCCMachine
	   exit 1 ;;
esac

# Generate BuildConfig
cat << EOF > "$buildOutputDir/BuildConfig"
# BuildConfig
# Note: This file has been automatically generated by configure.

TARGET_PLATFORM 			?= "${target}" ;
HOST_PLATFORM				?= "${buildPlatform}" ;

BOCHS_DEBUG_HACK					?= "${bochsDebug}" ;
INCLUDE_GPL_ADDONS					?= "${includeGPLAddOns}" ;
HAIKU_INCLUDE_PATENTED_CODE			?= "${includePatentedCode}" ;
HAIKU_INCLUDE_3RDPARTY				?= "${include3rdParty}" ;
HAIKU_ENABLE_MULTIUSER				?= "${enableMultiuser}" ;
HAIKU_DISTRO_COMPATIBILITY			?= "${distroCompatibility}" ;
HAIKU_USE_GCC_PIPE					?= "${useGCCPipe}" ;
HAIKU_HOST_USE_32BIT				?= "${use32bit}" ;
HAIKU_HOST_USE_XATTR				?= "${useXattr}" ;
HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR	?= ${alternativeGCCOutputDir} ;
HAIKU_ADD_ALTERNATIVE_GCC_LIBS		?= ${addAlternativeGCCLibs} ;

HAIKU_GCC_RAW_VERSION		?= ${haikuGCCVersion} ;
HAIKU_GCC_MACHINE			?= ${haikuGCCMachine} ;
HAIKU_GCC_LIB_DIR			?= ${HAIKU_GCC_LIB_DIR} ;
HAIKU_GCC_HEADERS_DIR		?= ${HAIKU_GCC_HEADERS_DIR} ;
HAIKU_GCC_LIBGCC			?= ${HAIKU_GCC_LIBGCC} ;

HAIKU_STATIC_LIBSTDC++		?= ${haikuStaticLibStdCxx} ;
HAIKU_SHARED_LIBSTDC++		?= ${haikuSharedLibStdCxx} ;
HAIKU_STATIC_LIBSUPC++		?= ${haikuStaticLibSupCxx} ;
HAIKU_SHARED_LIBSUPC++		?= ${haikuSharedLibSupCxx} ;
HAIKU_C++_HEADERS_DIR		?= ${haikuCxxHeadersDir} ;

HAIKU_BUILD_ATTRIBUTES_DIR	?= ${buildAttributesDir} ;

HAIKU_AR					?= ${HAIKU_AR} ;
HAIKU_CC					?= ${HAIKU_CC} ;
HAIKU_LD					?= ${HAIKU_LD} ;
HAIKU_OBJCOPY				?= ${HAIKU_OBJCOPY} ;
HAIKU_RANLIB				?= ${HAIKU_RANLIB} ;
HAIKU_YASM					?= ${HAIKU_YASM} ;
HAIKU_CPPFLAGS				?= ${HAIKU_CPPFLAGS} ;
HAIKU_CCFLAGS				?= ${HAIKU_CCFLAGS} ;
HAIKU_CXXFLAGS				?= ${HAIKU_CXXFLAGS} ;
HAIKU_LDFLAGS				?= ${HAIKU_LDFLAGS} ;
HAIKU_ARFLAGS				?= ${HAIKU_ARFLAGS} ;
HAIKU_UNARFLAGS				?= ${HAIKU_UNARFLAGS} ;

HOST_GCC_RAW_VERSION		?= ${hostGCCVersion} ;

EOF

# Libgcc.a objects

cat << EOF > "$buildOutputDir/libgccObjects"
# libgcc.a objects to be linked against libroot.so
# Note: This file has been automatically generated by configure.

HAIKU_GCC_LIBGCC_OBJECTS	?= ${HAIKU_GCC_LIBGCC_OBJECTS} ;
EOF

# Generate Timezones binaries bindings

timezoneSources="africa antarctica asia australasia europe northamerica
	southamerica pacificnew etcetera factory backward"

cat << EOF > "$buildOutputDir/Timezones"
# Timezones used for the build
# Note: This file has been automatically generated by configure.

HAIKU_TIME_ZONE_SOURCES = ${timezoneSources} ;

EOF

for source in ${timezoneSources}; do
	f=$sourceDir/src/data/etc/timezones/$source

TZOBJECTS=`gawk '/^Zone/ { print $2 } /^Link/ { print $3 } ' "$f" `

cat << EOF >> "$buildOutputDir/Timezones"
TZ_OBJECTS on <timezone-source>${source} ?= $TZOBJECTS ;
EOF
done

# Generate a boot strap Jamfile in the output directory.

cat << EOF > $outputDir/Jamfile
# automatically generated Jamfile

HAIKU_TOP			= ${sourceDir} ;
HAIKU_OUTPUT_DIR	= ${outputDir} ;

include [ FDirName \$(HAIKU_TOP) Jamfile ] ;

EOF