configure

   1 #!/bin/sh
   2 #
   3 # configure [ <options> ]
   4
   5 # usage
   6 #
   7 # Prints usage.
   8 #
   9 usage()
  10 {
  11         cat << EOF
  12
  13 Usage: $0 <options>
  14 options:
  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,host
  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
 107 environment 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
 134 Non-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
 146 EOF
 147 }
 148
 149 # assertparam
 150 #
 151 # Checks whether at least one parameter is left.
 152 #
 153 assertparam()
 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 #
 165 assertparams()
 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 #
 177 absolute_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 #
 190 check_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 #
 203 check_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 #
 216 real_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 #
 225 standard_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 #
 326 set_variable()
 327 {
 328         eval "$1=\"$2\""
 329 }
 330
 331 # get_variable
 332 #
 333 # Echo the value of a variable.
 334 #
 335 get_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 #
 344 set_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 #
 353 get_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
 375 is_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
 387 if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
 388         usage; exit 0;
 389 fi
 390
 391
 392 # get cwd and the source directory
 393 currentDir=`pwd`
 394 cd `dirname "$0"`
 395 sourceDir=`pwd`
 396 cd "$currentDir"
 397
 398 # backup the passed arguments
 399 configureArgs="$@"
 400
 401 # internal default parameter values
 402 #
 403 platform=`uname`
 404 platformMachine=`uname  -m`
 405 targetArchs=
 406 buildCrossTools=
 407 buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
 408 buildCrossToolsJobs=
 409 useClang=0
 410 useGccGraphiteDefault=0
 411 unknownArchIndex=1
 412 haikuTargetArchs=
 413
 414 if [ -z "$CC" ]; then
 415         CC=gcc
 416 fi
 417
 418 # exported (BuildSetup) default parameter values
 419 #
 420 HOST_GCC_RAW_VERSION=`$CC -dumpversion`
 421 HOST_GCC_MACHINE=`$CC -dumpmachine`
 422 HAIKU_INCLUDE_GPL_ADDONS=0
 423 HAIKU_INCLUDE_PATENTED_CODE=0
 424 HAIKU_INCLUDE_SOURCES=0
 425 HAIKU_INCLUDE_3RDPARTY=0
 426 HAIKU_ENABLE_MULTIUSER=0
 427 HAIKU_DISTRO_COMPATIBILITY=default
 428 TARGET_PLATFORM=haiku
 429 HAIKU_USE_GCC_PIPE=0
 430 HAIKU_HOST_USE_32BIT=0
 431 HAIKU_HOST_USE_XATTR=0
 432 HAIKU_HOST_USE_XATTR_REF=0
 433 HAIKU_HOST_BUILD_ONLY=0
 434 HOST_EXTENDED_REGEX_SED="sed -r"
 435 HOST_GCC_LD=`$CC -print-prog-name=ld`
 436 HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy`
 437 HOST_SHA256=
 438 HOST_HAIKU_PORTER=
 439 HAIKU_PORTS=
 440 HAIKU_PORTS_CROSS=
 441 HAIKU_IS_BOOTSTRAP=0
 442 HAIKU_BOOT_BOARD=
 443 HAIKU_NO_DOWNLOADS=0
 444
 445 HAIKU_PACKAGING_ARCHS=
 446
 447 set_default_value HAIKU_NASM            nasm
 448
 449 if sha256sum < /dev/null > /dev/null 2>&1; then
 450         HOST_SHA256=sha256sum
 451 elif sha256 < /dev/null > /dev/null 2>&1; then
 452         HOST_SHA256="sha256 -q"
 453 elif shasum < /dev/null > /dev/null 2>&1; then
 454         HOST_SHA256="shasum -a 256"
 455 else
 456         echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2
 457         exit 1
 458 fi
 459
 460 haikuRequiredLegacyGCCVersion="2.95.3-haiku-2014_07_26"
 461 export haikuRequiredLegacyGCCVersion
 462         # version of legacy gcc required to build haiku
 463 supportedTargetArchs="
 464         arm
 465         m68k
 466         ppc
 467         x86
 468         x86_64
 469         x86_gcc2
 470         "
 471 supportedTargetBoards="
 472         beagle
 473         rpi1
 474         rpi2
 475         cubieboard4
 476         verdex
 477         overo
 478         "
 479
 480 # determine output directory
 481 if [ "$currentDir" = "$sourceDir" ]; then
 482         outputDir=$currentDir/generated
 483 else
 484         outputDir=$currentDir
 485 fi
 486 buildOutputDir="$outputDir/build"
 487 HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes"
 488 buildConfigFile="$buildOutputDir/BuildConfig"
 489
 490 # check for update request
 491 if [ "$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
 507 fi
 508
 509 # parse parameters
 510 #
 511 while [ $# -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
 623 done
 624
 625 # detect the build platform
 626 case "${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 ;;
 640 esac
 641
 642 # check for case-sensitive filesystem
 643 mkdir haikuCaseTest 2>/dev/null
 644 mkdir haikucasetest 2>/dev/null
 645 caseInsensitive=$?
 646 rmdir haikuCaseTest haikucasetest 2>/dev/null
 647 if [ $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
 653 fi
 654
 655 # determine how to invoke sed with extended regexp support for non-GNU sed
 656 if [ $HOST_PLATFORM = "darwin" ]; then
 657         HOST_EXTENDED_REGEX_SED="sed -E"
 658 fi
 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
 663 if [ "$("$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
 670 fi
 671
 672 # create output directory
 673 mkdir -p "$buildOutputDir" || exit 1
 674
 675 if [ "$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
 685 else
 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.*|7.*)
 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
 840 fi
 841
 842 # Generate BuildConfig
 843 cat << EOF > "$buildConfigFile"
 844 # BuildConfig
 845 # Note: This file has been automatically generated by configure with the
 846 # following arguments:
 847 # ${configureArgs}
 848
 849 TARGET_PLATFORM                         ?= "${TARGET_PLATFORM}" ;
 850 HOST_PLATFORM                           ?= "${HOST_PLATFORM}" ;
 851
 852 HAIKU_INCLUDE_GPL_ADDONS                        ?= "${HAIKU_INCLUDE_GPL_ADDONS}" ;
 853 HAIKU_INCLUDE_PATENTED_CODE                     ?= "${HAIKU_INCLUDE_PATENTED_CODE}" ;
 854 HAIKU_INCLUDE_SOURCES                           ?= "${HAIKU_INCLUDE_SOURCES}" ;
 855 HAIKU_INCLUDE_3RDPARTY                          ?= "${HAIKU_INCLUDE_3RDPARTY}" ;
 856 HAIKU_ENABLE_MULTIUSER                          ?= "${HAIKU_ENABLE_MULTIUSER}" ;
 857 HAIKU_DISTRO_COMPATIBILITY                      ?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
 858 HAIKU_USE_GCC_PIPE                                      ?= "${HAIKU_USE_GCC_PIPE}" ;
 859 HAIKU_HOST_USE_32BIT                            ?= "${HAIKU_HOST_USE_32BIT}" ;
 860 HAIKU_HOST_USE_XATTR                            ?= "${HAIKU_HOST_USE_XATTR}" ;
 861 HAIKU_HOST_USE_XATTR_REF                        ?= "${HAIKU_HOST_USE_XATTR_REF}" ;
 862 HAIKU_HOST_BUILD_ONLY                           ?= "${HAIKU_HOST_BUILD_ONLY}" ;
 863
 864 HAIKU_PACKAGING_ARCHS           ?= ${HAIKU_PACKAGING_ARCHS} ;
 865
 866 HAIKU_NO_DOWNLOADS                      ?= "${HAIKU_NO_DOWNLOADS}" ;
 867
 868 HAIKU_BUILD_ATTRIBUTES_DIR      ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
 869
 870 HAIKU_NASM                                      ?= ${HAIKU_NASM} ;
 871 HAIKU_BOOT_BOARD                        ?= ${HAIKU_BOOT_BOARD} ;
 872
 873 HOST_EXTENDED_REGEX_SED         ?= ${HOST_EXTENDED_REGEX_SED} ;
 874 HOST_GCC_RAW_VERSION            ?= ${HOST_GCC_RAW_VERSION} ;
 875 HOST_GCC_MACHINE                        ?= ${HOST_GCC_MACHINE} ;
 876 HOST_LD                                         ?= ${HOST_GCC_LD} ;
 877 HOST_OBJCOPY                            ?= ${HOST_GCC_OBJCOPY} ;
 878 HOST_SHA256                                     ?= ${HOST_SHA256} ;
 879
 880 HOST_HAIKU_PORTER                       ?= ${HOST_HAIKU_PORTER} ;
 881 HAIKU_PORTS                                     ?= ${HAIKU_PORTS} ;
 882 HAIKU_PORTS_CROSS                       ?= ${HAIKU_PORTS_CROSS} ;
 883 HAIKU_IS_BOOTSTRAP                      ?= ${HAIKU_IS_BOOTSTRAP} ;
 884
 885 EOF
 886
 887 for 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
 931 done
 932
 933
 934 # Generate a boot strap Jamfile in the output directory.
 935
 936 cat << EOF > $outputDir/Jamfile
 937 # automatically generated Jamfile
 938
 939 HAIKU_TOP                       = ${sourceDir} ;
 940 HAIKU_OUTPUT_DIR        = ${outputDir} ;
 941
 942 include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
 943
 944 EOF