haiku/configure

1122 lines
34 KiB
Plaintext
Raw Normal View History

#!/bin/sh
#
# configure [ <options> ]
# usage
#
# Prints usage.
#
usage()
{
cat << EOF
Usage: $0 <options>
options:
--help Prints out this help.
--update Re-runs last configure invocation [must be given
as first option!]
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
--bootstrap <haikuporter> <HaikuPorts cross repo> <HaikuPorts repo>
Prepare for a bootstrap build. No pre-built
packages will be used, instead they will be built
from the sources (in several phases).
<haikuporter> is the path to the haikuporter tool
suitable for the host platform.
<HaikuPorts cross repo> is the path to a checked
out HaikuPorts cross-compilation repository.
<HaikuPorts repo> is the path to a checked out
HaikuPorts repository.
2013-07-26 01:52:11 +04:00
--build-cross-tools <arch> [ <build tools dir> ]
Assume cross compilation. <build tools dir>
defines the location of the build tools sources.
They will be compiled and placed in the output
directory under "cross-tools". The HAIKU_* tools
variables will be set accordingly.
<arch> specifies the target architecture, either
"x86_gcc2", "x86", "x86_64", "ppc", "m68k", "arm", "arm64"
2013-07-26 01:52:11 +04:00
This option and --cross-tools-prefix can be
specified multiple times. The first cross tools
specify the primary tools, the subsequent ones the
secondary tools (for "hybrid" images).
For the first --build-cross-tools the
<build tools dir> argument must be specified and
for the subsequent ones it must be omitted.
--cross-tools-prefix <prefix>
Assume cross compilation. <prefix> should be a
path to the directory where the cross
compilation tools are located, plus the platform
prefix, e.g. "/path/to/tools/i586-pc-haiku-".
This overrides the HAIKU_* tool variables.
--distro-compatibility <level>
The distribution's level of compatibility with
the official Haiku distribution. The generated
files will contain the respective trademarks
accordingly.
official -- the official Haiku distribution.
compatible -- a Haiku Compatible (tm) distro.
default -- any other distro (default value).
--host-only Configure for building tools for the build host
only. Haiku cannot be built when configured like
this.
--include-sources Includes the source code of projects that require
either an offer of source code or a copy of the
patched sources. This is preferable when
distributing on physical mediums.
--include-3rdparty Include 3rdparty/ in the build system.
-j<n> Only relevant for --build-cross-tools. Is passed
on to the make building the build tools.
--no-downloads Do not download anything. Useful when trying to
bootstrap and build Haiku from source only.
--target-arch <arch> Haiku only: Specify the target architecture to
build for. Must be one of the architectures of the
host system. The installed build tools for that
architecture will be used.
This option can be specified multiple times. The
first occurrence specifies the primary
architecture of the Haiku to build, subsequent
ones the secondary architectures.
--use-clang <arch> Build with host Clang instead of GCC cross
compiler, targeting <arch>
--use-gcc-pipe Build with GCC option -pipe. Speeds up the build
process, but uses more memory.
--use-gcc-graphite Build with GCC Graphite engine for loop
optimizations. (Only for GCC 4+.)
--use-32bit Use -m32 flag on 64bit host gcc compiler.
--no-full-xattr Do not use Linux/*BSD/Darwin's native extended file
attributes as Haiku attributes. If they are still
available, they will be used to store hashes for
the attribute emulation layer.
--no-xattr Do not use Linux/*BSD/Darwin's native extended file
attributes for Haiku extended attributes at all,
even if they are available.
--with-gdb <gdb sources dir>
specify the path to a GDB source dir, to build
GDB for each arch we build the cross-tools for.
environment variables:
CC The host compiler. Defaults to "gcc".
HAIKU_AR_<arch> The static library archiver for <arch>.
2013-07-26 01:52:11 +04:00
Defaults to "ar".
HAIKU_CC_<arch> The compiler for <arch>. Defaults to "gcc".
HAIKU_LD_<arch> The <arch> linker. Defaults to "ld".
HAIKU_OBJCOPY_<arch> The <arch> objcopy to be used. Defaults to
2013-07-26 01:52:11 +04:00
"objcopy".
HAIKU_RANLIB_<arch> The static library indexer for <arch>. Defaults
2013-07-26 01:52:11 +04:00
to "ranlib".
HAIKU_STRIP_<arch> The <arch> strip command. Defaults to "strip".
HAIKU_NASM The nasm assembler (x86 and x86_64 only).
2013-07-26 01:52:11 +04:00
HAIKU_CPPFLAGS_<arch> The preprocessor flags for target architecture
<arch>. Defaults to "".
HAIKU_CCFLAGS_<arch> The C flags for target architecture <arch>.
Defaults to "".
HAIKU_CXXFLAGS_<arch> The C++ flags for target architecture <arch>.
Defaults to "".
HAIKU_LINKFLAGS_<arch> The flags passed to the compiler when linking for
target architecture <arch>. Defaults to "".
2013-07-26 01:52:11 +04:00
HAIKU_LDFLAGS_<arch> The linker flags for target architecture <arch>.
Defaults to "".
HAIKU_ARFLAGS_<arch> The flags passed to HAIKU_AR for target
architecture <arch> for archiving. Defaults to
"cru".
HAIKU_UNARFLAGS_<arch> The flags passed to HAIKU_AR for target
architecture <arch> for unarchiving. Defaults to
"x".
Non-default output directories:
By default all objects, build configuration, and other related files are
stored in /path/to/haiku_source/generated. To store objects in a non-default
location, run "../../relative/path/to/haiku_source/configure <options>" from
within your non-default location. "jam [ options ] targets" can then be run
directly inside your non-default location. Another option is to invoke "jam
[ options ] targets" from within haiku_source. This can be accomplished by
either "export HAIKU_OUTPUT_DIR=your non-default location" before invoking
jam or by creating a symlink of haiku_source/generated pointing to your
non-default location and running jam.
EOF
}
# assertparam
#
# Checks whether at least one parameter is left.
#
assertparam()
{
if [ $2 -lt 2 ]; then
echo $0: \`$1\': Parameter expected.
exit 1
fi
}
# assertparams
#
# Checks whether at least a certain number of parameters is left.
#
assertparams()
{
if [ $3 -le $2 ]; then
echo $0: \`$1\': Not enough parameters.
exit 1
fi
}
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
# absolute_path
#
# returns the absolute path of a given path.
#
absolute_path()
{
if [ "x$1" != "x${1#/}" ]; then
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
echo "$1"
else
echo "`pwd`/$1"
fi
}
# check_dir_exists
#
# check if a directory exists or not
#
check_dir_exists()
{
if [ -d "$1" ]; then
return 0
else
return 1
fi
}
# check_file_exists
#
# check if a file exists or not
#
check_file_exists()
{
if [ -f "$1" ]; then
return 0
else
return 1
fi
}
# real_path
#
# returns the realpath of a symbolic link.
#
real_path()
{
perl -MCwd=realpath -e'print realpath($ARGV[0]), "\n"' "$1"
}
# relative_to
#
# returns $1 relative to $2
#
relative_to()
{
perl -e 'use File::Spec; print File::Spec->abs2rel(@ARGV) . "\n"' \
$1 $2
}
# valid_toolchain
#
# check if a toolchain is valid
#
valid_toolchain()
{
TRIPLET="$1"
BASE="$2"
SOURCE="$3"
if [ ! -d "$BASE" ]; then
return 1
fi
if [ -f "$BASE/bin/$TRIPLET-gcc" ]; then
[ "$BASE/bin/$TRIPLET-gcc" -nt "$SOURCE/legacy/gcc/configure" ] && \
[ "$BASE/bin/$TRIPLET-gcc" -nt "$SOURCE/gcc/gcc/configure" ]
return $?
fi
return 1
}
# standard_gcc_settings
#
# Sets the variables for a GCC platform.
#
standard_gcc_settings()
{
local gcc="$1"
2013-07-26 01:52:11 +04:00
if which greadlink > /dev/null 2>&1; then
readlink="greadlink -e"
elif which realpath > /dev/null 2>&1; then
readlink=realpath
elif readlink -e / > /dev/null 2>&1; then
readlink="readlink -e"
else
readlink=real_path
fi
# PLATFORM_LINKLIBS
2013-07-26 01:52:11 +04:00
local gcclib=`$gcc -print-libgcc-file-name`
local gccdir=`dirname ${gcclib}`
2013-07-26 01:52:11 +04:00
local gccRawVersion=`$gcc -dumpversion`
local gccMachine=`$gcc -dumpmachine`
# determine architecture from machine triple
2013-07-26 01:52:11 +04:00
case $gccMachine in
arm-*) targetCpu=arm;;
arm64-*) targetCpu=arm64;;
2013-07-26 01:52:11 +04:00
i?86-*) targetCpu=x86;;
m68k-*) targetCpu=m68k;;
powerpc-*) targetCpu=ppc;;
x86_64-*) targetCpu=x86_64;;
*)
2013-07-26 01:52:11 +04:00
echo "Unsupported gcc target machine: $gccMachine" >&2
exit 1
;;
esac
2013-07-26 01:52:11 +04:00
local targetArch=$targetCpu
2013-07-26 01:52:11 +04:00
case $gccRawVersion in
2.9*)
# check for correct (most up-to-date) legacy compiler and complain
# if an older one is installed
2013-07-26 01:52:11 +04:00
if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion ]; then
echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
echo "Please download it from www.haiku-os.org...";
exit 1;
fi
2013-07-26 01:52:11 +04:00
targetArch=x86_gcc2
;;
esac
2013-07-26 01:52:11 +04:00
local bootLibgcc
local bootLibSupCxx
local bootCxxHeaders
2013-07-26 01:52:11 +04:00
case $gccMachine in
x86_64-*)
# Boot loader is 32-bit, need the 32-bit libs and c++ config
bootLibgcc=`$gcc -m32 -print-file-name=libgcc.a`
2013-07-26 01:52:11 +04:00
bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a`
local headersBase=$gccdir/../../../..
local headers=$headersBase/$gccMachine/include/c++/$gccRawVersion
if [ ! -d $headers ]; then
headers=$headersBase/include/c++/$gccRawVersion
fi
bootCxxHeaders="$headers/$gccMachine/32"
;;
esac
2013-07-26 01:52:11 +04:00
# determine whether graphite loop optimization should/can be used
local useGraphite=`get_variable HAIKU_USE_GCC_GRAPHITE_$targetCpu`
if [ -z "$useGraphite" ]; then
useGraphite=$useGccGraphiteDefault
fi
if [ "$useGraphite" != 0 ]; then
UNUSED=`echo "int main() {}" | $gcc -xc -c -floop-block - 2>&1`
if [ $? != 0 ]; then
echo "GCC Graphite loop optimizations cannot be used on $targetArch"
useGraphite=0
fi
fi
set_variable HAIKU_CPU_$targetArch $targetCpu
get_build_tool_path CC_$targetArch "$gcc"
2015-11-08 17:58:56 +03:00
set_variable HAIKU_CC_IS_CLANG_$targetArch $useClang
2013-07-26 01:52:11 +04:00
set_variable HAIKU_GCC_RAW_VERSION_$targetArch $gccRawVersion
set_variable HAIKU_GCC_MACHINE_$targetArch $gccMachine
set_variable HAIKU_GCC_LIB_DIR_$targetArch $gccdir
set_variable HAIKU_BOOT_CXX_HEADERS_DIR_$targetArch "$bootCxxHeaders"
2013-07-26 01:52:11 +04:00
set_variable HAIKU_BOOT_LIBSUPCXX_$targetArch "$bootLibSupCxx"
set_variable HAIKU_BOOT_LIBGCC_$targetArch $bootLibgcc
set_variable HAIKU_USE_GCC_GRAPHITE_$targetArch $useGraphite
standard_gcc_settings_targetArch=$targetArch
}
# set_variable
#
# Set the value of a variable.
#
set_variable()
{
eval "$1=\"$2\""
}
# get_variable
#
# Echo the value of a variable.
#
get_variable()
{
eval "echo \${$1}"
}
# set_default_value
#
# Set the value for a variable, if no value is set yet.
#
set_default_value()
{
eval "$1=\${$1-$2}"
}
# get_build_tool_path
#
# Gets a usable absolute path of a build tool.
#
get_build_tool_path()
{
local var="HAIKU_$1"
local varval="`get_variable $var`"
local cmd="$2"
if [ ! -z "$varval" ]; then
# this variable is already set (probably by user) so grab its contents
cmd=$varval
fi
local path=${cmd%% *}
if [ -f "$path" ]; then
# get absolute path from relative path
local oldPwd="`pwd`"
cd "`dirname "$path"`"
path="`pwd`/`basename "$path"`"
cd $oldPwd
else
which "$path" > /dev/null 2>&1 || {
echo "Build tool \"$path\" not found (maybe specify it in $var?)" >&2
exit 1
}
fi
if test "${cmd#* }" != "$cmd"; then
# $cmd contains arguments, so preserve them (and only them)
cmd=${cmd#* }
else
# $cmd does not contain arguments, so unset it
cmd=
fi
eval "$var=\"$path $cmd\""
}
# check_native_xattrs
#
# Checks the host platform's support for extended attributes.
# 0: no support, 1: only enough for xattr-ref, 2: full support
#
check_native_xattrs()
{
local xattr_set=
local xattr_set_args=
local xattr_get=
local xattr_get_args=
case $HOST_PLATFORM in
haiku_host)
xattr_set="addattr"; xattr_set_args="\$NAME \"\$VALUE\""
xattr_get="catattr"; xattr_get_args="\$NAME"
;;
darwin)
xattr_set="xattr"; xattr_set_args="-w \$NAME \"\$VALUE\""
xattr_get="xattr"; xattr_get_args="-p \$NAME"
;;
freebsd)
xattr_set="setextattr"; xattr_set_args="user \$NAME \"\$VALUE\""
xattr_get="getextattr"; xattr_get_args="user \$NAME"
;;
linux)
xattr_set="setfattr"; xattr_set_args="-n user.\$NAME -v \"\$VALUE\""
xattr_get="getfattr"; xattr_get_args="-n user.\$NAME"
;;
*)
return 0
;;
esac
if ! type $xattr_set >/dev/null 2>&1; then
echo "$0: could not find $xattr_set, assuming host has no extended attributes"
return 0
elif ! type $xattr_get >/dev/null 2>&1; then
echo "$0: could not find $xattr_get, assuming host has no extended attributes"
return 0
fi
mkdir -p "$outputDir"
echo "xattr test file" >"$outputDir/xattrtest"
local i=0
# on round 0, we test if we can set 3 attrs of 1K each (enough for xattr-ref)
# on round 1, we test if we can set 3 attrs of 45K each (enough for full xattr)
while [ $i -lt 2 ]; do
local j=0
while [ $j -lt 3 ]; do
NAME=attr$j
VALUE=`printf '%*s' $((1024 + $i * 45056)) "" | tr ' ' x`
if [ `echo -n $VALUE | wc -c` -lt $((1024 + $i * 45056)) ]; then
echo "$0: warning: could not generate test data for extended attributes"
rm "$outputDir/xattrtest"
return $i
elif ! $xattr_set `eval echo \"$xattr_set_args\"` \
"$outputDir/xattrtest" >/dev/null 2>&1 ; then
rm "$outputDir/xattrtest"
return $i
fi
j=$((j+1))
done
i=$((i+1))
done
rm "$outputDir/xattrtest"
return 2
}
is_in_list()
{
local element
for element in $2; do
if [ "$1" = "$element" ]; then
return 0
fi
done
return 1
}
# check for --help or -h and show usage immediately
if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
usage; exit 0;
fi
# get cwd and the source directory
currentDir=`pwd`
cd `dirname "$0"`
sourceDir=`pwd`
cd "$currentDir"
# determine output directory
if [ "$currentDir" = "$sourceDir" ]; then
outputDir=$currentDir/generated
else
outputDir=$currentDir
fi
buildOutputDir="$outputDir/build"
HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes"
buildConfigFile="$buildOutputDir/BuildConfig"
# check for update request
if [ "$1" = "--update" ]; then
if ! [ -e "$buildConfigFile" ]; then
echo $0 --update: \'$buildConfigFile\' not found - updating not possible.
exit 1
fi
# get last configure invocation and flags from BuildConfig and call ourselves with it
lastPwd=`grep "#d " "$buildConfigFile" | cut -c 4-`
lastConfig=`grep "#c " "$buildConfigFile" | cut -c 4-`
lastEnv=`grep "#e " "$buildConfigFile" | cut -c 4-`
lastArgs=`grep "#a " "$buildConfigFile" | cut -c 4-`
if [ -z "$lastConfig" ]; then
echo "$0 --update: The previous configure invocation was not properly" \
"encoded into '$buildConfigFile' - updating not possible."
exit 1
fi
cd $lastPwd
if [ -n "$lastEnv" ]; then
export $lastEnv
fi
$lastConfig $lastArgs
exit $?
fi
# backup the passed arguments
configureArgs="$@"
configurePath=$0
# backup relevant environs
configureEnvirons=
for var in `env`; do
case "$var" in
CC\=*|HAIKU*\=*)
configureEnvirons="$configureEnvirons $var"
;;
esac
done
# ensure umask is not too restrictive
if [ `umask` -gt 22 ]; then
echo Your umask is too restrictive "(should be <= 0022;" is actually `umask`")"
echo
echo Additionally, if the source tree was cloned with a too-restrictive umask,
echo you will need to run \"git checkout\" again to fix this.
exit 1
fi
# ensure git checkout was not done with a restrictive umask
if [ `stat -c '%a' $sourceDir/data/system/boot/SetupEnvironment` -lt 644 ]; then
echo "The source tree was cloned with a umask > 0022. It seems you"
echo have already corrected your umask, but not re-checked-out the
echo source tree. Try running:
echo " git checkout --force"
echo to fix this problem.
exit 1
fi
# internal default parameter values
#
platform=`uname`
platformMachine=`uname -m`
2013-07-26 01:52:11 +04:00
targetArchs=
buildCrossTools=
buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
buildCrossToolsJobs=
useClang=0
2013-07-26 01:52:11 +04:00
useGccGraphiteDefault=0
unknownArchIndex=1
haikuTargetArchs=
gdbSources=
if [ -z "$CC" ]; then
CC=gcc
fi
# exported (BuildSetup) default parameter values
#
HOST_GCC_RAW_VERSION=`$CC -dumpversion`
HOST_GCC_MACHINE=`$CC -dumpmachine`
HAIKU_INCLUDE_SOURCES=0
HAIKU_INCLUDE_3RDPARTY=0
HAIKU_DISTRO_COMPATIBILITY=default
TARGET_PLATFORM=haiku
HAIKU_USE_GCC_PIPE=0
HAIKU_HOST_USE_32BIT=0
HAIKU_HOST_USE_XATTR=
HAIKU_HOST_USE_XATTR_REF=
HAIKU_HOST_BUILD_ONLY=0
HOST_EXTENDED_REGEX_SED="sed -r"
HOST_GCC_LD=`$CC -print-prog-name=ld`
HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy`
HOST_SHA256=
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
HOST_HAIKU_PORTER=
HAIKU_PORTS=
HAIKU_PORTS_CROSS=
HAIKU_IS_BOOTSTRAP=0
HAIKU_NO_DOWNLOADS=0
2013-07-26 01:52:11 +04:00
HAIKU_PACKAGING_ARCHS=
set_default_value HAIKU_NASM nasm
2013-07-26 01:52:11 +04:00
2013-07-06 14:19:46 +04:00
if sha256sum < /dev/null > /dev/null 2>&1; then
HOST_SHA256=sha256sum
2013-07-06 14:19:46 +04:00
elif sha256 < /dev/null > /dev/null 2>&1; then
HOST_SHA256="sha256 -q"
elif shasum < /dev/null > /dev/null 2>&1; then
HOST_SHA256="shasum -a 256"
else
echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2
exit 1
fi
haikuRequiredLegacyGCCVersion="2.95.3-haiku-2017_07_20"
export haikuRequiredLegacyGCCVersion
# version of legacy gcc required to build haiku
supportedTargetArchs="
arm
arm64
m68k
ppc
x86
x86_64
x86_gcc2
"
# parse parameters
#
while [ $# -gt 0 ] ; do
case "$1" in
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
--bootstrap)
assertparams "$1" 3 $#
HOST_HAIKU_PORTER="`absolute_path $2`"
HAIKU_PORTS_CROSS="`absolute_path $3`"
HAIKU_PORTS="`absolute_path $4`"
HAIKU_IS_BOOTSTRAP=1
HAIKU_NO_DOWNLOADS=1
check_file_exists "$HOST_HAIKU_PORTER" || (
echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2
exit 1
)
check_dir_exists "$HAIKU_PORTS" || (
echo "Non-existent directory $HAIKU_PORTS" >&2
exit 1
)
check_dir_exists "$HAIKU_PORTS_CROSS" || (
echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2
exit 1
)
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
shift 4
;;
2013-07-26 01:52:11 +04:00
--build-cross-tools)
if [ -z "$buildCrossTools" ]; then
assertparams "$1" 2 $#
targetArch=$2
buildCrossTools=$3
shift 3
else
assertparam "$1" $#
targetArch=$2
shift 2
fi
case "$targetArch" in
x86_gcc2) targetMachine=i586-pc-haiku;;
x86) targetMachine=i586-pc-haiku;;
x86_64) targetMachine=x86_64-unknown-haiku;;
ppc) targetMachine=powerpc-apple-haiku;;
m68k) targetMachine=m68k-unknown-haiku;;
arm) targetMachine=arm-unknown-haiku;;
*)
echo "Unsupported target architecture: $targetArch" >&2
2013-07-26 01:52:11 +04:00
exit 1
;;
esac
2013-07-26 01:52:11 +04:00
set_variable buildCrossToolsMachine_$targetArch $targetMachine
targetArchs="$targetArchs $targetArch"
;;
--cross-tools-prefix)
assertparam "$1" $#
2013-07-26 01:52:11 +04:00
targetArch=unknown${unknownArchIndex}
set_variable crossToolsPrefix_$targetArch "$2"
targetArchs="$targetArchs $targetArch"
unknownArchIndex=$(($unknownArchIndex + 1))
shift 2
;;
--distro-compatibility)
assertparam "$1" $#
HAIKU_DISTRO_COMPATIBILITY=$2
case "$HAIKU_DISTRO_COMPATIBILITY" in
official) ;;
compatible) ;;
default) ;;
*) echo "Invalid distro compatibility" \
"level: $HAIKU_DISTRO_COMPATIBILITY"
exit 1;;
esac
shift 2
;;
--host-only) HAIKU_HOST_BUILD_ONLY=1; shift 1;;
--include-sources) HAIKU_INCLUDE_SOURCES=1; shift 1;;
--include-3rdparty) HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
-j*) buildCrossToolsJobs="$1"; shift 1;;
--no-downloads) HAIKU_NO_DOWNLOADS=1; shift 1;;
--target-arch)
assertparam "$1" $#
targetArch=$2
shift 2
if [ ! "$platform" = Haiku ]; then
echo "--target-arch can only be specified on Haiku." >&2
exit 1
fi
is_in_list "$targetArch" "$supportedTargetArchs" || (
echo "Unsupported target architecture: \"$targetArch\"" >&2
exit 1
)
haikuTargetArchs="$haikuTargetArchs $targetArch"
;;
--use-clang)
assertparam "$1" $#
targetArch=$2
useClang=1
case "$targetArch" in
x86) targetMachine=i586-pc-haiku;;
x86_64) targetMachine=x86_64-unknown-haiku;;
ppc) targetMachine=powerpc-apple-haiku;;
2018-08-02 02:31:01 +03:00
arm) targetMachine=arm-unknown-haiku;;
arm64) targetMachine=arm64-unknown-haiku;;
*)
echo "Unsupported target architecture: $2" >&2
exit 1
;;
esac
get_build_tool_path clang clang
if [ -z `get_variable "crossToolsPrefix_$targetArch"` ] \
&& [ -z `get_variable buildCrossToolsMachine_$targetArch` ]; then
set_variable crossToolsPrefix_$targetArch llvm-
fi
clangVersion=`$HAIKU_clang -v 2>&1 | head -1 | cut -d " " -f3`
if [ `echo $clangVersion | head -c 1` -lt 7 ]; then
echo "Haiku requires Clang 7 or better to build, but you have $clangVersion."
echo "Please install a newer version."
exit 1
fi
targetArchs="$targetArchs $targetArch"
shift 2
;;
--use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;;
2013-07-26 01:52:11 +04:00
--use-gcc-graphite) useGccGraphiteDefault=1; shift 1;;
--use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;;
--no-full-xattr)HAIKU_HOST_USE_XATTR=0; shift 1;;
--no-xattr) HAIKU_HOST_USE_XATTR_REF=0; shift 1;;
--with-gdb) gdbSources=$2; shift 2;;
*) echo Invalid argument: \`$1\'; exit 1;;
esac
done
# detect the build platform
case "${platform}" in
Darwin) HOST_PLATFORM=darwin ;;
FreeBSD) HOST_PLATFORM=freebsd
if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then
echo Unsupported platform: FreeBSD ${platformMachine}
exit 1
fi ;;
Haiku) HOST_PLATFORM=haiku_host ;;
Linux) HOST_PLATFORM=linux ;;
OpenBSD) HOST_PLATFORM=openbsd ;;
SunOS) HOST_PLATFORM=sunos ;;
CYGWIN_NT-*) HOST_PLATFORM=cygwin ;;
*) echo Unsupported platform: ${platform}
exit 1 ;;
esac
# check for case-sensitive filesystem
mkdir haikuCaseTest 2>/dev/null
mkdir haikucasetest 2>/dev/null
caseInsensitive=$?
2012-07-11 20:41:52 +04:00
rmdir haikuCaseTest haikucasetest 2>/dev/null
if [ $caseInsensitive != 0 ]; then
echo "You need a case-sensitive file-system to build Haiku."
if [ $HOST_PLATFORM = "darwin" ]; then
echo "You can create a case-sensitive disk image using Disk Utility."
fi
exit 1
fi
# check xattr support
if [ -z $HAIKU_HOST_USE_XATTR_REF ]; then
check_native_xattrs
attrSupport=$?
if [ $attrSupport = 2 ] && [ -z $HAIKU_HOST_USE_XATTR ]; then
HAIKU_HOST_USE_XATTR=1
elif [ $attrSupport = 1 ]; then
HAIKU_HOST_USE_XATTR_REF=1
fi
fi
if [ -z $HAIKU_HOST_USE_XATTR ]; then HAIKU_HOST_USE_XATTR=0; fi
if [ -z $HAIKU_HOST_USE_XATTR_REF ]; then HAIKU_HOST_USE_XATTR_REF=0; fi
# determine how to invoke sed with extended regexp support for non-GNU sed
if [ $HOST_PLATFORM = "darwin" ]; then
HOST_EXTENDED_REGEX_SED="sed -E"
fi
# check if nasm can actually output ELF files
# (the stock version in OSX can't)
# XXX: should probably only test for x86* arch
if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then
echo "$HAIKU_NASM cannot generate ELF files. Please install a working version."
if [ $HOST_PLATFORM = "darwin" ]; then
echo "You can install it from Mac Ports."
echo "Mac Ports is available at: http://www.macports.org/"
fi
exit 1
fi
# create output directory
mkdir -p "$buildOutputDir" || exit 1
if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
invalidCommand=$sourceDir/build/scripts/host_build_only
HAIKU_AR=$invalidCommand
HAIKU_CC=$invalidCommand
HAIKU_LD=$invalidCommand
HAIKU_OBJCOPY=$invalidCommand
HAIKU_RANLIB=$invalidCommand
HAIKU_ELFEDIT=$invalidCommand
2014-03-29 04:03:51 +04:00
HAIKU_NASM=$invalidCommand
HAIKU_STRIP=$invalidCommand
else
# On Haiku determine target architectures and tools automatically.
2013-07-26 01:52:11 +04:00
if [ -z "$targetArchs" ]; then
if [ $HOST_PLATFORM != haiku_host ]; then
echo "Please specify the build tools to use or build (via" \
"--cross-tools-prefix or --build-cross-tools) or specify a" \
"host-only build (--host-only)." >&2
echo "For more info, invoke $0 --help"
exit 1
fi
# determine primary architecture
targetArch=`package list -i /system/packages/haiku-*.hpkg \
| sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'`
is_in_list "$targetArch" "$supportedTargetArchs" || (
echo "Unsupported target architecture: \"$targetArch\"" >&2
exit 1
)
2013-07-26 01:52:11 +04:00
targetArchs=$targetArch
2013-07-26 01:52:11 +04:00
set_default_value HAIKU_AR_$targetArch ar
set_default_value HAIKU_CC_$targetArch gcc
set_default_value HAIKU_LD_$targetArch ld
set_default_value HAIKU_OBJCOPY_$targetArch objcopy
set_default_value HAIKU_RANLIB_$targetArch ranlib
set_default_value HAIKU_ELFEDIT_$targetArch elfedit
set_default_value HAIKU_STRIP_$targetArch strip
# determine secondary architectures
for targetArch in $supportedTargetArchs; do
if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then
targetArchs="$targetArchs $targetArch"
set_default_value HAIKU_AR_$targetArch ar-$targetArch
set_default_value HAIKU_CC_$targetArch gcc-$targetArch
set_default_value HAIKU_LD_$targetArch ld-$targetArch
set_default_value HAIKU_OBJCOPY_$targetArch objcopy-$targetArch
set_default_value HAIKU_RANLIB_$targetArch ranlib-$targetArch
set_default_value HAIKU_ELFEDIT_$targetArch elfedit-$targetArch
set_default_value HAIKU_STRIP_$targetArch strip-$targetArch
fi
done
# The target architectures might have been specified explicitly.
if [ -n "$haikuTargetArchs" ]; then
for targetArch in $haikuTargetArchs; do
is_in_list "$targetArch" "$targetArchs" || (
echo "Unsupported target architecture: \"$targetArch\"." \
"Only native architectures of the host platform can" \
"be specified." >&2
exit 1
)
done
targetArchs="$haikuTargetArchs"
fi
fi
isPrimaryArch=1
2013-07-26 01:52:11 +04:00
for targetArch in $targetArchs; do
# Note: targetArch is "unknown<n>" at this point if a cross-tools
2013-07-26 01:52:11 +04:00
# prefix was specified. The standard_gcc_settings call below will get
# the actual architecture.
if test "${HAIKU_PACKAGING_ARCHS#*$targetArch\b}" != "$HAIKU_PACKAGING_ARCHS"; then
# somehow we wound up with a duplicate arch; skip this one
continue
fi
2013-07-26 01:52:11 +04:00
crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
# build cross tools from sources
if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
crossToolsDir="$outputDir/cross-tools-$targetArch"
targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
script="$buildCrossToolsScript"
scriptArgs=
2013-07-26 01:52:11 +04:00
if [ $targetArch != x86_gcc2 ]; then
script="${script}_gcc4"
scriptArgs="$targetMachine"
set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch \
$useGccGraphiteDefault
2013-07-26 01:52:11 +04:00
fi
secondaryArch=
if [ -z "$isPrimaryArch" ]; then
secondaryArch=$targetArch
fi
case $HOST_PLATFORM in
freebsd|openbsd) MAKE=gmake;;
*) MAKE=make;;
esac
if ! valid_toolchain "${targetMachine}" "${crossToolsDir}" "${buildCrossTools}"; then
MAKE=$MAKE \
SECONDARY_ARCH=$secondaryArch \
HAIKU_USE_GCC_GRAPHITE=`get_variable \
HAIKU_USE_GCC_GRAPHITE_$targetArch` \
HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \
HAIKU_USE_GDB="$gdbSources" \
"$script" $scriptArgs "$sourceDir" "$buildCrossTools" \
"$crossToolsDir" $buildCrossToolsJobs || exit 1
else
echo "$targetArch crosstools already exist in $crossToolsDir; skipping build"
fi
2013-07-26 01:52:11 +04:00
crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
fi
# prepare gcc settings and get the actual target architecture
2015-11-08 17:58:56 +03:00
if [ $useClang = 1 ]; then
gcc="$HAIKU_clang -target ${targetMachine}"
if [ ! -z "${crossToolsPrefix}" ]; then
gcc="$gcc -B ${crossToolsPrefix}"
fi
# Clang's compiler intrinsics are not compatible with GCC's or even
# across versions of Clang, so we must collect them for use in the build.
mkdir -p "$outputDir/clang_headers" || exit 1
clangHeadersDir=`$gcc -print-resource-dir`/include/
case $targetArch in
x86*) cp $clangHeadersDir/*intrin* $clangHeadersDir/mm3* "$outputDir/clang_headers" || exit 1 ;;
ppc*) cp $clangHeadersDir/*altivec* "$outputDir/clang_headers" || exit 1 ;;
arm*) cp $clangHeadersDir/*arm* "$outputDir/clang_headers" || exit 1 ;;
esac
elif [ -z "${crossToolsPrefix}" ]; then
gcc=`get_variable HAIKU_CC_$targetArch`
2015-11-08 17:58:56 +03:00
else
gcc="${crossToolsPrefix}gcc"
fi
2013-07-26 01:52:11 +04:00
standard_gcc_settings "$gcc"
targetArch=$standard_gcc_settings_targetArch
# set default values for flags
set_default_value HAIKU_CPPFLAGS_$targetArch ""
set_default_value HAIKU_CCFLAGS_$targetArch ""
set_default_value HAIKU_CXXFLAGS_$targetArch ""
set_default_value HAIKU_LINKFLAGS_$targetArch ""
2013-07-26 01:52:11 +04:00
set_default_value HAIKU_LDFLAGS_$targetArch ""
set_default_value HAIKU_ARFLAGS_$targetArch cru
set_default_value HAIKU_UNARFLAGS_$targetArch x
# Override the cross tools variables, if the tools were built or a
# prefix was specified.
if [ $useClang = 1 ]; then
get_build_tool_path LD_$targetArch ld.lld
get_build_tool_path ELFEDIT_$targetArch elfedit
elif [ -n "$crossToolsPrefix" ]; then
2013-07-26 01:52:11 +04:00
get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
2017-05-13 12:37:22 +03:00
4.*|5.*|6.*|7.*|8.*)
2013-07-26 01:52:11 +04:00
get_build_tool_path ELFEDIT_$targetArch \
${crossToolsPrefix}elfedit
;;
esac
fi
if [ -n "$crossToolsPrefix" ]; then
get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
fi
2013-07-26 01:52:11 +04:00
# check whether the Haiku compiler really targets Haiku
targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
case "$targetMachine" in
*-*-haiku) ;;
*)
echo The compiler specified as Haiku target compiler is not a \
valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
echo compiler: $HAIKU_CC
echo compiler is configured for target: $targetMachine
exit 1 ;;
esac
2013-07-26 01:52:11 +04:00
HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
isPrimaryArch=
2013-07-26 01:52:11 +04:00
done
fi
# Generate BuildConfig
cat << EOF > "$buildConfigFile"
# -- WARNING --
# This file was AUTOMATICALLY GENERATED by configure, and will be completely
# overwritten the next time configure is run.
#
#d ${currentDir}
#c ${configurePath}
#e ${configureEnvirons}
#a ${configureArgs}
HOST_PLATFORM ?= "${HOST_PLATFORM}" ;
TARGET_PLATFORM ?= "${TARGET_PLATFORM}" ;
2013-07-26 01:52:11 +04:00
HAIKU_PACKAGING_ARCHS ?= ${HAIKU_PACKAGING_ARCHS} ;
HAIKU_NO_DOWNLOADS ?= "${HAIKU_NO_DOWNLOADS}" ;
HAIKU_INCLUDE_SOURCES ?= "${HAIKU_INCLUDE_SOURCES}" ;
HAIKU_INCLUDE_3RDPARTY ?= "${HAIKU_INCLUDE_3RDPARTY}" ;
HAIKU_DISTRO_COMPATIBILITY ?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
HAIKU_USE_GCC_PIPE ?= "${HAIKU_USE_GCC_PIPE}" ;
HAIKU_HOST_USE_32BIT ?= "${HAIKU_HOST_USE_32BIT}" ;
HAIKU_HOST_USE_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ;
HAIKU_HOST_USE_XATTR_REF ?= "${HAIKU_HOST_USE_XATTR_REF}" ;
HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ;
HOST_CC ?= ${CC} ;
HOST_GCC_RAW_VERSION ?= ${HOST_GCC_RAW_VERSION} ;
HOST_GCC_MACHINE ?= ${HOST_GCC_MACHINE} ;
HOST_LD ?= ${HOST_GCC_LD} ;
HOST_OBJCOPY ?= ${HOST_GCC_OBJCOPY} ;
HOST_EXTENDED_REGEX_SED ?= ${HOST_EXTENDED_REGEX_SED} ;
HOST_SHA256 ?= ${HOST_SHA256} ;
HAIKU_NASM ?= ${HAIKU_NASM} ;
HAIKU_BUILD_ATTRIBUTES_DIR ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
HOST_HAIKU_PORTER ?= ${HOST_HAIKU_PORTER} ;
HAIKU_PORTS ?= ${HAIKU_PORTS} ;
HAIKU_PORTS_CROSS ?= ${HAIKU_PORTS_CROSS} ;
HAIKU_IS_BOOTSTRAP ?= ${HAIKU_IS_BOOTSTRAP} ;
Integrate building the HaikuPorts bootstrap packages * Add configure option --bootstrap which allows specifying the haikuporter and HaikuPorts repository paths. * Add rules for supporting a second repository type. The PackageRepository rule is now private and RemotePackageRepository is used for remote repositories. The new BootstrapPackageRepository rule is for defining a bootstrap repository (there will probably be only the HaikuPorts cross repository) whose packages can be built as needed via haikuporter. * Rename DownloadPackage to FetchPackage. * Define repository HaikuPortsCross. * HaikuCrossDevel package(s): There are now two sets of packages: A "stage1" set with the same content as before and a final set additionally containing the libraries libbe, libnetwork, libpackage. Those are needed for building the libsolv bootstrap package while for building them we need other bootstrap packages (ICU, libz). This is basically all that's required to build a bootstrap Haiku completely from sources, with a few caveats: * There's no ICU bootstrap recipe yet (so one has to cheat and use the prebuilt package ATM). * Probably doesn't work on Haiku yet (tested on Linux only). * A 32 bit environment must be used (otherwise building the gcc 2 bootstrap package fails). * Building with multiple jobs doesn't work yet, since haikuporter uses common directories for building different packages and there's no explicit serialization yet. * Haven't tested the resulting image save for booting it. So it probably needs a bit more work before it can actually build the final HaikuPorts packages.
2013-07-21 06:10:48 +04:00
EOF
2013-07-26 01:52:11 +04:00
for targetArch in $HAIKU_PACKAGING_ARCHS; do
variables="
HAIKU_CC HAIKU_CC
HAIKU_CC_IS_CLANG HAIKU_CC_IS_CLANG
HAIKU_USE_GCC_GRAPHITE HAIKU_USE_GCC_GRAPHITE
HAIKU_CPU HAIKU_CPU
2013-07-26 01:52:11 +04:00
HAIKU_GCC_MACHINE HAIKU_GCC_MACHINE
HAIKU_GCC_RAW_VERSION HAIKU_GCC_RAW_VERSION
2013-07-26 01:52:11 +04:00
HAIKU_GCC_LIB_DIR HAIKU_GCC_LIB_DIR
HAIKU_BOOT_LIBGCC HAIKU_BOOT_LIBGCC
HAIKU_BOOT_LIBSUPC++ HAIKU_BOOT_LIBSUPCXX
HAIKU_AR HAIKU_AR
HAIKU_LD HAIKU_LD
HAIKU_OBJCOPY HAIKU_OBJCOPY
HAIKU_RANLIB HAIKU_RANLIB
HAIKU_ELFEDIT HAIKU_ELFEDIT
HAIKU_STRIP HAIKU_STRIP
HAIKU_CPPFLAGS HAIKU_CPPFLAGS
HAIKU_CCFLAGS HAIKU_CCFLAGS
HAIKU_C++FLAGS HAIKU_CXXFLAGS
HAIKU_LINKFLAGS HAIKU_LINKFLAGS
2013-07-26 01:52:11 +04:00
HAIKU_LDFLAGS HAIKU_LDFLAGS
HAIKU_ARFLAGS HAIKU_ARFLAGS
HAIKU_UNARFLAGS HAIKU_UNARFLAGS
"
set -- $variables
while [ $# -ge 2 ]; do
value=`get_variable ${2}_$targetArch`
echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
shift 2
done
# For variables that may have long values, distribute them over multiple
# lines so that jam doesn't hit the maximum line length.
variables="
HAIKU_BOOT_C++_HEADERS_DIR HAIKU_BOOT_CXX_HEADERS_DIR
2013-07-26 01:52:11 +04:00
"
set -- $variables
while [ $# -ge 2 ]; do
echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
get_variable ${2}_$targetArch | xargs -n 1 echo " " \
>> "$buildConfigFile"
echo " ;" >> "$buildConfigFile"
shift 2
done
done
# Generate a Jamfile in the output directory.
cat << EOF > $outputDir/Jamfile
# -- WARNING --
# This file was AUTOMATICALLY GENERATED by configure, and will be completely
# overwritten the next time configure is run.
HAIKU_TOP = $(relative_to "${sourceDir}" "${outputDir}") ;
HAIKU_OUTPUT_DIR = . ;
include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
EOF
echo "Configured successfully!"