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