haiku/configure

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

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

Usage: $0 <options>
options:
  --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.
  --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", "x86_64", "ppc", "m68k", "arm" or "mipsel".
  --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).
  --enable-multiuser          Enable experimental multiuser support.
  --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-sources           Includes the source code of projects that require
                              either an offer of source code or a copy of the
                              patched sources. This is preferable when
                              distributing on physical mediums.
  --include-3rdparty          Include 3rdparty/ in the build system.
  -j<n>                       Only relevant for --build-cross-tools and
                              --build-cross-tools-gcc4. Is passed on to the
                              make building the build tools.
  --target=TARGET             Select build target platform.
                              [default=${TARGET_PLATFORM}]
                              valid targets=r5,bone,dano,haiku
  --update                    re-runs last configure invocation [must be given
                              as first option!]
  --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
}

# real_path
#
# returns the realpath of a symbolic link.
#
real_path()
{
	perl -MCwd=realpath -e'print realpath($ARGV[0]), "\n"' "$1"
}

# standard_gcc_settings
#
# Sets the variables for a GCC platform.
#
standard_gcc_settings()
{
	if which greadlink > /dev/null 2>&1; then
		readlink="greadlink -e"
	elif which realpath > /dev/null 2>&1; then
		readlink=realpath
	elif readlink -e / > /dev/null 2>&1; then
		readlink="readlink -e"
	else
		readlink=real_path
	fi

	# PLATFORM_LINKLIBS
	gcclib=`$HAIKU_CC -print-libgcc-file-name`
	gccdir=`dirname ${gcclib}`

	HAIKU_GCC_RAW_VERSION=`$HAIKU_CC -dumpversion`
	HAIKU_GCC_MACHINE=`$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 $HAIKU_GCC_RAW_VERSION in
		4.*)
			# for gcc 4 we use the libstdc++ and libsupc++ that come with the
			# compiler
			HAIKU_STATIC_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.a`
			HAIKU_SHARED_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.so`
			HAIKU_STATIC_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.a`
			HAIKU_SHARED_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.so`

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

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

			# Unset the HAIKU_{SHARED,STATIC}_LIB{STD,SUP}CXX variables, if the
			# compiler didn't give us actual file names. Otherwise resolve
			# symlinks to avoid problems when copying the libraries to the
			# image.

			if [ $HAIKU_STATIC_LIBSTDCXX = libstdc++.a ]; then
				HAIKU_STATIC_LIBSTDCXX=
			else
				HAIKU_STATIC_LIBSTDCXX=`$readlink $HAIKU_STATIC_LIBSTDCXX`
			fi

			if [ $HAIKU_SHARED_LIBSTDCXX = libstdc++.so ]; then
				HAIKU_SHARED_LIBSTDCXX=
			else
				HAIKU_SHARED_LIBSTDCXX=`$readlink $HAIKU_SHARED_LIBSTDCXX`
			fi

			if [ $HAIKU_STATIC_LIBSUPCXX = libsupc++.a ]; then
				HAIKU_STATIC_LIBSUPCXX=
			else
				HAIKU_STATIC_LIBSUPCXX=`$readlink $HAIKU_STATIC_LIBSUPCXX`
			fi

			if [ $HAIKU_SHARED_LIBSUPCXX = libsupc++.so ]; then
				HAIKU_SHARED_LIBSUPCXX=
			else
				HAIKU_SHARED_LIBSUPCXX=`$readlink $HAIKU_SHARED_LIBSUPCXX`
			fi
		;;
		2.9*)
			# check for correct (most up-to-date) legacy compiler and complain
			# if an older one is installed
			if [ $HAIKU_GCC_RAW_VERSION != $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 2>&1 || {
			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"

# backup the passed arguments
configureArgs="$@"

# internal default parameter values
#
platform=`uname`
platformMachine=`uname  -m`
targetArch=x86
crossToolsPrefix=
buildCrossTools=
buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
buildCrossToolsMachine=
buildCrossToolsJobs=

# exported (BuildSetup) default parameter values
#
HAIKU_GCC_RAW_VERSION=
HAIKU_GCC_MACHINE=i586-pc-haiku
HAIKU_STATIC_LIBSTDCXX=
HAIKU_SHARED_LIBSTDCXX=
HAIKU_STATIC_LIBSUPCXX=
HAIKU_SHARED_LIBSUPCXX=
HAIKU_CXX_HEADERS_DIR=
HOST_GCC_RAW_VERSION=`gcc -dumpversion`
HOST_GCC_MACHINE=`gcc -dumpmachine`
HAIKU_INCLUDE_GPL_ADDONS=0
HAIKU_INCLUDE_PATENTED_CODE=0
HAIKU_INCLUDE_SOURCES=0
HAIKU_INCLUDE_3RDPARTY=0
HAIKU_ENABLE_MULTIUSER=0
HAIKU_DISTRO_COMPATIBILITY=default
TARGET_PLATFORM=haiku
HAIKU_USE_GCC_PIPE=0
HAIKU_HOST_USE_32BIT=0
HAIKU_HOST_USE_XATTR=0
HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR=
HAIKU_ADD_ALTERNATIVE_GCC_LIBS=0
HOST_GCC_LD=`gcc -print-prog-name=ld`
HOST_GCC_OBJCOPY=`gcc -print-prog-name=objcopy`
SFDISK_BINARY=sfdisk
HOST_SFDISK=$SFDISK_BINARY

haikuRequiredLegacyGCCVersion="2.95.3-haiku-111122"
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

# determine output directory
if [ "$currentDir" = "$sourceDir" ]; then
	outputDir=$currentDir/generated
else
	outputDir=$currentDir
fi
buildOutputDir="$outputDir/build"
HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes"
buildConfigFile="$buildOutputDir/BuildConfig"

# check for update request
if [ "$1" = "--update" ]; then
	if ! [ -e "$buildConfigFile" ]; then
		echo $0 --update: \'$buildConfigFile\' not found - updating not possible.
		exit 1
	fi
	if ! type perl >/dev/null 2>&1; then
		echo $0 --update: \'perl\' not found - updating not possible.
		exit 1
	fi
	# convert BuildConfig from jam format to shell format and evaluate it
	shellConfigFile="${buildConfigFile}.shell"
	perl "$sourceDir/build/scripts/convert_build_config_to_shell_format.pl" \
		<"$buildConfigFile" >"$shellConfigFile"
	. "$shellConfigFile"
	rm "$shellConfigFile"
	shift
fi

# parse parameters
#
while [ $# -gt 0 ] ; do
	case "$1" in
		--alternative-gcc-output-dir)
			assertparam "$1" $#
			cd $2 || exit 1
			HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR=`pwd`
			HAIKU_ADD_ALTERNATIVE_GCC_LIBS=1
			cd $currentDir
			shift 2
			;;
		--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)	HAIKU_GCC_MACHINE=i586-pc-haiku;;
				x86_64)	HAIKU_GCC_MACHINE=x86_64-pc-haiku; targetArch=x86_64;;
				ppc)	HAIKU_GCC_MACHINE=powerpc-apple-haiku; targetArch=ppc;;
				m68k)	HAIKU_GCC_MACHINE=m68k-unknown-haiku; targetArch=m68k;;
				arm)	HAIKU_GCC_MACHINE=arm-unknown-haiku; targetArch=arm;;
				mipsel)	HAIKU_GCC_MACHINE=mipsel-unknown-haiku; targetArch=mips;;
				*)		echo "Unsupported target architecture: $2"
						exit 1;;
			esac
			buildCrossToolsMachine=$HAIKU_GCC_MACHINE
			shift 3
			;;
		--cross-tools-prefix)
			assertparam "$1" $#
			crossToolsPrefix=$2
			shift 2
			;;
		--distro-compatibility)
			assertparam "$1" $#
			HAIKU_DISTRO_COMPATIBILITY=$2
			case "$HAIKU_DISTRO_COMPATIBILITY" in
				official)	;;
				compatible)	;;
				default)	;;
				*)			echo "Invalid distro compatibility" \
								"level: $HAIKU_DISTRO_COMPATIBILITY"
							exit 1;;
			esac
			shift 2
			;;
		--enable-multiuser)	HAIKU_ENABLE_MULTIUSER=1; shift 1;;
		--help | -h)	usage; exit 0;;
		--include-gpl-addons)	HAIKU_INCLUDE_GPL_ADDONS=1; shift 1;;
		--include-patented-code)	HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;;
		--include-sources)	HAIKU_INCLUDE_SOURCES=1; shift 1;;
		--include-3rdparty)	HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
        -j*)				buildCrossToolsJobs="$1"; shift 1;;
		--target=*)     TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;;
		--use-gcc-pipe)	HAIKU_USE_GCC_PIPE=1; shift 1;;
		--use-32bit)	HAIKU_HOST_USE_32BIT=1; shift 1;;
		--use-xattr)	HAIKU_HOST_USE_XATTR=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.*)	HOST_PLATFORM=dano ;;
				5.1)	HOST_PLATFORM=dano ;;
				5.0.4)	HOST_PLATFORM=bone ;;
				5.0*)	HOST_PLATFORM=r5 ;;
				*)		echo Unknown BeOS version: $revision
						exit 1 ;;
			esac
			;;
	Darwin)	HOST_PLATFORM=darwin ;;
	FreeBSD)	HOST_PLATFORM=freebsd
				SFDISK_BINARY=sfdisk-linux
				if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then
					echo Unsupported platform: FreeBSD ${platformMachine}
					exit 1
				fi	;;
	Haiku)	HOST_PLATFORM=haiku_host ;;
	Linux)	HOST_PLATFORM=linux ;;
	OpenBSD) HOST_PLATFORM=openbsd ;;
	SunOS)	HOST_PLATFORM=sunos ;;
	CYGWIN_NT-*) HOST_PLATFORM=cygwin ;;
	*)		echo Unsupported platform: ${platform}
			exit 1 ;;
esac

# check common locations for sfdisk
for sfdiskDir in /sbin /usr/sbin /usr/local/sbin ; do
	if [ -e ${sfdiskDir}/${SFDISK_BINARY} ]; then
		HOST_SFDISK=${sfdiskDir}/${SFDISK_BINARY}
	fi
done

# check for case-sensitive filesystem if on darwin
if [ $HOST_PLATFORM = "darwin" ]; then
	diskutil info $(pwd)/.. | 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
mkdir -p "$buildOutputDir" || exit 1

# build cross tools from sources
if [ -n "$buildCrossTools" ]; then
	"$buildCrossToolsScript" $buildCrossToolsMachine "$sourceDir" \
		"$buildCrossTools" "$outputDir" $buildCrossToolsJobs || exit 1
	crossToolsPrefix="$outputDir/cross-tools/bin/${HAIKU_GCC_MACHINE}-"
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 "$HAIKU_GCC_MACHINE" 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: $HAIKU_GCC_MACHINE
	   exit 1 ;;
esac

# Generate BuildConfig
cat << EOF > "$buildConfigFile"
# BuildConfig
# Note: This file has been automatically generated by configure with the
# following arguments:
# ${configureArgs}

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

HAIKU_INCLUDE_GPL_ADDONS			?= "${HAIKU_INCLUDE_GPL_ADDONS}" ;
HAIKU_INCLUDE_PATENTED_CODE			?= "${HAIKU_INCLUDE_PATENTED_CODE}" ;
HAIKU_INCLUDE_SOURCES				?= "${HAIKU_INCLUDE_SOURCES}" ;
HAIKU_INCLUDE_3RDPARTY				?= "${HAIKU_INCLUDE_3RDPARTY}" ;
HAIKU_ENABLE_MULTIUSER				?= "${HAIKU_ENABLE_MULTIUSER}" ;
HAIKU_DISTRO_COMPATIBILITY			?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
HAIKU_USE_GCC_PIPE					?= "${HAIKU_USE_GCC_PIPE}" ;
HAIKU_HOST_USE_32BIT				?= "${HAIKU_HOST_USE_32BIT}" ;
HAIKU_HOST_USE_XATTR				?= "${HAIKU_HOST_USE_XATTR}" ;
HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR	?= ${HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR} ;
HAIKU_ADD_ALTERNATIVE_GCC_LIBS		?= ${HAIKU_ADD_ALTERNATIVE_GCC_LIBS} ;

HAIKU_GCC_RAW_VERSION		?= ${HAIKU_GCC_RAW_VERSION} ;
HAIKU_GCC_MACHINE			?= ${HAIKU_GCC_MACHINE} ;
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++		?= ${HAIKU_STATIC_LIBSTDCXX} ;
HAIKU_SHARED_LIBSTDC++		?= ${HAIKU_SHARED_LIBSTDCXX} ;
HAIKU_STATIC_LIBSUPC++		?= ${HAIKU_STATIC_LIBSUPCXX} ;
HAIKU_SHARED_LIBSUPC++		?= ${HAIKU_SHARED_LIBSUPCXX} ;
HAIKU_C++_HEADERS_DIR		?= ${HAIKU_CXX_HEADERS_DIR} ;

HAIKU_BUILD_ATTRIBUTES_DIR	?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;

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		?= ${HOST_GCC_RAW_VERSION} ;
HOST_GCC_MACHINE			?= ${HOST_GCC_MACHINE} ;
HOST_LD						?= ${HOST_GCC_LD} ;
HOST_OBJCOPY				?= ${HOST_GCC_OBJCOPY} ;
HOST_SFDISK					?= ${HOST_SFDISK} ;

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 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