595 lines
20 KiB
Bash
Executable File
595 lines
20 KiB
Bash
Executable File
#!/bin/sh
|
|
#
|
|
# configure [ <options> ]
|
|
|
|
# usage
|
|
#
|
|
# Prints usage.
|
|
#
|
|
usage()
|
|
{
|
|
cat << EOF
|
|
|
|
Usage: $0 <options>
|
|
options:
|
|
--alternative-gcc-output-dir <dir>
|
|
Build a Haiku installation that supports running
|
|
executables built with a gcc version incompatible
|
|
with the primary gcc (e.g. gcc 2 executables under
|
|
a gcc 4 Haiku or vice versa). <dir> specifies the
|
|
output directory of the other gcc. The directory
|
|
must already be fully configured.
|
|
Note, that a sub-jam will be executed when
|
|
building Haiku. When using a jam that is not
|
|
simply invoked by "jam", the JAM build variable
|
|
needs to be set accordingly.
|
|
To disable building the alternative libraries
|
|
the variable HAIKU_ADD_ALTERNATIVE_GCC_LIBS can be
|
|
unset in the UserBuildConfig file.
|
|
--build-cross-tools <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.
|
|
--build-cross-tools-gcc4 <arch> <build tools dir>
|
|
Like "--build-cross-tools" just that gcc 4 will
|
|
be used for cross-compilation. Note, that the
|
|
resulting Haiku installation built with gcc 4
|
|
will not be binary compatible with BeOS R5.
|
|
<arch> specifies the target architecture, either
|
|
"x86", "x86_64", "ppc", "m68k", "arm" or "mipsel".
|
|
--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).
|
|
--enable-multiuser Enable experimental multiuser support.
|
|
--help Prints out this help.
|
|
--include-gpl-addons Include GPL licensed add-ons.
|
|
--include-patented-code Enable code that is known to implemented patented
|
|
ideas and techniques. If this option is not
|
|
specified, the resulting distribution may still
|
|
implement patented ideas and techniques. This
|
|
option only disables code that is currently known
|
|
to be problematic.
|
|
--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 and
|
|
--build-cross-tools-gcc4. Is passed on to the
|
|
make building the build tools.
|
|
--target=TARGET Select build target platform.
|
|
[default=${TARGET_PLATFORM}]
|
|
valid targets=r5,bone,dano,haiku
|
|
--update re-runs last configure invocation [must be given
|
|
as first option!]
|
|
--use-gcc-pipe Build with GCC option -pipe. Speeds up the build
|
|
process, but uses more memory.
|
|
--use-32bit Use -m32 flag on 64bit host gcc compiler.
|
|
--use-xattr Use Linux xattr support for BeOS attribute
|
|
emulation. Warning: Make sure your file system
|
|
supports sufficient attribute sizes (4 KB per
|
|
file for all attributes won't suffice).
|
|
|
|
environment variables:
|
|
HAIKU_AR The static library archiver. Defaults to "ar".
|
|
HAIKU_CC The compiler. Defaults to "gcc".
|
|
HAIKU_LD The linker. Defaults to "ld".
|
|
HAIKU_OBJCOPY The objcopy to be used. Defaults to "objcopy".
|
|
HAIKU_RANLIB The static library indexer. Defaults to "ranlib".
|
|
HAIKU_YASM The yasm assembler (x86 only).
|
|
HAIKU_CPPFLAGS The preprocessor flags. Defaults to "".
|
|
HAIKU_CCFLAGS The C flags. Defaults to "".
|
|
HAIKU_CXXFLAGS The C++ flags. Defaults to "".
|
|
HAIKU_LDFLAGS The linker flags. Defaults to "".
|
|
HAIKU_ARFLAGS The flags passed to HAIKU_AR for archiving.
|
|
Defaults to "cru".
|
|
HAIKU_UNARFLAGS The flags passed to HAIKU_AR for unarchiving.
|
|
Defaults to "x".
|
|
|
|
Non-standard 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
|
|
}
|
|
|
|
# real_path
|
|
#
|
|
# returns the realpath of a symbolic link.
|
|
#
|
|
real_path()
|
|
{
|
|
perl -MCwd=realpath -e'print realpath($ARGV[0]), "\n"' "$1"
|
|
}
|
|
|
|
# standard_gcc_settings
|
|
#
|
|
# Sets the variables for a GCC platform.
|
|
#
|
|
standard_gcc_settings()
|
|
{
|
|
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
|
|
gcclib=`$HAIKU_CC -print-libgcc-file-name`
|
|
gccdir=`dirname ${gcclib}`
|
|
|
|
HAIKU_GCC_RAW_VERSION=`$HAIKU_CC -dumpversion`
|
|
HAIKU_GCC_MACHINE=`$HAIKU_CC -dumpmachine`
|
|
|
|
HAIKU_GCC_LIB_DIR=${gccdir}
|
|
HAIKU_GCC_LIBGCC=${gccdir}/libgcc.a
|
|
HAIKU_GCC_GLUE_CODE="crtbegin.o crtend.o"
|
|
HAIKU_GCC_HEADERS_DIR="${gccdir}/include
|
|
${gccdir}/include-fixed"
|
|
HAIKU_GCC_LIBGCC_OBJECTS=`$HAIKU_AR t ${HAIKU_GCC_LIBGCC} | grep -v eabi.o`
|
|
# Note: We filter out eabi.o. It's present in gcc's libgcc for PPC and
|
|
# neither needed nor wanted.
|
|
|
|
case $HAIKU_GCC_RAW_VERSION in
|
|
4.*)
|
|
# for gcc 4 we use the libstdc++ and libsupc++ that come with the
|
|
# compiler
|
|
HAIKU_STATIC_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.a`
|
|
HAIKU_SHARED_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.so`
|
|
HAIKU_STATIC_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.a`
|
|
HAIKU_SHARED_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.so`
|
|
|
|
local headers
|
|
if [ -d $gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION ]; then
|
|
headers=$gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION
|
|
else
|
|
headers=$gccdir/../../../../include/c++/$HAIKU_GCC_RAW_VERSION
|
|
fi
|
|
|
|
HAIKU_CXX_HEADERS_DIR=$headers
|
|
for d in $HAIKU_GCC_MACHINE backward ext; do
|
|
# Note: We need the line break, otherwise the line might become
|
|
# too long for jam (512 bytes max).
|
|
HAIKU_CXX_HEADERS_DIR="$HAIKU_CXX_HEADERS_DIR
|
|
$headers/$d"
|
|
done
|
|
|
|
# Unset the HAIKU_{SHARED,STATIC}_LIB{STD,SUP}CXX variables, if the
|
|
# compiler didn't give us actual file names. Otherwise resolve
|
|
# symlinks to avoid problems when copying the libraries to the
|
|
# image.
|
|
|
|
if [ $HAIKU_STATIC_LIBSTDCXX = libstdc++.a ]; then
|
|
HAIKU_STATIC_LIBSTDCXX=
|
|
else
|
|
HAIKU_STATIC_LIBSTDCXX=`$readlink $HAIKU_STATIC_LIBSTDCXX`
|
|
fi
|
|
|
|
if [ $HAIKU_SHARED_LIBSTDCXX = libstdc++.so ]; then
|
|
HAIKU_SHARED_LIBSTDCXX=
|
|
else
|
|
HAIKU_SHARED_LIBSTDCXX=`$readlink $HAIKU_SHARED_LIBSTDCXX`
|
|
fi
|
|
|
|
if [ $HAIKU_STATIC_LIBSUPCXX = libsupc++.a ]; then
|
|
HAIKU_STATIC_LIBSUPCXX=
|
|
else
|
|
HAIKU_STATIC_LIBSUPCXX=`$readlink $HAIKU_STATIC_LIBSUPCXX`
|
|
fi
|
|
|
|
if [ $HAIKU_SHARED_LIBSUPCXX = libsupc++.so ]; then
|
|
HAIKU_SHARED_LIBSUPCXX=
|
|
else
|
|
HAIKU_SHARED_LIBSUPCXX=`$readlink $HAIKU_SHARED_LIBSUPCXX`
|
|
fi
|
|
;;
|
|
2.9*)
|
|
# check for correct (most up-to-date) legacy compiler and complain
|
|
# if an older one is installed
|
|
if [ $HAIKU_GCC_RAW_VERSION != $haikuRequiredLegacyGCCVersion ]; then
|
|
echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
|
|
echo "Please download it from www.haiku-os.org...";
|
|
exit 1;
|
|
fi
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# 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 tool=$2
|
|
local path="${crossToolsPrefix}$tool"
|
|
|
|
if [ -f "$path" ]; then
|
|
# get absolute 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." >&2
|
|
exit 1
|
|
}
|
|
fi
|
|
|
|
eval "$var=$path"
|
|
}
|
|
|
|
# get cwd and the source directory
|
|
currentDir=`pwd`
|
|
cd `dirname "$0"`
|
|
sourceDir=`pwd`
|
|
cd "$currentDir"
|
|
|
|
# backup the passed arguments
|
|
configureArgs="$@"
|
|
|
|
# internal default parameter values
|
|
#
|
|
platform=`uname`
|
|
platformMachine=`uname -m`
|
|
targetArch=x86
|
|
crossToolsPrefix=
|
|
buildCrossTools=
|
|
buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
|
|
buildCrossToolsMachine=
|
|
buildCrossToolsJobs=
|
|
|
|
# exported (BuildSetup) default parameter values
|
|
#
|
|
HAIKU_GCC_RAW_VERSION=
|
|
HAIKU_GCC_MACHINE=i586-pc-haiku
|
|
HAIKU_STATIC_LIBSTDCXX=
|
|
HAIKU_SHARED_LIBSTDCXX=
|
|
HAIKU_STATIC_LIBSUPCXX=
|
|
HAIKU_SHARED_LIBSUPCXX=
|
|
HAIKU_CXX_HEADERS_DIR=
|
|
HOST_GCC_RAW_VERSION=`gcc -dumpversion`
|
|
HOST_GCC_MACHINE=`gcc -dumpmachine`
|
|
HAIKU_INCLUDE_GPL_ADDONS=0
|
|
HAIKU_INCLUDE_PATENTED_CODE=0
|
|
HAIKU_INCLUDE_SOURCES=0
|
|
HAIKU_INCLUDE_3RDPARTY=0
|
|
HAIKU_ENABLE_MULTIUSER=0
|
|
HAIKU_DISTRO_COMPATIBILITY=default
|
|
TARGET_PLATFORM=haiku
|
|
HAIKU_USE_GCC_PIPE=0
|
|
HAIKU_HOST_USE_32BIT=0
|
|
HAIKU_HOST_USE_XATTR=0
|
|
HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR=
|
|
HAIKU_ADD_ALTERNATIVE_GCC_LIBS=0
|
|
HOST_GCC_LD=`gcc -print-prog-name=ld`
|
|
HOST_GCC_OBJCOPY=`gcc -print-prog-name=objcopy`
|
|
SFDISK_BINARY=sfdisk
|
|
HOST_SFDISK=$SFDISK_BINARY
|
|
|
|
haikuRequiredLegacyGCCVersion="2.95.3-haiku-111122"
|
|
export haikuRequiredLegacyGCCVersion
|
|
# version of legacy gcc required to build haiku
|
|
|
|
set_default_value HAIKU_AR ar
|
|
set_default_value HAIKU_CC gcc
|
|
set_default_value HAIKU_LD ld
|
|
set_default_value HAIKU_OBJCOPY objcopy
|
|
set_default_value HAIKU_RANLIB ranlib
|
|
set_default_value HAIKU_YASM yasm
|
|
set_default_value HAIKU_CPPFLAGS ""
|
|
set_default_value HAIKU_CCFLAGS ""
|
|
set_default_value HAIKU_CXXFLAGS ""
|
|
set_default_value HAIKU_LDFLAGS ""
|
|
set_default_value HAIKU_ARFLAGS cru
|
|
set_default_value HAIKU_UNARFLAGS x
|
|
|
|
# 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
|
|
if ! type perl >/dev/null 2>&1; then
|
|
echo $0 --update: \'perl\' not found - updating not possible.
|
|
exit 1
|
|
fi
|
|
# convert BuildConfig from jam format to shell format and evaluate it
|
|
shellConfigFile="${buildConfigFile}.shell"
|
|
perl "$sourceDir/build/scripts/convert_build_config_to_shell_format.pl" \
|
|
<"$buildConfigFile" >"$shellConfigFile"
|
|
. "$shellConfigFile"
|
|
rm "$shellConfigFile"
|
|
shift
|
|
fi
|
|
|
|
# parse parameters
|
|
#
|
|
while [ $# -gt 0 ] ; do
|
|
case "$1" in
|
|
--alternative-gcc-output-dir)
|
|
assertparam "$1" $#
|
|
cd $2 || exit 1
|
|
HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR=`pwd`
|
|
HAIKU_ADD_ALTERNATIVE_GCC_LIBS=1
|
|
cd $currentDir
|
|
shift 2
|
|
;;
|
|
--build-cross-tools) assertparam "$1" $#; buildCrossTools=$2; shift 2;;
|
|
--build-cross-tools-gcc4)
|
|
assertparams "$1" 2 $#
|
|
buildCrossTools=$3
|
|
buildCrossToolsScript="${buildCrossToolsScript}_gcc4"
|
|
case "$2" in
|
|
x86) HAIKU_GCC_MACHINE=i586-pc-haiku;;
|
|
x86_64) HAIKU_GCC_MACHINE=x86_64-pc-haiku; targetArch=x86_64;;
|
|
ppc) HAIKU_GCC_MACHINE=powerpc-apple-haiku; targetArch=ppc;;
|
|
m68k) HAIKU_GCC_MACHINE=m68k-unknown-haiku; targetArch=m68k;;
|
|
arm) HAIKU_GCC_MACHINE=arm-unknown-haiku; targetArch=arm;;
|
|
mipsel) HAIKU_GCC_MACHINE=mipsel-unknown-haiku; targetArch=mips;;
|
|
*) echo "Unsupported target architecture: $2"
|
|
exit 1;;
|
|
esac
|
|
buildCrossToolsMachine=$HAIKU_GCC_MACHINE
|
|
shift 3
|
|
;;
|
|
--cross-tools-prefix)
|
|
assertparam "$1" $#
|
|
crossToolsPrefix=$2
|
|
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
|
|
;;
|
|
--enable-multiuser) HAIKU_ENABLE_MULTIUSER=1; shift 1;;
|
|
--help | -h) usage; exit 0;;
|
|
--include-gpl-addons) HAIKU_INCLUDE_GPL_ADDONS=1; shift 1;;
|
|
--include-patented-code) HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;;
|
|
--include-sources) HAIKU_INCLUDE_SOURCES=1; shift 1;;
|
|
--include-3rdparty) HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
|
|
-j*) buildCrossToolsJobs="$1"; shift 1;;
|
|
--target=*) TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;;
|
|
--use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;;
|
|
--use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;;
|
|
--use-xattr) HAIKU_HOST_USE_XATTR=1; shift 1;;
|
|
*) echo Invalid argument: \`$1\'; exit 1;;
|
|
esac
|
|
done
|
|
|
|
# detect the build platform
|
|
case "${platform}" in
|
|
BeOS) revision=`uname -r`
|
|
case "$revision" in
|
|
6.*) HOST_PLATFORM=dano ;;
|
|
5.1) HOST_PLATFORM=dano ;;
|
|
5.0.4) HOST_PLATFORM=bone ;;
|
|
5.0*) HOST_PLATFORM=r5 ;;
|
|
*) echo Unknown BeOS version: $revision
|
|
exit 1 ;;
|
|
esac
|
|
;;
|
|
Darwin) HOST_PLATFORM=darwin ;;
|
|
FreeBSD) HOST_PLATFORM=freebsd
|
|
SFDISK_BINARY=sfdisk-linux
|
|
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 common locations for sfdisk
|
|
for sfdiskDir in /sbin /usr/sbin /usr/local/sbin ; do
|
|
if [ -e ${sfdiskDir}/${SFDISK_BINARY} ]; then
|
|
HOST_SFDISK=${sfdiskDir}/${SFDISK_BINARY}
|
|
fi
|
|
done
|
|
|
|
# check for case-sensitive filesystem if on darwin
|
|
if [ $HOST_PLATFORM = "darwin" ]; then
|
|
diskutil info $(pwd) | grep -i "case-sensitive" > /dev/null
|
|
if [ $? != 0 ]; then
|
|
echo "You need a case-sensitive file-system to build Haiku."
|
|
echo "Please see the following guide on how to set one up:"
|
|
echo "http://haiku-os.org/documents/dev/how_to_build_haiku_on_mac_os_x"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# create output directory
|
|
mkdir -p "$buildOutputDir" || exit 1
|
|
|
|
# build cross tools from sources
|
|
if [ -n "$buildCrossTools" ]; then
|
|
"$buildCrossToolsScript" $buildCrossToolsMachine "$sourceDir" \
|
|
"$buildCrossTools" "$outputDir" $buildCrossToolsJobs || exit 1
|
|
crossToolsPrefix="$outputDir/cross-tools/bin/${HAIKU_GCC_MACHINE}-"
|
|
fi
|
|
|
|
# cross tools
|
|
if [ -n "$crossToolsPrefix" ]; then
|
|
get_build_tool_path AR ar
|
|
get_build_tool_path CC gcc
|
|
get_build_tool_path LD ld
|
|
get_build_tool_path OBJCOPY objcopy
|
|
get_build_tool_path RANLIB ranlib
|
|
fi
|
|
|
|
# prepare gcc settings
|
|
standard_gcc_settings
|
|
|
|
# check whether the Haiku compiler really targets Haiku or BeOS
|
|
case "$HAIKU_GCC_MACHINE" in
|
|
*-*-haiku) ;;
|
|
*-*-beos) ;;
|
|
*) 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: $HAIKU_GCC_MACHINE
|
|
exit 1 ;;
|
|
esac
|
|
|
|
# Generate BuildConfig
|
|
cat << EOF > "$buildConfigFile"
|
|
# BuildConfig
|
|
# Note: This file has been automatically generated by configure with the
|
|
# following arguments:
|
|
# ${configureArgs}
|
|
|
|
TARGET_PLATFORM ?= "${TARGET_PLATFORM}" ;
|
|
HOST_PLATFORM ?= "${HOST_PLATFORM}" ;
|
|
|
|
HAIKU_INCLUDE_GPL_ADDONS ?= "${HAIKU_INCLUDE_GPL_ADDONS}" ;
|
|
HAIKU_INCLUDE_PATENTED_CODE ?= "${HAIKU_INCLUDE_PATENTED_CODE}" ;
|
|
HAIKU_INCLUDE_SOURCES ?= "${HAIKU_INCLUDE_SOURCES}" ;
|
|
HAIKU_INCLUDE_3RDPARTY ?= "${HAIKU_INCLUDE_3RDPARTY}" ;
|
|
HAIKU_ENABLE_MULTIUSER ?= "${HAIKU_ENABLE_MULTIUSER}" ;
|
|
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_ALTERNATIVE_GCC_OUTPUT_DIR ?= ${HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR} ;
|
|
HAIKU_ADD_ALTERNATIVE_GCC_LIBS ?= ${HAIKU_ADD_ALTERNATIVE_GCC_LIBS} ;
|
|
|
|
HAIKU_GCC_RAW_VERSION ?= ${HAIKU_GCC_RAW_VERSION} ;
|
|
HAIKU_GCC_MACHINE ?= ${HAIKU_GCC_MACHINE} ;
|
|
HAIKU_GCC_LIB_DIR ?= ${HAIKU_GCC_LIB_DIR} ;
|
|
HAIKU_GCC_HEADERS_DIR ?= ${HAIKU_GCC_HEADERS_DIR} ;
|
|
HAIKU_GCC_LIBGCC ?= ${HAIKU_GCC_LIBGCC} ;
|
|
|
|
HAIKU_STATIC_LIBSTDC++ ?= ${HAIKU_STATIC_LIBSTDCXX} ;
|
|
HAIKU_SHARED_LIBSTDC++ ?= ${HAIKU_SHARED_LIBSTDCXX} ;
|
|
HAIKU_STATIC_LIBSUPC++ ?= ${HAIKU_STATIC_LIBSUPCXX} ;
|
|
HAIKU_SHARED_LIBSUPC++ ?= ${HAIKU_SHARED_LIBSUPCXX} ;
|
|
HAIKU_C++_HEADERS_DIR ?= ${HAIKU_CXX_HEADERS_DIR} ;
|
|
|
|
HAIKU_BUILD_ATTRIBUTES_DIR ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
|
|
|
|
HAIKU_AR ?= ${HAIKU_AR} ;
|
|
HAIKU_CC ?= ${HAIKU_CC} ;
|
|
HAIKU_LD ?= ${HAIKU_LD} ;
|
|
HAIKU_OBJCOPY ?= ${HAIKU_OBJCOPY} ;
|
|
HAIKU_RANLIB ?= ${HAIKU_RANLIB} ;
|
|
HAIKU_YASM ?= ${HAIKU_YASM} ;
|
|
HAIKU_CPPFLAGS ?= ${HAIKU_CPPFLAGS} ;
|
|
HAIKU_CCFLAGS ?= ${HAIKU_CCFLAGS} ;
|
|
HAIKU_CXXFLAGS ?= ${HAIKU_CXXFLAGS} ;
|
|
HAIKU_LDFLAGS ?= ${HAIKU_LDFLAGS} ;
|
|
HAIKU_ARFLAGS ?= ${HAIKU_ARFLAGS} ;
|
|
HAIKU_UNARFLAGS ?= ${HAIKU_UNARFLAGS} ;
|
|
|
|
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_SFDISK ?= ${HOST_SFDISK} ;
|
|
|
|
EOF
|
|
|
|
# Libgcc.a objects
|
|
|
|
cat << EOF > "$buildOutputDir/libgccObjects"
|
|
# libgcc.a objects to be linked against libroot.so
|
|
# Note: This file has been automatically generated by configure.
|
|
|
|
HAIKU_GCC_LIBGCC_OBJECTS ?= ${HAIKU_GCC_LIBGCC_OBJECTS} ;
|
|
EOF
|
|
|
|
# Generate a boot strap Jamfile in the output directory.
|
|
|
|
cat << EOF > $outputDir/Jamfile
|
|
# automatically generated Jamfile
|
|
|
|
HAIKU_TOP = ${sourceDir} ;
|
|
HAIKU_OUTPUT_DIR = ${outputDir} ;
|
|
|
|
include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
|
|
|
|
EOF
|