xref: /haiku/configure (revision be622abddb00c474c53631429ad1102d78688d4f) 
1#!/bin/sh
2#
3# configure [ <options> ]
4
5# usage
6#
7# Prints usage.
8#
9usage()
10{
11	cat << EOF
12
13Usage: $0 <options>
14options:
15  --bootstrap <haikuporter> <HaikuPorts cross repo> <HaikuPorts repo>
16                              Prepare for a bootstrap build. No pre-built
17                              packages will be used, instead they will be built
18                              from the sources (in several phases).
19                              <haikuporter> is the path to the haikuporter tool
20                              suitable for the host platform.
21                              <HaikuPorts cross repo> is the path to a checked
22                              out HaikuPorts cross-compilation repository.
23                              <HaikuPorts repo> is the path to a checked out
24                              HaikuPorts repository.
25  --build-cross-tools <arch> [ <build tools dir> ]
26                              Assume cross compilation. <build tools dir>
27                              defines the location of the build tools sources.
28                              They will be compiled and placed in the output
29                              directory under "cross-tools". The HAIKU_* tools
30                              variables will be set accordingly.
31                              <arch> specifies the target architecture, either
32                              "x86_gcc2", "x86", "x86_64", "ppc", "m68k", "arm"
33                              This option and --cross-tools-prefix can be
34                              specified multiple times. The first cross tools
35                              specify the primary tools, the subsequent ones the
36                              secondary tools (for "hybrid" images).
37                              For the first --build-cross-tools the
38                              <build tools dir> argument must be specified and
39                              for the subsequent ones it must be omitted.
40  --cross-tools-prefix <prefix>
41                              Assume cross compilation. <prefix> should be a
42                              path to the directory where the cross
43                              compilation tools are located, plus the platform
44                              prefix, e.g. "/path/to/tools/i586-pc-haiku-".
45                              This overrides the HAIKU_* tool variables.
46  --distro-compatibility <level>
47                              The distribution's level of compatibility with
48                              the official Haiku distribution. The generated
49                              files will contain the respective trademarks
50                              accordingly.
51                              official -- the official Haiku distribution.
52                              compatible -- a Haiku Compatible (tm) distro.
53                              default -- any other distro (default value).
54  --enable-multiuser          Enable experimental multiuser support.
55  --help                      Prints out this help.
56  --host-only                 Configure for building tools for the build host
57                              only. Haiku cannot be built when configured like
58                              this.
59  --include-patented-code     Enable code that is known to implemented patented
60                              ideas and techniques. If this option is not
61                              specified, the resulting distribution may still
62                              implement patented ideas and techniques. This
63                              option only disables code that is currently known
64                              to be problematic.
65  --include-sources           Includes the source code of projects that require
66                              either an offer of source code or a copy of the
67                              patched sources. This is preferable when
68                              distributing on physical mediums.
69  --include-3rdparty          Include 3rdparty/ in the build system.
70  -j<n>                       Only relevant for --build-cross-tools. Is passed
71                              on to the make building the build tools.
72  --no-downloads              Do not download anything. Useful when trying to
73                              bootstrap and build Haiku from source only.
74  --target=TARGET             Select build target platform.
75                              [default=${TARGET_PLATFORM}]
76                              valid targets=r5,bone,dano,haiku
77  --target-arch <arch>        Haiku only: Specify the target architecture to
78                              build for. Must be one of the architectures of the
79                              host system. The installed build tools for that
80                              architecture will be used.
81                              This option can be specified multiple times. The
82                              first occurrence specifies the primary
83                              architecture of the Haiku to build, subsequent
84                              ones the secondary architectures.
85  --update                    re-runs last configure invocation [must be given
86                              as first option!]
87  --use-clang <arch>          Build with host Clang instead of GCC cross
88                              compiler, targeting <arch>
89  --use-gcc-pipe              Build with GCC option -pipe. Speeds up the build
90                              process, but uses more memory.
91  --use-gcc-graphite          Build with GCC Graphite engine for loop
92                              optimizations. Only for gcc 4.
93  --use-32bit                 Use -m32 flag on 64bit host gcc compiler.
94  --use-xattr                 Use Linux xattr respectively *BSD extattr support
95                              for BeOS attribute emulation. Warning: Make sure
96                              your file system supports sufficient attribute
97                              sizes (4 KB per file for all attributes won't
98                              suffice).
99  --use-xattr-ref             Use the generic BeOS attribute emulation, but use
100                              Linux xattr respectively *BSD extattr support to
101                              make it more robust (i.e. attribute mix-ups become
102                              less likely).
103  --with-gdb <gdb sources dir>
104                              specify the path to a GDB source dir, to build
105                              GDB for each arch we build the cross-tools for.
106
107environment variables:
108  CC                          The host compiler. Defaults to "gcc".
109  HAIKU_AR_x86_gcc2           The static library archiver for x86_gcc2.
110                              Defaults to "ar".
111  HAIKU_CC_x86_gcc2           The x86_gcc2 compiler. Defaults to "gcc".
112  HAIKU_LD_x86_gcc2           The x86_gcc2 linker. Defaults to "ld".
113  HAIKU_OBJCOPY_x86_gcc2      The x86_gcc2 objcopy to be used. Defaults to
114                              "objcopy".
115  HAIKU_RANLIB_x86_gcc2       The static library indexer for x86_gcc2. Defaults
116                              to "ranlib".
117  HAIKU_STRIP_x86_gcc2        The x86_gcc2 strip command. Defaults to "strip".
118  HAIKU_NASM                  The nasm assembler (x86 and x86_64 only).
119  HAIKU_CPPFLAGS_<arch>       The preprocessor flags for target architecture
120                              <arch>. Defaults to "".
121  HAIKU_CCFLAGS_<arch>        The C flags for target architecture <arch>.
122                              Defaults to "".
123  HAIKU_CXXFLAGS_<arch>       The C++ flags for target architecture <arch>.
124                              Defaults to "".
125  HAIKU_LDFLAGS_<arch>        The linker flags for target architecture <arch>.
126                              Defaults to "".
127  HAIKU_ARFLAGS_<arch>        The flags passed to HAIKU_AR for target
128                              architecture <arch> for archiving. Defaults to
129                              "cru".
130  HAIKU_UNARFLAGS_<arch>      The flags passed to HAIKU_AR for target
131                              architecture <arch> for unarchiving. Defaults to
132                              "x".
133
134Non-default output directories:
135  By default all objects, build configuration, and other related files are
136  stored in /path/to/haiku_source/generated.  To store objects in a non-default
137  location, run "../../relative/path/to/haiku_source/configure <options>" from
138  within your non-default location.  "jam [ options ] targets" can then be run
139  directly inside your non-default location.  Another option is to invoke "jam
140  [ options ] targets" from within haiku_source.  This can be accomplished by
141  either "export HAIKU_OUTPUT_DIR=your non-default location" before invoking
142  jam or by creating a symlink of haiku_source/generated pointing to your
143  non-default location and running jam.
144
145
146EOF
147}
148
149# assertparam
150#
151# Checks whether at least one parameter is left.
152#
153assertparam()
154{
155	if [ $2 -lt 2 ]; then
156		echo $0: \`$1\': Parameter expected.
157		exit 1
158	fi
159}
160
161# assertparams
162#
163# Checks whether at least a certain number of parameters is left.
164#
165assertparams()
166{
167	if [ $3 -le $2 ]; then
168		echo $0: \`$1\': Not enough parameters.
169		exit 1
170	fi
171}
172
173# absolute_path
174#
175# returns the absolute path of a given path.
176#
177absolute_path()
178{
179	if [ "x$1" != "x${1#/}" ]; then
180		echo "$1"
181	else
182		echo "`pwd`/$1"
183	fi
184}
185
186# check_dir_exists
187#
188# check if a directory exists or not
189#
190check_dir_exists()
191{
192	if [ -d "$1" ]; then
193		return 0
194	else
195		return 1
196	fi
197}
198
199# check_file_exists
200#
201# check if a file exists or not
202#
203check_file_exists()
204{
205	if [ -f "$1" ]; then
206		return 0
207	else
208		return 1
209	fi
210}
211
212# real_path
213#
214# returns the realpath of a symbolic link.
215#
216real_path()
217{
218	perl -MCwd=realpath -e'print realpath($ARGV[0]), "\n"' "$1"
219}
220
221# standard_gcc_settings
222#
223# Sets the variables for a GCC platform.
224#
225standard_gcc_settings()
226{
227	local gcc=$1
228
229	if which greadlink > /dev/null 2>&1; then
230		readlink="greadlink -e"
231	elif which realpath > /dev/null 2>&1; then
232		readlink=realpath
233	elif readlink -e / > /dev/null 2>&1; then
234		readlink="readlink -e"
235	else
236		readlink=real_path
237	fi
238
239	# PLATFORM_LINKLIBS
240	local gcclib=`$gcc -print-libgcc-file-name`
241	local gccdir=`dirname ${gcclib}`
242
243	local gccRawVersion=`$gcc -dumpversion`
244	local gccMachine=`$gcc -dumpmachine`
245
246	# determine architecture from machine triple
247	case $gccMachine in
248		arm-*)		targetCpu=arm;;
249		i?86-*)		targetCpu=x86;;
250		m68k-*)		targetCpu=m68k;;
251		powerpc-*)	targetCpu=ppc;;
252		x86_64-*)	targetCpu=x86_64;;
253		*)
254			echo "Unsupported gcc target machine: $gccMachine" >&2
255			exit 1
256			;;
257	esac
258
259	local targetArch=$targetCpu
260
261	case $gccRawVersion in
262		2.9*)
263			# check for correct (most up-to-date) legacy compiler and complain
264			# if an older one is installed
265			if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion ]; then
266				echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
267				echo "Please download it from www.haiku-os.org...";
268				exit 1;
269			fi
270
271			targetArch=x86_gcc2
272			;;
273	esac
274
275	local bootLibgcc
276	local bootLibSupCxx
277	local bootCxxHeaders
278	case $gccMachine in
279		x86_64-*)
280			# Boot loader is 32-bit, need the 32-bit libs and c++ config
281			bootLibgcc=`$gcc -m32 -print-file-name=libgcc.a`
282			bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a`
283
284			local headersBase=$gccdir/../../../..
285			local headers=$headersBase/$gccMachine/include/c++/$gccRawVersion
286			if [ ! -d $headers ]; then
287				headers=$headersBase/include/c++/$gccRawVersion
288			fi
289			bootCxxHeaders="$headers/$gccMachine/32"
290			;;
291	esac
292
293	# determine whether graphite loop optimization should/can be used
294	local useGraphite=`get_variable HAIKU_USE_GCC_GRAPHITE_$targetCpu`
295	if [ -z "$useGraphite" ]; then
296		useGraphite=$useGccGraphiteDefault
297	fi
298
299	if [ "$useGraphite" != 0 ]; then
300		UNUSED=`echo "int main() {}" | $gcc -xc -c -floop-block - 2>&1`
301		if [ $? != 0 ]; then
302			echo "GCC Graphite loop optimizations cannot be used on $targetArch"
303			useGraphite=0
304		fi
305	fi
306
307	set_variable HAIKU_CPU_$targetArch $targetCpu
308
309	get_build_tool_path CC_$targetArch "$gcc"
310	set_variable HAIKU_CC_IS_CLANG_$targetArch $useClang
311	set_variable HAIKU_GCC_RAW_VERSION_$targetArch $gccRawVersion
312	set_variable HAIKU_GCC_MACHINE_$targetArch $gccMachine
313	set_variable HAIKU_GCC_LIB_DIR_$targetArch $gccdir
314	set_variable HAIKU_BOOT_CXX_HEADERS_DIR_$targetArch "$bootCxxHeaders"
315	set_variable HAIKU_BOOT_LIBSUPCXX_$targetArch "$bootLibSupCxx"
316	set_variable HAIKU_BOOT_LIBGCC_$targetArch $bootLibgcc
317	set_variable HAIKU_USE_GCC_GRAPHITE_$targetArch $useGraphite
318
319	standard_gcc_settings_targetArch=$targetArch
320}
321
322# set_variable
323#
324# Set the value of a variable.
325#
326set_variable()
327{
328	eval "$1=\"$2\""
329}
330
331# get_variable
332#
333# Echo the value of a variable.
334#
335get_variable()
336{
337	eval "echo \${$1}"
338}
339
340# set_default_value
341#
342# Set the value for a variable, if no value is set yet.
343#
344set_default_value()
345{
346	eval "$1=\${$1-$2}"
347}
348
349# get_build_tool_path
350#
351# Gets a usable absolute path of a build tool.
352#
353get_build_tool_path()
354{
355	local var="HAIKU_$1"
356	local varval=`get_variable $var`
357	local cmd=$2
358
359	if [ ! -z "$varval" ]; then
360		# this variable is already set (probably by user) so grab its contents
361		cmd=$varval
362	fi
363
364	local path=${cmd%% *}
365
366	if [ -f "$path" ]; then
367		# get absolute path
368		local oldPwd="`pwd`"
369		cd "`dirname "$path"`"
370		path="`pwd`/`basename "$path"`"
371		cd $oldPwd
372	else
373		which "$path" > /dev/null 2>&1 || {
374			echo "Build tool \"$path\" not found (maybe specify it in $var?)" >&2
375			exit 1
376		}
377	fi
378
379	eval "$var=\"$path ${cmd#${2%% *}}\""
380}
381
382is_in_list()
383{
384	local element
385	for element in $2; do
386		if [ "$1" = "$element" ]; then
387			return 0
388		fi
389	done
390	return 1
391}
392
393# check for --help or -h and show usage immediately
394if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
395	usage; exit 0;
396fi
397
398# ensure umask is not too restrictive
399if [ $(umask) -gt 22 ]; then
400	echo "Your umask is too restrictive (should be: <= 0022; is actually:" $(umask)")"
401	exit 1
402fi
403
404# get cwd and the source directory
405currentDir=`pwd`
406cd `dirname "$0"`
407sourceDir=`pwd`
408cd "$currentDir"
409
410# backup the passed arguments
411configureArgs="$@"
412
413# internal default parameter values
414#
415platform=`uname`
416platformMachine=`uname  -m`
417targetArchs=
418buildCrossTools=
419buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
420buildCrossToolsJobs=
421useClang=0
422useGccGraphiteDefault=0
423unknownArchIndex=1
424haikuTargetArchs=
425gdbSources=
426
427if [ -z "$CC" ]; then
428	CC=gcc
429fi
430
431# exported (BuildSetup) default parameter values
432#
433HOST_GCC_RAW_VERSION=`$CC -dumpversion`
434HOST_GCC_MACHINE=`$CC -dumpmachine`
435HAIKU_INCLUDE_PATENTED_CODE=0
436HAIKU_INCLUDE_SOURCES=0
437HAIKU_INCLUDE_3RDPARTY=0
438HAIKU_ENABLE_MULTIUSER=0
439HAIKU_DISTRO_COMPATIBILITY=default
440TARGET_PLATFORM=haiku
441HAIKU_USE_GCC_PIPE=0
442HAIKU_HOST_USE_32BIT=0
443HAIKU_HOST_USE_XATTR=0
444HAIKU_HOST_USE_XATTR_REF=0
445HAIKU_HOST_BUILD_ONLY=0
446HOST_EXTENDED_REGEX_SED="sed -r"
447HOST_GCC_LD=`$CC -print-prog-name=ld`
448HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy`
449HOST_SHA256=
450HOST_HAIKU_PORTER=
451HAIKU_PORTS=
452HAIKU_PORTS_CROSS=
453HAIKU_IS_BOOTSTRAP=0
454HAIKU_BOOT_BOARD=
455HAIKU_NO_DOWNLOADS=0
456
457HAIKU_PACKAGING_ARCHS=
458
459set_default_value HAIKU_NASM		nasm
460
461if sha256sum < /dev/null > /dev/null 2>&1; then
462	HOST_SHA256=sha256sum
463elif sha256 < /dev/null > /dev/null 2>&1; then
464	HOST_SHA256="sha256 -q"
465elif shasum < /dev/null > /dev/null 2>&1; then
466	HOST_SHA256="shasum -a 256"
467else
468	echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2
469	exit 1
470fi
471
472haikuRequiredLegacyGCCVersion="2.95.3-haiku-2017_07_20"
473export haikuRequiredLegacyGCCVersion
474	# version of legacy gcc required to build haiku
475supportedTargetArchs="
476	arm
477	m68k
478	ppc
479	x86
480	x86_64
481	x86_gcc2
482	"
483
484# determine output directory
485if [ "$currentDir" = "$sourceDir" ]; then
486	outputDir=$currentDir/generated
487else
488	outputDir=$currentDir
489fi
490buildOutputDir="$outputDir/build"
491HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes"
492buildConfigFile="$buildOutputDir/BuildConfig"
493
494# check for update request
495if [ "$1" = "--update" ]; then
496	if ! [ -e "$buildConfigFile" ]; then
497		echo $0 --update: \'$buildConfigFile\' not found - updating not possible.
498		exit 1
499	fi
500	if ! type perl >/dev/null 2>&1; then
501		echo $0 --update: \'perl\' not found - updating not possible.
502		exit 1
503	fi
504	# convert BuildConfig from jam format to shell format and evaluate it
505	shellConfigFile="${buildConfigFile}.shell"
506	perl "$sourceDir/build/scripts/convert_build_config_to_shell_format.pl" \
507		<"$buildConfigFile" >"$shellConfigFile"
508	. "$shellConfigFile"
509	rm "$shellConfigFile"
510	shift
511fi
512
513# parse parameters
514#
515while [ $# -gt 0 ] ; do
516	case "$1" in
517		--bootstrap)
518			assertparams "$1" 3 $#
519			HOST_HAIKU_PORTER="`absolute_path $2`"
520			HAIKU_PORTS_CROSS="`absolute_path $3`"
521			HAIKU_PORTS="`absolute_path $4`"
522			HAIKU_IS_BOOTSTRAP=1
523			HAIKU_NO_DOWNLOADS=1
524			check_file_exists "$HOST_HAIKU_PORTER" || (
525				echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2
526				exit 1
527			)
528			check_dir_exists "$HAIKU_PORTS" || (
529				echo "Non-existent directory $HAIKU_PORTS" >&2
530				exit 1
531			)
532			check_dir_exists "$HAIKU_PORTS_CROSS" || (
533				echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2
534				exit 1
535			)
536			shift 4
537			;;
538		--build-cross-tools)
539			if [ -z "$buildCrossTools" ]; then
540				assertparams "$1" 2 $#
541				targetArch=$2
542				buildCrossTools=$3
543				shift 3
544			else
545				assertparam "$1" $#
546				targetArch=$2
547				shift 2
548			fi
549			case "$targetArch" in
550				x86_gcc2)	targetMachine=i586-pc-haiku;;
551				x86)		targetMachine=i586-pc-haiku;;
552				x86_64)		targetMachine=x86_64-unknown-haiku;;
553				ppc)		targetMachine=powerpc-apple-haiku;;
554				m68k)		targetMachine=m68k-unknown-haiku;;
555				arm)		targetMachine=arm-unknown-haiku;;
556				*)
557					echo "Unsupported target architecture: $2" >&2
558					exit 1
559					;;
560			esac
561			set_variable buildCrossToolsMachine_$targetArch $targetMachine
562			targetArchs="$targetArchs $targetArch"
563			HAIKU_PACKAGING_ARCHS=
564			;;
565		--cross-tools-prefix)
566			assertparam "$1" $#
567			targetArch=unknown${unknownArchIndex}
568			set_variable crossToolsPrefix_$targetArch "$2"
569			targetArchs="$targetArchs $targetArch"
570			HAIKU_PACKAGING_ARCHS=
571			unknownArchIndex=$(($unknownArchIndex + 1))
572			shift 2
573			;;
574		--distro-compatibility)
575			assertparam "$1" $#
576			HAIKU_DISTRO_COMPATIBILITY=$2
577			case "$HAIKU_DISTRO_COMPATIBILITY" in
578				official)	;;
579				compatible)	;;
580				default)	;;
581				*)			echo "Invalid distro compatibility" \
582								"level: $HAIKU_DISTRO_COMPATIBILITY"
583							exit 1;;
584			esac
585			shift 2
586			;;
587		--enable-multiuser)	HAIKU_ENABLE_MULTIUSER=1; shift 1;;
588		--host-only)	HAIKU_HOST_BUILD_ONLY=1; shift 1;;
589		--include-patented-code)	HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;;
590		--include-sources)	HAIKU_INCLUDE_SOURCES=1; shift 1;;
591		--include-3rdparty)	HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
592        -j*)				buildCrossToolsJobs="$1"; shift 1;;
593		--no-downloads)	HAIKU_NO_DOWNLOADS=1; shift 1;;
594		--target=*)     TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;;
595		--target-arch)
596			assertparam "$1" $#
597			targetArch=$2
598			shift 2
599			if [ ! "$platform" = Haiku ]; then
600				echo "--target-arch can only be specified on Haiku." >&2
601				exit 1
602			fi
603			is_in_list "$targetArch" "$supportedTargetArchs" || (
604				echo "Unsupported target architecture: \"$targetArch\"" >&2
605				exit 1
606			)
607			haikuTargetArchs="$haikuTargetArchs $targetArch"
608			;;
609		--use-clang)
610			assertparam "$1" $#
611			targetArch=$2
612			useClang=1
613			case "$targetArch" in
614				x86)		targetMachine=i586-pc-haiku;;
615				x86_64)		targetMachine=x86_64-unknown-haiku;;
616				*)
617					echo "Unsupported target architecture: $2" >&2
618					exit 1
619					;;
620			esac
621			targetArchs="$targetArchs $targetArch"
622			HAIKU_PACKAGING_ARCHS=
623			shift 2
624			;;
625		--use-gcc-pipe)	HAIKU_USE_GCC_PIPE=1; shift 1;;
626		--use-gcc-graphite)	useGccGraphiteDefault=1; shift 1;;
627		--use-32bit)	HAIKU_HOST_USE_32BIT=1; shift 1;;
628		--use-xattr)	HAIKU_HOST_USE_XATTR=1; shift 1;;
629		--use-xattr-ref)	HAIKU_HOST_USE_XATTR_REF=1; shift 1;;
630		--with-gdb)	gdbSources=$2; shift 2;;
631		*)				echo Invalid argument: \`$1\'; exit 1;;
632	esac
633done
634
635# detect the build platform
636case "${platform}" in
637	Darwin)	HOST_PLATFORM=darwin ;;
638	FreeBSD)	HOST_PLATFORM=freebsd
639				if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then
640					echo Unsupported platform: FreeBSD ${platformMachine}
641					exit 1
642				fi	;;
643	Haiku)	HOST_PLATFORM=haiku_host ;;
644	Linux)	HOST_PLATFORM=linux ;;
645	OpenBSD) HOST_PLATFORM=openbsd ;;
646	SunOS)	HOST_PLATFORM=sunos ;;
647	CYGWIN_NT-*) HOST_PLATFORM=cygwin ;;
648	*)		echo Unsupported platform: ${platform}
649			exit 1 ;;
650esac
651
652# check for case-sensitive filesystem
653mkdir haikuCaseTest 2>/dev/null
654mkdir haikucasetest 2>/dev/null
655caseInsensitive=$?
656rmdir haikuCaseTest haikucasetest 2>/dev/null
657if [ $caseInsensitive != 0 ]; then
658	echo "You need a case-sensitive file-system to build Haiku."
659	if [ $HOST_PLATFORM = "darwin" ]; then
660		echo "You can create a case-sensitive disk image using Disk Utility."
661	fi
662	exit 1
663fi
664
665# determine how to invoke sed with extended regexp support for non-GNU sed
666if [ $HOST_PLATFORM = "darwin" ]; then
667	HOST_EXTENDED_REGEX_SED="sed -E"
668fi
669
670# check if nasm can actually output ELF files
671# (the stock version in OSX can't)
672# XXX: should probably only test for x86* arch
673if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then
674	echo "$HAIKU_NASM cannot generate ELF files. Please install a working version."
675	if [ $HOST_PLATFORM = "darwin" ]; then
676		echo "You can install it from Mac Ports."
677		echo "Mac Ports is available at: http://www.macports.org/"
678	fi
679	exit 1
680fi
681
682# create output directory
683mkdir -p "$buildOutputDir" || exit 1
684
685if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
686	invalidCommand=$sourceDir/build/scripts/host_build_only
687	HAIKU_AR=$invalidCommand
688	HAIKU_CC=$invalidCommand
689	HAIKU_LD=$invalidCommand
690	HAIKU_OBJCOPY=$invalidCommand
691	HAIKU_RANLIB=$invalidCommand
692	HAIKU_ELFEDIT=$invalidCommand
693	HAIKU_NASM=$invalidCommand
694	HAIKU_STRIP=$invalidCommand
695else
696	if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then
697		targetArchs="$HAIKU_PACKAGING_ARCHS"
698	fi
699	HAIKU_PACKAGING_ARCHS=
700
701	# On Haiku determine target architectures and tools automatically.
702	if [ -z "$targetArchs" ]; then
703		if [ $HOST_PLATFORM != haiku_host ]; then
704			echo "Please specify the build tools to use or build (via" \
705				"--cross-tools-prefix or --build-cross-tools) or specify a" \
706				"host-only build (--host-only)." >&2
707			echo "For more info, invoke $0 --help"
708			exit 1
709		fi
710
711		# determine primary architecture
712		targetArch=`package list -i /system/packages/haiku-*.hpkg \
713			| sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'`
714		is_in_list "$targetArch" "$supportedTargetArchs" || (
715			echo "Unsupported target architecture: \"$targetArch\"" >&2
716			exit 1
717		)
718		targetArchs=$targetArch
719
720		set_default_value HAIKU_AR_$targetArch			ar
721		set_default_value HAIKU_CC_$targetArch			gcc
722		set_default_value HAIKU_LD_$targetArch			ld
723		set_default_value HAIKU_OBJCOPY_$targetArch		objcopy
724		set_default_value HAIKU_RANLIB_$targetArch		ranlib
725		set_default_value HAIKU_ELFEDIT_$targetArch		elfedit
726		set_default_value HAIKU_STRIP_$targetArch		strip
727
728		# determine secondary architectures
729		for targetArch in $supportedTargetArchs; do
730			if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then
731				targetArchs="$targetArchs $targetArch"
732				set_default_value HAIKU_AR_$targetArch		ar-$targetArch
733				set_default_value HAIKU_CC_$targetArch		gcc-$targetArch
734				set_default_value HAIKU_LD_$targetArch		ld-$targetArch
735				set_default_value HAIKU_OBJCOPY_$targetArch	objcopy-$targetArch
736				set_default_value HAIKU_RANLIB_$targetArch	ranlib-$targetArch
737				set_default_value HAIKU_ELFEDIT_$targetArch	elfedit-$targetArch
738				set_default_value HAIKU_STRIP_$targetArch	strip-$targetArch
739			fi
740		done
741
742		# The target architectures might have been specified explicitly.
743		if [ -n "$haikuTargetArchs" ]; then
744			for targetArch in $haikuTargetArchs; do
745				is_in_list "$targetArch" "$targetArchs" || (
746					echo "Unsupported target architecture: \"$targetArch\"." \
747						"Only native architectures of the host platform can" \
748						"be specified." >&2
749					exit 1
750				)
751			done
752			targetArchs="$haikuTargetArchs"
753		fi
754	fi
755
756	isPrimaryArch=1
757	for targetArch in $targetArchs; do
758		# Note: targetArch is "unknown<n>" at this point, if a cross-tools
759		# prefix was specified. The standard_gcc_settings call below will get
760		# the actual architecture.
761
762		crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
763
764		# build cross tools from sources
765		if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
766			crossToolsDir="$outputDir/cross-tools-$targetArch"
767			targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
768			script="$buildCrossToolsScript"
769			scriptArgs=
770			if [ $targetArch != x86_gcc2 ]; then
771				script="${script}_gcc4"
772				scriptArgs="$targetMachine"
773				set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch	\
774					$useGccGraphiteDefault
775			fi
776			secondaryArch=
777			if [ -z "$isPrimaryArch" ]; then
778				secondaryArch=$targetArch
779			fi
780
781			case $HOST_PLATFORM in
782				freebsd|openbsd)	MAKE=gmake;;
783				*)					MAKE=make;;
784			esac
785
786			MAKE=$MAKE \
787			SECONDARY_ARCH=$secondaryArch \
788			HAIKU_USE_GCC_GRAPHITE=`get_variable \
789				HAIKU_USE_GCC_GRAPHITE_$targetArch` \
790			HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \
791			HAIKU_USE_GDB="$gdbSources" \
792			"$script" $scriptArgs "$sourceDir" "$buildCrossTools" \
793				"$crossToolsDir" $buildCrossToolsJobs || exit 1
794			crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
795		fi
796
797		# prepare gcc settings and get the actual target architecture
798		if [ $useClang = 1 ]; then
799			gcc="clang -target ${targetMachine} -no-integrated-as"
800		elif [ -z "${crossToolsPrefix}" ]; then
801			gcc=`get_variable HAIKU_CC_$targetArch`
802		else
803			gcc="${crossToolsPrefix}gcc"
804		fi
805		standard_gcc_settings "$gcc"
806		targetArch=$standard_gcc_settings_targetArch
807
808		# set default values for flags
809		set_default_value HAIKU_CPPFLAGS_$targetArch	""
810		set_default_value HAIKU_CCFLAGS_$targetArch		""
811		set_default_value HAIKU_CXXFLAGS_$targetArch	""
812		set_default_value HAIKU_LDFLAGS_$targetArch		""
813		set_default_value HAIKU_ARFLAGS_$targetArch		cru
814		set_default_value HAIKU_UNARFLAGS_$targetArch	x
815
816		# Override the cross tools variables, if the tools were built or a
817		# prefix was specified.
818		if [ -n "$crossToolsPrefix" ]; then
819			get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
820			get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
821			get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
822			get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
823			get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
824
825			case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
826				4.*|5.*|6.*|7.*|8.*)
827					get_build_tool_path ELFEDIT_$targetArch \
828						${crossToolsPrefix}elfedit
829				;;
830			esac
831		fi
832
833		# check whether the Haiku compiler really targets Haiku
834		targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
835		case "$targetMachine" in
836			*-*-haiku)	;;
837			*)
838				echo The compiler specified as Haiku target compiler is not a \
839				valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
840				echo compiler: $HAIKU_CC
841				echo compiler is configured for target: $targetMachine
842				exit 1 ;;
843		esac
844
845		HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
846		isPrimaryArch=
847	done
848fi
849
850# Generate BuildConfig
851cat << EOF > "$buildConfigFile"
852# BuildConfig
853# Note: This file has been automatically generated by configure with the
854# following arguments:
855# ${configureArgs}
856
857TARGET_PLATFORM 			?= "${TARGET_PLATFORM}" ;
858HOST_PLATFORM				?= "${HOST_PLATFORM}" ;
859
860HAIKU_INCLUDE_PATENTED_CODE			?= "${HAIKU_INCLUDE_PATENTED_CODE}" ;
861HAIKU_INCLUDE_SOURCES				?= "${HAIKU_INCLUDE_SOURCES}" ;
862HAIKU_INCLUDE_3RDPARTY				?= "${HAIKU_INCLUDE_3RDPARTY}" ;
863HAIKU_ENABLE_MULTIUSER				?= "${HAIKU_ENABLE_MULTIUSER}" ;
864HAIKU_DISTRO_COMPATIBILITY			?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
865HAIKU_USE_GCC_PIPE					?= "${HAIKU_USE_GCC_PIPE}" ;
866HAIKU_HOST_USE_32BIT				?= "${HAIKU_HOST_USE_32BIT}" ;
867HAIKU_HOST_USE_XATTR				?= "${HAIKU_HOST_USE_XATTR}" ;
868HAIKU_HOST_USE_XATTR_REF			?= "${HAIKU_HOST_USE_XATTR_REF}" ;
869HAIKU_HOST_BUILD_ONLY				?= "${HAIKU_HOST_BUILD_ONLY}" ;
870
871HAIKU_PACKAGING_ARCHS		?= ${HAIKU_PACKAGING_ARCHS} ;
872
873HAIKU_NO_DOWNLOADS			?= "${HAIKU_NO_DOWNLOADS}" ;
874
875HAIKU_BUILD_ATTRIBUTES_DIR	?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
876
877HAIKU_NASM					?= ${HAIKU_NASM} ;
878HAIKU_BOOT_BOARD			?= ${HAIKU_BOOT_BOARD} ;
879
880HOST_EXTENDED_REGEX_SED		?= ${HOST_EXTENDED_REGEX_SED} ;
881HOST_GCC_RAW_VERSION		?= ${HOST_GCC_RAW_VERSION} ;
882HOST_GCC_MACHINE			?= ${HOST_GCC_MACHINE} ;
883HOST_LD						?= ${HOST_GCC_LD} ;
884HOST_OBJCOPY				?= ${HOST_GCC_OBJCOPY} ;
885HOST_SHA256					?= ${HOST_SHA256} ;
886
887HOST_HAIKU_PORTER			?= ${HOST_HAIKU_PORTER} ;
888HAIKU_PORTS					?= ${HAIKU_PORTS} ;
889HAIKU_PORTS_CROSS			?= ${HAIKU_PORTS_CROSS} ;
890HAIKU_IS_BOOTSTRAP			?= ${HAIKU_IS_BOOTSTRAP} ;
891
892EOF
893
894for targetArch in $HAIKU_PACKAGING_ARCHS; do
895	variables="
896		HAIKU_GCC_RAW_VERSION		HAIKU_GCC_RAW_VERSION
897		HAIKU_GCC_MACHINE			HAIKU_GCC_MACHINE
898		HAIKU_GCC_LIB_DIR			HAIKU_GCC_LIB_DIR
899		HAIKU_CPU					HAIKU_CPU
900		HAIKU_BOOT_LIBGCC			HAIKU_BOOT_LIBGCC
901		HAIKU_BOOT_LIBSUPC++		HAIKU_BOOT_LIBSUPCXX
902		HAIKU_AR					HAIKU_AR
903		HAIKU_CC					HAIKU_CC
904		HAIKU_CC_IS_CLANG			HAIKU_CC_IS_CLANG
905		HAIKU_LD					HAIKU_LD
906		HAIKU_OBJCOPY				HAIKU_OBJCOPY
907		HAIKU_RANLIB				HAIKU_RANLIB
908		HAIKU_ELFEDIT				HAIKU_ELFEDIT
909		HAIKU_STRIP					HAIKU_STRIP
910		HAIKU_CPPFLAGS				HAIKU_CPPFLAGS
911		HAIKU_CCFLAGS				HAIKU_CCFLAGS
912		HAIKU_C++FLAGS				HAIKU_CXXFLAGS
913		HAIKU_LDFLAGS				HAIKU_LDFLAGS
914		HAIKU_ARFLAGS				HAIKU_ARFLAGS
915		HAIKU_UNARFLAGS				HAIKU_UNARFLAGS
916		HAIKU_USE_GCC_GRAPHITE		HAIKU_USE_GCC_GRAPHITE
917		"
918	set -- $variables
919	while [ $# -ge 2 ]; do
920		value=`get_variable ${2}_$targetArch`
921		echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
922		shift 2
923	done
924
925	# For variables that may have long values, distribute them over multiple
926	# lines so that jam doesn't hit the maximum line length.
927	variables="
928		HAIKU_BOOT_C++_HEADERS_DIR	HAIKU_BOOT_CXX_HEADERS_DIR
929		"
930	set -- $variables
931	while [ $# -ge 2 ]; do
932		echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
933		get_variable ${2}_$targetArch | xargs -n 1 echo "   " \
934			>> "$buildConfigFile"
935		echo "    ;" >> "$buildConfigFile"
936		shift 2
937	done
938done
939
940
941# Generate a boot strap Jamfile in the output directory.
942
943cat << EOF > $outputDir/Jamfile
944# automatically generated Jamfile
945
946HAIKU_TOP			= ${sourceDir} ;
947HAIKU_OUTPUT_DIR	= ${outputDir} ;
948
949include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
950
951EOF
952
953echo "Configured successfully!"
954