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: Specify the board to build for. Must be
87                              one of beagle,rpi1,rpi2,cubieboard4,verdex,overo.
88  --update                    re-runs last configure invocation [must be given
89                              as first option!]
90  --use-clang                 Build with host Clang instead of GCC cross
91                              compiler
92  --use-gcc-pipe              Build with GCC option -pipe. Speeds up the build
93                              process, but uses more memory.
94  --use-gcc-graphite          Build with GCC Graphite engine for loop
95                              optimizations. Only for gcc 4.
96  --use-32bit                 Use -m32 flag on 64bit host gcc compiler.
97  --use-xattr                 Use Linux xattr respectively *BSD extattr support
98                              for BeOS attribute emulation. Warning: Make sure
99                              your file system supports sufficient attribute
100                              sizes (4 KB per file for all attributes won't
101                              suffice).
102  --use-xattr-ref             Use the generic BeOS attribute emulation, but use
103                              Linux xattr respectively *BSD extattr support to
104                              make it more robust (i.e. attribute mix-ups become
105                              less likely).
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 cmd=$2
357	local path=${2%% *}
358
359	if [ -f "$path" ]; then
360		# get absolute path
361		local oldPwd="`pwd`"
362		cd "`dirname "$path"`"
363		path="`pwd`/`basename "$path"`"
364		cd $oldPwd
365	else
366		which "$path" > /dev/null 2>&1 || {
367			echo "Build tool \"$path\" not found." >&2
368			exit 1
369		}
370	fi
371
372	eval "$var=\"$path ${cmd#${2%% *}}\""
373}
374
375is_in_list()
376{
377	local element
378	for element in $2; do
379		if [ "$1" = "$element" ]; then
380			return 0
381		fi
382	done
383	return 1
384}
385
386# check for --help or -h and show usage immediately
387if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
388	usage; exit 0;
389fi
390
391
392# get cwd and the source directory
393currentDir=`pwd`
394cd `dirname "$0"`
395sourceDir=`pwd`
396cd "$currentDir"
397
398# backup the passed arguments
399configureArgs="$@"
400
401# internal default parameter values
402#
403platform=`uname`
404platformMachine=`uname  -m`
405targetArchs=
406buildCrossTools=
407buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
408buildCrossToolsJobs=
409useClang=0
410useGccGraphiteDefault=0
411unknownArchIndex=1
412haikuTargetArchs=
413
414if [ -z "$CC" ]; then
415	CC=gcc
416fi
417
418# exported (BuildSetup) default parameter values
419#
420HOST_GCC_RAW_VERSION=`$CC -dumpversion`
421HOST_GCC_MACHINE=`$CC -dumpmachine`
422HAIKU_INCLUDE_GPL_ADDONS=0
423HAIKU_INCLUDE_PATENTED_CODE=0
424HAIKU_INCLUDE_SOURCES=0
425HAIKU_INCLUDE_3RDPARTY=0
426HAIKU_ENABLE_MULTIUSER=0
427HAIKU_DISTRO_COMPATIBILITY=default
428TARGET_PLATFORM=haiku
429HAIKU_USE_GCC_PIPE=0
430HAIKU_HOST_USE_32BIT=0
431HAIKU_HOST_USE_XATTR=0
432HAIKU_HOST_USE_XATTR_REF=0
433HAIKU_HOST_BUILD_ONLY=0
434HOST_EXTENDED_REGEX_SED="sed -r"
435HOST_GCC_LD=`$CC -print-prog-name=ld`
436HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy`
437HOST_SHA256=
438HOST_HAIKU_PORTER=
439HAIKU_PORTS=
440HAIKU_PORTS_CROSS=
441HAIKU_IS_BOOTSTRAP=0
442HAIKU_BOOT_BOARD=
443HAIKU_NO_DOWNLOADS=0
444
445HAIKU_PACKAGING_ARCHS=
446
447set_default_value HAIKU_NASM		nasm
448
449if sha256sum < /dev/null > /dev/null 2>&1; then
450	HOST_SHA256=sha256sum
451elif sha256 < /dev/null > /dev/null 2>&1; then
452	HOST_SHA256="sha256 -q"
453elif shasum < /dev/null > /dev/null 2>&1; then
454	HOST_SHA256="shasum -a 256"
455else
456	echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2
457	exit 1
458fi
459
460haikuRequiredLegacyGCCVersion="2.95.3-haiku-2014_07_26"
461export haikuRequiredLegacyGCCVersion
462	# version of legacy gcc required to build haiku
463supportedTargetArchs="
464	arm
465	m68k
466	ppc
467	x86
468	x86_64
469	x86_gcc2
470	"
471supportedTargetBoards="
472	beagle
473	rpi1
474	rpi2
475	cubieboard4
476	verdex
477	overo
478	"
479
480# determine output directory
481if [ "$currentDir" = "$sourceDir" ]; then
482	outputDir=$currentDir/generated
483else
484	outputDir=$currentDir
485fi
486buildOutputDir="$outputDir/build"
487HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes"
488buildConfigFile="$buildOutputDir/BuildConfig"
489
490# check for update request
491if [ "$1" = "--update" ]; then
492	if ! [ -e "$buildConfigFile" ]; then
493		echo $0 --update: \'$buildConfigFile\' not found - updating not possible.
494		exit 1
495	fi
496	if ! type perl >/dev/null 2>&1; then
497		echo $0 --update: \'perl\' not found - updating not possible.
498		exit 1
499	fi
500	# convert BuildConfig from jam format to shell format and evaluate it
501	shellConfigFile="${buildConfigFile}.shell"
502	perl "$sourceDir/build/scripts/convert_build_config_to_shell_format.pl" \
503		<"$buildConfigFile" >"$shellConfigFile"
504	. "$shellConfigFile"
505	rm "$shellConfigFile"
506	shift
507fi
508
509# parse parameters
510#
511while [ $# -gt 0 ] ; do
512	case "$1" in
513		--bootstrap)
514			assertparams "$1" 3 $#
515			HOST_HAIKU_PORTER="`absolute_path $2`"
516			HAIKU_PORTS_CROSS="`absolute_path $3`"
517			HAIKU_PORTS="`absolute_path $4`"
518			HAIKU_IS_BOOTSTRAP=1
519			HAIKU_NO_DOWNLOADS=1
520			check_file_exists "$HOST_HAIKU_PORTER" || (
521				echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2
522				exit 1
523			)
524			check_dir_exists "$HAIKU_PORTS" || (
525				echo "Non-existent directory $HAIKU_PORTS" >&2
526				exit 1
527			)
528			check_dir_exists "$HAIKU_PORTS_CROSS" || (
529				echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2
530				exit 1
531			)
532			shift 4
533			;;
534		--build-cross-tools)
535			if [ -z "$buildCrossTools" ]; then
536				assertparams "$1" 2 $#
537				targetArch=$2
538				buildCrossTools=$3
539				shift 3
540			else
541				assertparam "$1" $#
542				targetArch=$2
543				shift 2
544			fi
545			case "$targetArch" in
546				x86_gcc2)	targetMachine=i586-pc-haiku;;
547				x86)		targetMachine=i586-pc-haiku;;
548				x86_64)		targetMachine=x86_64-unknown-haiku;;
549				ppc)		targetMachine=powerpc-apple-haiku;;
550				m68k)		targetMachine=m68k-unknown-haiku;;
551				arm)		targetMachine=arm-unknown-haiku;;
552				*)
553					echo "Unsupported target architecture: $2" >&2
554					exit 1
555					;;
556			esac
557			set_variable buildCrossToolsMachine_$targetArch $targetMachine
558			targetArchs="$targetArchs $targetArch"
559			HAIKU_PACKAGING_ARCHS=
560			;;
561		--cross-tools-prefix)
562			assertparam "$1" $#
563			targetArch=unknown${unknownArchIndex}
564			set_variable crossToolsPrefix_$targetArch "$2"
565			targetArchs="$targetArchs $targetArch"
566			HAIKU_PACKAGING_ARCHS=
567			unknownArchIndex=$(($unknownArchIndex + 1))
568			shift 2
569			;;
570		--distro-compatibility)
571			assertparam "$1" $#
572			HAIKU_DISTRO_COMPATIBILITY=$2
573			case "$HAIKU_DISTRO_COMPATIBILITY" in
574				official)	;;
575				compatible)	;;
576				default)	;;
577				*)			echo "Invalid distro compatibility" \
578								"level: $HAIKU_DISTRO_COMPATIBILITY"
579							exit 1;;
580			esac
581			shift 2
582			;;
583		--enable-multiuser)	HAIKU_ENABLE_MULTIUSER=1; shift 1;;
584		--host-only)	HAIKU_HOST_BUILD_ONLY=1; shift 1;;
585		--include-gpl-addons)	HAIKU_INCLUDE_GPL_ADDONS=1; shift 1;;
586		--include-patented-code)	HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;;
587		--include-sources)	HAIKU_INCLUDE_SOURCES=1; shift 1;;
588		--include-3rdparty)	HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
589        -j*)				buildCrossToolsJobs="$1"; shift 1;;
590		--no-downloads)	HAIKU_NO_DOWNLOADS=1; shift 1;;
591		--target=*)     TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;;
592		--target-arch)
593			assertparam "$1" $#
594			targetArch=$2
595			shift 2
596			if [ ! "$platform" = Haiku ]; then
597				echo "--target-arch can only be specified on Haiku." >&2
598				exit 1
599			fi
600			is_in_list "$targetArch" "$supportedTargetArchs" || (
601				echo "Unsupported target architecture: \"$targetArch\"" >&2
602				exit 1
603			)
604			haikuTargetArchs="$haikuTargetArchs $targetArch"
605			;;
606		--target-board)
607			assertparam "$1" $#
608			HAIKU_BOOT_BOARD=$2
609			is_in_list "$HAIKU_BOOT_BOARD" "$supportedTargetBoards" || (
610				echo "Unsupported target board: \"$HAIKU_BOOT_BOARD\"" >&2
611				exit 1
612			)
613			shift 2
614			;;
615		--use-clang) useClang=1; shift 1;;
616		--use-gcc-pipe)	HAIKU_USE_GCC_PIPE=1; shift 1;;
617		--use-gcc-graphite)	useGccGraphiteDefault=1; shift 1;;
618		--use-32bit)	HAIKU_HOST_USE_32BIT=1; shift 1;;
619		--use-xattr)	HAIKU_HOST_USE_XATTR=1; shift 1;;
620		--use-xattr-ref)	HAIKU_HOST_USE_XATTR_REF=1; shift 1;;
621		*)				echo Invalid argument: \`$1\'; exit 1;;
622	esac
623done
624
625# detect the build platform
626case "${platform}" in
627	Darwin)	HOST_PLATFORM=darwin ;;
628	FreeBSD)	HOST_PLATFORM=freebsd
629				if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then
630					echo Unsupported platform: FreeBSD ${platformMachine}
631					exit 1
632				fi	;;
633	Haiku)	HOST_PLATFORM=haiku_host ;;
634	Linux)	HOST_PLATFORM=linux ;;
635	OpenBSD) HOST_PLATFORM=openbsd ;;
636	SunOS)	HOST_PLATFORM=sunos ;;
637	CYGWIN_NT-*) HOST_PLATFORM=cygwin ;;
638	*)		echo Unsupported platform: ${platform}
639			exit 1 ;;
640esac
641
642# check for case-sensitive filesystem
643mkdir haikuCaseTest 2>/dev/null
644mkdir haikucasetest 2>/dev/null
645caseInsensitive=$?
646rmdir haikuCaseTest haikucasetest 2>/dev/null
647if [ $caseInsensitive != 0 ]; then
648	echo "You need a case-sensitive file-system to build Haiku."
649	if [ $HOST_PLATFORM = "darwin" ]; then
650		echo "You can create a case-sensitive disk image using Disk Utility."
651	fi
652	exit 1
653fi
654
655# determine how to invoke sed with extended regexp support for non-GNU sed
656if [ $HOST_PLATFORM = "darwin" ]; then
657	HOST_EXTENDED_REGEX_SED="sed -E"
658fi
659
660# check if nasm can actually output ELF files
661# (the stock version in OSX can't)
662# XXX: should probably only test for x86* arch
663if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then
664	echo "$HAIKU_NASM cannot generate ELF files. Please install a working version."
665	if [ $HOST_PLATFORM = "darwin" ]; then
666		echo "You can install it from Mac Ports."
667		echo "Mac Ports is available at: http://www.macports.org/"
668	fi
669	exit 1
670fi
671
672# create output directory
673mkdir -p "$buildOutputDir" || exit 1
674
675if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
676	invalidCommand=$sourceDir/build/scripts/host_build_only
677	HAIKU_AR=$invalidCommand
678	HAIKU_CC=$invalidCommand
679	HAIKU_LD=$invalidCommand
680	HAIKU_OBJCOPY=$invalidCommand
681	HAIKU_RANLIB=$invalidCommand
682	HAIKU_ELFEDIT=$invalidCommand
683	HAIKU_NASM=$invalidCommand
684	HAIKU_STRIP=$invalidCommand
685else
686	if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then
687		targetArchs="$HAIKU_PACKAGING_ARCHS"
688	fi
689	HAIKU_PACKAGING_ARCHS=
690
691	# On Haiku determine target architectures and tools automatically.
692	if [ -z "$targetArchs" ]; then
693		if [ $HOST_PLATFORM != haiku_host ]; then
694			echo "Please specify the build tools to use or build (via" \
695				"--cross-tools-prefix or --build-cross-tools) or specify a" \
696				"host-only build (--host-only)." >&2
697			echo "For more info, invoke $0 --help"
698			exit 1
699		fi
700
701		# determine primary architecture
702		targetArch=`package list -i /system/packages/haiku-*.hpkg \
703			| sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'`
704		is_in_list "$targetArch" "$supportedTargetArchs" || (
705			echo "Unsupported target architecture: \"$targetArch\"" >&2
706			exit 1
707		)
708		targetArchs=$targetArch
709
710		set_default_value HAIKU_AR_$targetArch			ar
711		set_default_value HAIKU_CC_$targetArch			gcc
712		set_default_value HAIKU_LD_$targetArch			ld
713		set_default_value HAIKU_OBJCOPY_$targetArch		objcopy
714		set_default_value HAIKU_RANLIB_$targetArch		ranlib
715		set_default_value HAIKU_ELFEDIT_$targetArch		elfedit
716		set_default_value HAIKU_STRIP_$targetArch		strip
717
718		# determine secondary architectures
719		for targetArch in $supportedTargetArchs; do
720			if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then
721				targetArchs="$targetArchs $targetArch"
722				set_default_value HAIKU_AR_$targetArch		ar-$targetArch
723				set_default_value HAIKU_CC_$targetArch		gcc-$targetArch
724				set_default_value HAIKU_LD_$targetArch		ld-$targetArch
725				set_default_value HAIKU_OBJCOPY_$targetArch	objcopy-$targetArch
726				set_default_value HAIKU_RANLIB_$targetArch	ranlib-$targetArch
727				set_default_value HAIKU_ELFEDIT_$targetArch	elfedit-$targetArch
728				set_default_value HAIKU_STRIP_$targetArch	strip-$targetArch
729			fi
730		done
731
732		# The target architectures might have been specified explicitly.
733		if [ -n "$haikuTargetArchs" ]; then
734			for targetArch in $haikuTargetArchs; do
735				is_in_list "$targetArch" "$targetArchs" || (
736					echo "Unsupported target architecture: \"$targetArch\"." \
737						"Only native architectures of the host platform can" \
738						"be specified." >&2
739					exit 1
740				)
741			done
742			targetArchs="$haikuTargetArchs"
743		fi
744	fi
745
746	isPrimaryArch=1
747	for targetArch in $targetArchs; do
748		# Note: targetArch is "unknown<n>" at this point, if a cross-tools
749		# prefix was specified. The standard_gcc_settings call below will get
750		# the actual architecture.
751
752		crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
753
754		# build cross tools from sources
755		if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
756			crossToolsDir="$outputDir/cross-tools-$targetArch"
757			targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
758			script="$buildCrossToolsScript"
759			scriptArgs=
760			if [ $targetArch != x86_gcc2 ]; then
761				script="${script}_gcc4"
762				scriptArgs="$targetMachine"
763				set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch	\
764					$useGccGraphiteDefault
765			fi
766			secondaryArch=
767			if [ -z "$isPrimaryArch" ]; then
768				secondaryArch=$targetArch
769			fi
770
771			case $HOST_PLATFORM in
772				freebsd|openbsd)	MAKE=gmake;;
773				*)					MAKE=make;;
774			esac
775
776			MAKE=$MAKE \
777			SECONDARY_ARCH=$secondaryArch \
778			HAIKU_USE_GCC_GRAPHITE=`get_variable \
779				HAIKU_USE_GCC_GRAPHITE_$targetArch` \
780			HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \
781			"$script" $scriptArgs "$sourceDir" "$buildCrossTools" \
782				"$crossToolsDir" $buildCrossToolsJobs || exit 1
783			crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
784		fi
785
786		# prepare gcc settings and get the actual target architecture
787		if [ $useClang = 1 ]; then
788			target=${crossToolsPrefix##*/}
789			target=${target%-}
790			gcc="clang -target ${target} -no-integrated-as"
791		else
792			gcc="${crossToolsPrefix}gcc"
793		fi
794		if [ -z "${crossToolsPrefix}" ]; then
795			gcc=`get_variable HAIKU_CC_$targetArch`
796		fi
797		standard_gcc_settings "$gcc"
798		targetArch=$standard_gcc_settings_targetArch
799
800		# set default values for flags
801		set_default_value HAIKU_CPPFLAGS_$targetArch	""
802		set_default_value HAIKU_CCFLAGS_$targetArch		""
803		set_default_value HAIKU_CXXFLAGS_$targetArch	""
804		set_default_value HAIKU_LDFLAGS_$targetArch		""
805		set_default_value HAIKU_ARFLAGS_$targetArch		cru
806		set_default_value HAIKU_UNARFLAGS_$targetArch	x
807
808		# Override the cross tools variables, if the tools were built or a
809		# prefix was specified.
810		if [ -n "$crossToolsPrefix" ]; then
811			get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
812			get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
813			get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
814			get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
815			get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
816
817			case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
818				4.*|5.*|6.*)
819					get_build_tool_path ELFEDIT_$targetArch \
820						${crossToolsPrefix}elfedit
821				;;
822			esac
823		fi
824
825		# check whether the Haiku compiler really targets Haiku
826		targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
827		case "$targetMachine" in
828			*-*-haiku)	;;
829			*)
830				echo The compiler specified as Haiku target compiler is not a \
831				valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
832				echo compiler: $HAIKU_CC
833				echo compiler is configured for target: $targetMachine
834				exit 1 ;;
835		esac
836
837		HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
838		isPrimaryArch=
839	done
840fi
841
842# Generate BuildConfig
843cat << EOF > "$buildConfigFile"
844# BuildConfig
845# Note: This file has been automatically generated by configure with the
846# following arguments:
847# ${configureArgs}
848
849TARGET_PLATFORM 			?= "${TARGET_PLATFORM}" ;
850HOST_PLATFORM				?= "${HOST_PLATFORM}" ;
851
852HAIKU_INCLUDE_GPL_ADDONS			?= "${HAIKU_INCLUDE_GPL_ADDONS}" ;
853HAIKU_INCLUDE_PATENTED_CODE			?= "${HAIKU_INCLUDE_PATENTED_CODE}" ;
854HAIKU_INCLUDE_SOURCES				?= "${HAIKU_INCLUDE_SOURCES}" ;
855HAIKU_INCLUDE_3RDPARTY				?= "${HAIKU_INCLUDE_3RDPARTY}" ;
856HAIKU_ENABLE_MULTIUSER				?= "${HAIKU_ENABLE_MULTIUSER}" ;
857HAIKU_DISTRO_COMPATIBILITY			?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
858HAIKU_USE_GCC_PIPE					?= "${HAIKU_USE_GCC_PIPE}" ;
859HAIKU_HOST_USE_32BIT				?= "${HAIKU_HOST_USE_32BIT}" ;
860HAIKU_HOST_USE_XATTR				?= "${HAIKU_HOST_USE_XATTR}" ;
861HAIKU_HOST_USE_XATTR_REF			?= "${HAIKU_HOST_USE_XATTR_REF}" ;
862HAIKU_HOST_BUILD_ONLY				?= "${HAIKU_HOST_BUILD_ONLY}" ;
863
864HAIKU_PACKAGING_ARCHS		?= ${HAIKU_PACKAGING_ARCHS} ;
865
866HAIKU_NO_DOWNLOADS			?= "${HAIKU_NO_DOWNLOADS}" ;
867
868HAIKU_BUILD_ATTRIBUTES_DIR	?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
869
870HAIKU_NASM					?= ${HAIKU_NASM} ;
871HAIKU_BOOT_BOARD			?= ${HAIKU_BOOT_BOARD} ;
872
873HOST_EXTENDED_REGEX_SED		?= ${HOST_EXTENDED_REGEX_SED} ;
874HOST_GCC_RAW_VERSION		?= ${HOST_GCC_RAW_VERSION} ;
875HOST_GCC_MACHINE			?= ${HOST_GCC_MACHINE} ;
876HOST_LD						?= ${HOST_GCC_LD} ;
877HOST_OBJCOPY				?= ${HOST_GCC_OBJCOPY} ;
878HOST_SHA256					?= ${HOST_SHA256} ;
879
880HOST_HAIKU_PORTER			?= ${HOST_HAIKU_PORTER} ;
881HAIKU_PORTS					?= ${HAIKU_PORTS} ;
882HAIKU_PORTS_CROSS			?= ${HAIKU_PORTS_CROSS} ;
883HAIKU_IS_BOOTSTRAP			?= ${HAIKU_IS_BOOTSTRAP} ;
884
885EOF
886
887for targetArch in $HAIKU_PACKAGING_ARCHS; do
888	variables="
889		HAIKU_GCC_RAW_VERSION		HAIKU_GCC_RAW_VERSION
890		HAIKU_GCC_MACHINE			HAIKU_GCC_MACHINE
891		HAIKU_GCC_LIB_DIR			HAIKU_GCC_LIB_DIR
892		HAIKU_CPU					HAIKU_CPU
893		HAIKU_BOOT_LIBGCC			HAIKU_BOOT_LIBGCC
894		HAIKU_BOOT_LIBSUPC++		HAIKU_BOOT_LIBSUPCXX
895		HAIKU_AR					HAIKU_AR
896		HAIKU_CC					HAIKU_CC
897		HAIKU_CC_IS_CLANG			HAIKU_CC_IS_CLANG
898		HAIKU_LD					HAIKU_LD
899		HAIKU_OBJCOPY				HAIKU_OBJCOPY
900		HAIKU_RANLIB				HAIKU_RANLIB
901		HAIKU_ELFEDIT				HAIKU_ELFEDIT
902		HAIKU_STRIP					HAIKU_STRIP
903		HAIKU_CPPFLAGS				HAIKU_CPPFLAGS
904		HAIKU_CCFLAGS				HAIKU_CCFLAGS
905		HAIKU_C++FLAGS				HAIKU_CXXFLAGS
906		HAIKU_LDFLAGS				HAIKU_LDFLAGS
907		HAIKU_ARFLAGS				HAIKU_ARFLAGS
908		HAIKU_UNARFLAGS				HAIKU_UNARFLAGS
909		HAIKU_USE_GCC_GRAPHITE		HAIKU_USE_GCC_GRAPHITE
910		"
911	set -- $variables
912	while [ $# -ge 2 ]; do
913		value=`get_variable ${2}_$targetArch`
914		echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
915		shift 2
916	done
917
918	# For variables that may have long values, distribute them over multiple
919	# lines so that jam doesn't hit the maximum line length.
920	variables="
921		HAIKU_BOOT_C++_HEADERS_DIR	HAIKU_BOOT_CXX_HEADERS_DIR
922		"
923	set -- $variables
924	while [ $# -ge 2 ]; do
925		echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
926		get_variable ${2}_$targetArch | xargs -n 1 echo "   " \
927			>> "$buildConfigFile"
928		echo "    ;" >> "$buildConfigFile"
929		shift 2
930	done
931done
932
933
934# Generate a boot strap Jamfile in the output directory.
935
936cat << EOF > $outputDir/Jamfile
937# automatically generated Jamfile
938
939HAIKU_TOP			= ${sourceDir} ;
940HAIKU_OUTPUT_DIR	= ${outputDir} ;
941
942include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
943
944EOF
945