configure

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