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