configure

#!/bin/bash
#
# Deemon Configure file
#

shopt -s extglob

# OUT_ROOT: Directory where "./configure" is run from, and "config.mk" goes
# BLD_ROOT: Directory where object files go
OUT_ROOT="$(readlink -f "$(pwd)")"
BLD_ROOT="$OUT_ROOT/build/deemon"

# SRC_ROOT: Directory where "./configure" actually lies (root of deemon's .git)
SRC_ROOT="$(dirname "$(readlink -f "$0")")"
BIN_ROOT=""

CONFIG_CROSS_PREFIX=""
CONFIG_CC=""
CONFIG_CXX=""
CONFIG_EXE=""
CONFIG_DLL=""

CONFIG_CFLAGS=""
CONFIG_LDFLAGS=""
CONFIG_LIBS=""
CONFIG_LIBM=""
CONFIG_LIBDL=""
CONFIG_LIBSOCKET=""

CONFIG_DEX_CC=""
CONFIG_DEX_CFLAGS="-shared"
CONFIG_DEX_LDFLAGS="-shared"
CONFIG_DEX_LIBS=""
CONFIG_DEX_CTYPES_CC=""
CONFIG_DEX_CTYPES_CFLAGS=""
CONFIG_DEX_CTYPES_LDFLAGS=""
CONFIG_DEX_CTYPES_LIBS=""

CONFIG_CORE_CFLAGS=""
CONFIG_CORE_LDFLAGS=""
CONFIG_CORE_LIBS=""

LIBFFI_TARGET=""
TARGET=""
TARGET_IS_AUTO=""
TARGET_CPU=""
FEATURES=""
WITH_DEX=""
WITHOUT_DEX_SPECIFIC=""
WITH_DEBUG=""
WITH_THREADS=""
WITH_LIBFFI=""
WITH_SYSTEM_LIBFFI=""
WITH_OPTIMIZE=""
CONFIG_PTHREAD=""
WITH_KOS_SYSTEM_HEADERS=""


# del_feature(MACRO_NAME)
del_feature() {
	FEATURES="$(for feat in $FEATURES; do
		if [[ "$feat" != "$1" ]]; then
			printf " $feat"
		fi
	done)"
	if ! [ -z "$FEATURES" ]; then
		FEATURES="${FEATURES:1}"
	fi
}

# del_feature_startswith(MACRO_NAME_START)
del_feature_startswith() {
	FEATURES="$(for feat in $FEATURES; do
		if [[ "$feat" != "$1"* ]]; then
			printf " $feat"
		fi
	done)"
	if ! [ -z "$FEATURES" ]; then
		FEATURES="${FEATURES:1}"
	fi
}

# add_feature(MACRO_NAME)
add_feature() {
	del_feature "$1"
	FEATURES="$FEATURES $1"
}

# set_feature_pair(ON_MACRO_NAME, OFF_MACRO_NAME, STATE={0,1})
set_feature_pair() {
	if [[ "$3" == "1" ]]; then
		if ! [ -z "$2" ]; then del_feature "$2"; fi
		if ! [ -z "$1" ]; then add_feature "$1"; fi
	else
		if ! [ -z "$1" ]; then del_feature "$1"; fi
		if ! [ -z "$2" ]; then add_feature "$2"; fi
	fi
}

# add_dex_specific(DEX_NAME)
add_dex_specific() {
	WITHOUT_DEX_SPECIFIC="$(for name in $WITHOUT_DEX_SPECIFIC; do
		if [[ "$name" != "$1" ]]; then
			printf " $name"
		fi
	done)"
	if ! [ -z "$WITHOUT_DEX_SPECIFIC" ]; then
		WITHOUT_DEX_SPECIFIC="${WITHOUT_DEX_SPECIFIC:1}"
	fi
}

# del_dex_specific(DEX_NAME)
del_dex_specific() {
	del_feature "$1"
	WITHOUT_DEX_SPECIFIC="$WITHOUT_DEX_SPECIFIC $1"
}

# set_dex_specific(DEX_NAME, STATE={0,1})
set_dex_specific() {
	if [[ "$2" == "1" ]]; then
		add_dex_specific "$1"
	else
		del_dex_specific "$1"
	fi
}

set_with_feature() {
	case "$1" in
	dex)                     WITH_DEX="$2" ;;
	dex-ctypes)              set_dex_specific "CTYPES" "$2" ;;
	dex-net)                 set_dex_specific "NET" "$2" ;;
	dex-posix)               set_dex_specific "POSIX" "$2" ;;
	dex-math)                set_dex_specific "MATH" "$2" ;;
	dex-ipc)                 set_dex_specific "IPC" "$2" ;;
	dex-threading)           set_dex_specific "THREADING" "$2" ;;
	dex-time)                set_dex_specific "TIME" "$2" ;;
	dex-win32)               set_dex_specific "WIN32" "$2" ;;
	dex-json)                set_dex_specific "JSON" "$2" ;;
	kos-system-headers)      WITH_KOS_SYSTEM_HEADERS="$2" ;;
	debug)                   WITH_DEBUG="$2" ;;
	optimize=*)              WITH_OPTIMIZE="$(echo "$1" | cut -d '=' -f 2)" ;;
	threads)                 WITH_THREADS="$2" ;;
	libffi)                  WITH_LIBFFI="$2" ;;
	system-libffi)           WITH_SYSTEM_LIBFFI="$2" ;;
	trace-refchanges)        set_feature_pair "CONFIG_TRACE_REFCHANGES" "CONFIG_NO_TRACE_REFCHANGES" "$2" ;;
	badrefcnt-checks)        set_feature_pair "CONFIG_BADREFCNT_CHECKS" "CONFIG_NO_BADREFCNT_CHECKS" "$2" ;;
	calltuple-optimizations) set_feature_pair "CONFIG_HAVE_CALLTUPLE_OPTIMIZATIONS" "CONFIG_NO_CALLTUPLE_OPTIMIZATIONS" "$2" ;;
	object-slabs)            set_feature_pair "" "CONFIG_NO_OBJECT_SLABS" "$2" ;;
	nobase-optimized-class-operators) set_feature_pair "CONFIG_HAVE_NOBASE_OPTIMIZED_CLASS_OPERATORS" "CONFIG_NO_NOBASE_OPTIMIZED_CLASS_OPERATORS" "$2" ;;
	deemon-home-environ)
		set_feature_pair "" "CONFIG_NO_DEEMON_HOME_ENVIRON" "$2"
		;;
	deemon-home-environ=*)
		del_feature "CONFIG_NO_DEEMON_HOME_ENVIRON"
		del_feature_startswith "CONFIG_DEEMON_HOME_ENVIRON="
		add_feature "CONFIG_DEEMON_HOME_ENVIRON=$(echo "$1" | cut -d '=' -f 2)"
		;;
	deemon-home=*)
		del_feature_startswith "CONFIG_DEEMON_HOME="
		add_feature "CONFIG_DEEMON_HOME=\"$(echo "$1" | cut -d '=' -f 2)\""
		;;
	deemon-path-environ)
		set_feature_pair "" "CONFIG_NO_DEEMON_PATH_ENVIRON" "$2"
		;;
	deemon-path-environ=*)
		del_feature "CONFIG_NO_DEEMON_PATH_ENVIRON"
		del_feature_startswith "CONFIG_DEEMON_PATH_ENVIRON="
		add_feature "CONFIG_DEEMON_PATH_ENVIRON=$(echo "$1" | cut -d '=' -f 2)"
		;;
	deemon-path=*)
		del_feature_startswith "CONFIG_DEEMON_PATH="
		local PATH_EXPR=""
		# https://stackoverflow.com/questions/918886/how-do-i-split-a-string-on-a-delimiter-in-bash
		IFS=';' read -ra PATH_LIST <<< "$(echo "$1" | cut -d '=' -f 2)"
		for p in "${PATH_LIST[@]}"; do
			PATH_EXPR="${PATH_EXPR}p(\"${p}\")"
		done
		add_feature "CONFIG_DEEMON_PATH=(p)$PATH_EXPR"
		;;
	*)
		echo "Unknown with-feature $1"
		exit 1
		;;
	esac
}



print_help_features() {
	echo "Features:"
	echo "    dex                      Support native libraries as deemon extensions (default: yes)"
	echo "    dex-ctypes               Provide the native deemon extension module: 'ctypes' (default: yes)"
	echo "    dex-net                  Provide the native deemon extension module: 'net' (default: yes)"
	echo "    dex-posix                Provide the native deemon extension module: 'posix' (default: yes)"
	echo "    dex-math                 Provide the native deemon extension module: 'math' (default: yes)"
	echo "    dex-ipc                  Provide the native deemon extension module: 'ipc' (default: yes)"
	echo "    dex-threading            Provide the native deemon extension module: 'threading' (default: yes)"
	echo "    dex-time                 Provide the native deemon extension module: 'time' (default: yes)"
	echo "    dex-win32                Provide the native deemon extension module: 'win32' (default: yes)"
	echo "    dex-json                 Provide the native deemon extension module: 'json' (default: yes)"
	echo "    kos-system-headers       Use the deemon-provided copies of KOS's hybrid system headers (default: auto)"
	echo "    debug                    Include debug informations (default: yes)"
	echo "    optimize=*               Additional compiler options for optimization (default: '-O2')"
	echo "    threads                  Multi-threading support (default: yes)"
	echo "    libffi                   Use libffi to allow ctypes to perform native function calls"
	echo "    system-libffi            Use a system-provided libffi instead of our own, static one (default: no)"
	echo ""
	echo "Features controlling config options:"
	echo "    trace-refchanges         [def:#if !0]"
	echo "                               Trace the origins of all inc-/decref operations to aid in narrowing"
	echo "                               down the origins of reference leaks (highly resource intensive)"
	echo "                               When enabled, the refcnt-history of leaked objects is dumped during shutdown"
	echo "                             with:    --conf=CONFIG_TRACE_REFCHANGES"
	echo "                             without: --conf=CONFIG_NO_TRACE_REFCHANGES"
	echo ""
	echo "    badrefcnt-checks         [def:#if !NDEBUG]"
	echo "                               Perform runtime checking to guard against bad use of reference counters"
	echo "                             with:    --conf=CONFIG_BADREFCNT_CHECKS"
	echo "                             without: --conf=CONFIG_NO_BADREFCNT_CHECKS"
	echo ""
	echo "    calltuple-optimizations  [def:#if !__OPTIMIZE_SIZE__]"
	echo "                               Provide optimized code paths for function calls with packed arguments (e.g. 'foo(args...)')"
	echo "                             with:    --conf=CONFIG_CALLTUPLE_OPTIMIZATIONS"
	echo "                             without: --conf=CONFIG_NO_CALLTUPLE_OPTIMIZATIONS"
	echo ""
	echo "    object-slabs             [def:#if <available-for-target>]"
	echo "                               Use custom slab allocators allocating heap memory for objects"
	echo "                             with:    -"
	echo "                             without: --conf=CONFIG_NO_OBJECT_SLABS"
	echo ""
	echo "    nobase-optimized-class-operators"
	echo "                             [def:#if !__OPTIMIZE_SIZE__]"
	echo "                               Define optimized operators for user-classes without bases"
	echo "                             with:    --conf=CONFIG_NOBASE_OPTIMIZED_CLASS_OPERATORS"
	echo "                             without: --conf=CONFIG_NO_NOBASE_OPTIMIZED_CLASS_OPERATORS"
	echo ""
	echo "    deemon-home-environ      [def:#if 1]"
	echo "                               Enable/disable recognition of an environment variable to"
	echo "                               override the deemon ~home~ location at runtime"
	echo "                             with:    -"
	echo "                             without: --conf=CONFIG_NO_DEEMON_HOME_ENVIRON"
	echo ""
	echo "    deemon-home-environ=*    [def:DEEMON_HOME]"
	echo "                               Set the name of the environment variable to check at runtime"
	echo "                               in order to find library files (s.a. 'DeeExec_GetHome()')"
	echo "                             with:    --config=CONFIG_DEEMON_HOME_ENVIRON=*"
	echo "                             without: -"
	echo ""
	echo "    deemon-home=*           [def:<determine-at-runtime>]"
	echo "                               Specify the path where deemon is ~home~. By default, this"
	echo "                               path is determined at runtime, and is the directory in which"
	echo "                               the deemon core executable is located:"
	echo "                                 'fs.headof(fs.readlink(\"/proc/self/exe\"))'"
	echo "                               Note that when building for cygwin, this must be a windows-style path!"
	echo "                             with:    --config=CONFIG_DEEMON_HOME=*"
	echo "                             without: -"
	echo ""
	echo "    deemon-path-environ      [def:#if 1]"
	echo "                               Enable/disable recognition of an environment variable to"
	echo "                               override the deemon library path location list at runtime"
	echo "                             with:    -"
	echo "                             without: --conf=CONFIG_NO_DEEMON_PATH_ENVIRON"
	echo ""
	echo "    deemon-path-environ=*    [def:DEEMON_PATH]"
	echo "                               Set the name of the environment variable to check at runtime"
	echo "                               for specifying deemon system library paths. When not specified,"
	echo "                               either use the override provided by '--with-deemon-path=*', or"
	echo "                               default to '[ \"<DEEMON_HOME>/lib\" ]'"
	echo "                             with:    --config=CONFIG_DEEMON_PATH_ENVIRON=*"
	echo "                             without: -"
	echo ""
	echo "    deemon-path=*            [def:<unset>]"
	echo "                               Specify an override for recognized deemon system library locations"
	echo "                               to be used when 'DEEMON_PATH' isn't set at runtime. This feature"
	echo "                               takes a ;-seperated list of absolute paths that will be hard-coded"
	echo "                               into the deemon core."
	echo "                             with:    --config=CONFIG_DEEMON_PATH=..."
	echo "                             without: -"
}

print_help() {
	echo "Usage: ./configure [Options...]"
	echo "NOTE: This configure script will setup the caller's PWD as build root, allowing for out-of-source builds"
	echo "Options (target):"
	echo "    --cross-prefix=*           Compiler prefix when cross-compiling"
	echo "    --target=*                 Specify the target name (e.g. 'i386-kos', 'x86_64-linux-gnu' or 'x86_64-pc-cygwin')"
	echo "                               When not specified, the target will be automatically determined through 'cc -v'"
	echo "    --libffi-target=*          The target name to use for libffi (defaults to the same as --target)"
	echo "    --source-path=*            The directory where deemon source files are found ($SRC_ROOT)"
	echo "    --bin-path=*               The path where the deemon core and its lib file should be placed"
	echo "    --build-path=*             The path where object files should be placed"
	echo "Options (extended build options):"
	echo "    --config-exe-extension=*   File extension for executable files"
	echo "    --config-dll-extension=*   File extension for shared library files"
	echo "    --config-cc=*              Name of the C compiler to use"
	echo "    --config-cxx=*             Name of the C++ compiler to use"
	echo "    --config-cflags=*          Additional flags to pass to the compiler during compilation"
	echo "    --config-ldflags=*         Additional flags to pass to the compiler during linking"
	echo "    --config-libs=*            Additional libraries to include during linking"
	echo "    --config-libm=*            Additional libraries to include to get access to <math.h> functions"
	echo "    --config-libdl=*           Additional libraries to include to get access to <dlfcn.h> functions"
	echo "    --config-libsocket=*       Additional libraries to include to get access to <sys/socket.h> functions"
	echo "    --config-dex-cc=*          The C/C++ compiler to use when building dex modules (defaults to --config-cxx)"
	echo "    --config-dex-cflags=*      Additional flags to pass to the dex-compiler during compilation"
	echo "    --config-dex-ldflags=*     Additional flags to pass to the dex-compiler during linking"
	echo "    --config-dex-libs=*        Additional libraries to include during linking of dex modules"
	echo "    --config-core-cflags=*     Additional flags to pass to the deemon-core-compiler during compilation"
	echo "    --config-core-ldflags=*    Additional flags to pass to the deemon-core-compiler during linking"
	echo "    --config-core-libs=*       Additional libraries to include during linking of the deemon-core"
	echo "    --config-pthread=*         Additional C flags to pass when multi-threading support is enabled"
	echo "    --conf=NAME=VALUE          Add a configuration override '#define NAME VALUE' to <deemon/config.h>"
	echo "    --conf=NAME                Same as --conf=NAME=1"
	echo "    --with-host=unix           For multi-host systems (cygwin): build against unix APIs"
	echo "    --with-host=windows        For multi-host systems (cygwin): build against windows APIs"
	echo "    --with-FEATURE             Enable the specified FEATURE (s.a. --help=features)"
	echo "    --without-FEATURE          Disable the specified FEATURE (s.a. --help=features)"
	echo "    --help                     Display this help"
	echo "    --help=features            Disable available options for --with-FEATURE and --without-FEATURE"
}

while [[ $# -gt 0 ]]; do
	case "$1" in
	--target=*)
		## e.g. i386-kos
		## e.g. x86_64-linux-gnu
		## e.g. x86_64-pc-cygwin
		TARGET="$(echo "$1" | cut -d '=' -f 2)"
		;;
	--libffi-target=*)
		LIBFFI_TARGET="$(echo "$1" | cut -d '=' -f 2)"
		;;
	--source-path=*)          SRC_ROOT="$(echo "$1" | cut -d '=' -f 2)" ;;
	--bin-path=*)             BIN_ROOT="$(echo "$1" | cut -d '=' -f 2)" ;;
	--cross-prefix=*)         CONFIG_CROSS_PREFIX="$(echo "$1" | cut -d '=' -f 2)" ;;
	--config-exe-extension=*) CONFIG_EXE="$(echo "$1" | cut -d '=' -f 2)" ;;
	--config-dll-extension=*) CONFIG_DLL="$(echo "$1" | cut -d '=' -f 2)" ;;
	--config-cc=*)            CONFIG_CC="$(echo "$1" | cut -d '=' -f 2)" ;;
	--config-cxx=*)           CONFIG_CXX="$(echo "$1" | cut -d '=' -f 2)" ;;
	--config-cflags=*)        CONFIG_CFLAGS="$CONFIG_CFLAGS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-ldflags=*)       CONFIG_LDFLAGS="$CONFIG_LDFLAGS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-libs=*)          CONFIG_LIBS="$CONFIG_LIBS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-libm=*)          CONFIG_LIBM="$CONFIG_LIBM $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-libdl=*)         CONFIG_LIBDL="$CONFIG_LIBDL $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-libsocket=*)     CONFIG_LIBSOCKET="$CONFIG_LIBSOCKET $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-dex-cc=*)        CONFIG_DEX_CC="$(echo "$1" | cut -d '=' -f 2)" ;;
	--config-dex-cflags=*)    CONFIG_DEX_CFLAGS="$CONFIG_DEX_CFLAGS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-dex-ldflags=*)   CONFIG_DEX_LDFLAGS="$CONFIG_DEX_LDFLAGS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-dex-libs=*)      CONFIG_DEX_LIBS="$CONFIG_DEX_LIBS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-core-cflags=*)   CONFIG_CORE_CFLAGS="$CONFIG_CORE_CFLAGS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-core-ldflags=*)  CONFIG_CORE_LDFLAGS="$CONFIG_CORE_LDFLAGS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-core-libs=*)     CONFIG_CORE_LIBS="$CONFIG_CORE_LIBS $(echo "$1" | cut -d '=' -f 2)" ;;
	--config-pthread=*)       CONFIG_PTHREAD="$CONFIG_PTHREAD $(echo "$1" | cut -d '=' -f 2)" ;;
	--conf=*)                 FEATURES="$FEATURES $(echo "$1" | cut -d '=' -f 2)" ;;
	--with-host=unix)
		del_feature "CONFIG_FORCE_HOST_WINDOWS"
		add_feature "CONFIG_FORCE_HOST_UNIX"
		;;
	--with-host=windows)
		del_feature "CONFIG_FORCE_HOST_UNIX"
		add_feature "CONFIG_FORCE_HOST_WINDOWS"
		;;
	--with-*)    set_with_feature "${1:7}" "1" ;;
	--without-*) set_with_feature "${1:10}" "0" ;;
	--help)          print_help; exit 1 ;;
	--help=features) print_help_features; exit 1 ;;
	*)
		echo "Invalid argument $1 (run './configure --help' for options)"
		exit 1
		;;
	esac
	shift
done


########################################################################################
## Automatically configure options
########################################################################################
if [ -z "$BIN_ROOT" ]; then BIN_ROOT="$OUT_ROOT"; fi
if [ -z "$CONFIG_CC" ]; then CONFIG_CC="${CONFIG_CROSS_PREFIX}gcc"; fi
if [ -z "$CONFIG_CXX" ]; then CONFIG_CXX="${CONFIG_CROSS_PREFIX}g++"; fi
if [ -z "$WITH_DEBUG" ]; then WITH_DEBUG="1"; fi
if [ -z "$WITH_OPTIMIZE" ]; then WITH_OPTIMIZE="-O2"; fi
if [ -z "$WITH_THREADS" ]; then WITH_THREADS="1"; fi
if [ -z "$WITH_LIBFFI" ]; then WITH_LIBFFI="1"; fi
if [ -z "$WITH_SYSTEM_LIBFFI" ]; then WITH_SYSTEM_LIBFFI="0"; fi

########################################################################################
## Setup configure logging
########################################################################################
CONFIG_LOG="$BLD_ROOT/config.log"
cmd() {
	echo "exec: $*" >> "$CONFIG_LOG"
	$* | tee -a "$CONFIG_LOG"
	local error=${PIPESTATUS[0]}
	if ! test $error -eq 0; then
		echo "ERROR: Command failed '$*' -> '$error'" | tee -a "$CONFIG_LOG"
		exit $error
	fi
}
trycmd() {
	echo "exec: $*" >> "$CONFIG_LOG"
	$* | tee -a "$CONFIG_LOG"
	local error=${PIPESTATUS[0]}
	if ! test $error -eq 0; then
		echo "ERROR: Command failed '$*' -> '$error'" | tee -a "$CONFIG_LOG"
	fi
	return $error
}
mkdir -p "$BLD_ROOT"
unlink "$CONFIG_LOG" > /dev/null 2>&1



########################################################################################
## Automatically determine the target from the given compiler
########################################################################################
if [ -z "$TARGET" ]; then
	TARGET=$("$CONFIG_CC" -v 2>&1 | while read line; do
		if [[ "$line" == *"Target: "* ]]; then
			TARGET="$(echo "$line" | cut -d ':' -f 2)"
			TARGET="$(echo "${TARGET}" | sed -e 's/^[ \t]*//')"
			echo "$TARGET"
			break
		fi
	done)
	if [ -z "$TARGET" ]; then
		echo "Error: Unable to determine target triplet (must manually specific '--target=...')" | tee -a "$CONFIG_LOG"
		exit 1
	fi
	TARGET_IS_AUTO="yes"
fi

########################################################################################
## Automatically extract the target CPU name
########################################################################################
if [ -z "$TARGET_CPU" ]; then
	# Assume a triplet format that begins with
	# the target CPU name, followed by a dash ('-')
	TARGET_CPU="$(echo "$TARGET" | cut -d '-' -f 1)"
fi


########################################################################################
## Automatically determine the compiler used for the dex
########################################################################################
if [ -z "$CONFIG_DEX_CC" ]; then
	CONFIG_DEX_CC="$CONFIG_CC"
	case "$TARGET" in
	*CYGWIN* | *Cygwin* | *cygwin*)
		# Need to use a c++ compiler on windows (actually: Need to do so on any PE-platform)
		CONFIG_DEX_CC="$CONFIG_CXX"
		;;
	*)
		;;
	esac
fi


########################################################################################
## Automatically enable DEX support
########################################################################################
if [ -z "$WITH_DEX" ]; then
	case "$TARGET" in
	# Blacklist of targets without dex goes here
	*)
		WITH_DEX="1"
		;;
	esac
fi

########################################################################################
## Figure out if we need to provide KOS system headers
########################################################################################
if [ -z "$WITH_KOS_SYSTEM_HEADERS" ]; then
	case "$TARGET" in
	*-kos | *-kos-*)
		# The system already provides the needed headers
		WITH_KOS_SYSTEM_HEADERS="0"
		;;
	*)
		WITH_KOS_SYSTEM_HEADERS="1"
		;;
	esac
fi


########################################################################################
## Do some additional target-specific configurations
########################################################################################
if ! [ -z "$TARGET_IS_AUTO" ]; then
	case "$TARGET" in
	*CYGWIN* | *Cygwin* | *cygwin*)
		CONFIG_CORE_LDFLAGS="$CONFIG_CORE_LDFLAGS -Wl,--out-implib=$(realpath -s --relative-to="$OUT_ROOT" "${BIN_ROOT}/libdeemon.dll.a")"
		case "$TARGET_CPU" in
		i?86)
			CONFIG_CORE_LDFLAGS="$CONFIG_CORE_LDFLAGS -Wl,$(realpath -s --relative-to="$OUT_ROOT" "${SRC_ROOT}/src/deemon/linker-scripts/link-deemon-gcc-i386-cygwin.def")"
			CONFIG_CORE_LDFLAGS="$CONFIG_CORE_LDFLAGS -Wl,--stack,4194304"
			;;
		*x86_64* | *x86-64*)
			CONFIG_CORE_LDFLAGS="$CONFIG_CORE_LDFLAGS -Wl,--stack,8388608"
			;;
		*)
			;;
		esac
		;;
	*)
		;;
	esac
fi


########################################################################################
## Automatically determine how to link against libm and libdl
########################################################################################
if [ -z "$CONFIG_LIBM" ]; then
	case "$TARGET" in
	*-kos | *-kos-*)
		# KOS includes libm as part of libc
		;;
	*)
		CONFIG_LIBM="-lm"
		;;
	esac
fi
if [ -z "$CONFIG_LIBDL" ]; then
	case "$TARGET" in
	*CYGWIN* | *Cygwin* | *cygwin*)
		# Cygwin includes libdl as part of libc
		;;
	*)
		CONFIG_LIBDL="-ldl"
		;;
	esac
fi
if [ -z "$CONFIG_LIBSOCKET" ]; then
	case "$TARGET" in
	*CYGWIN* | *Cygwin* | *cygwin*)
		CONFIG_LIBSOCKET="-lWs2_32"
		;;
	*)
		CONFIG_LIBSOCKET=""
		;;
	esac
fi
if [ -z "$CONFIG_PTHREAD" ] && [[ "$WITH_THREADS" == "1" ]]; then
	CONFIG_PTHREAD="-pthread";
fi


########################################################################################
## Apply configuration options
if [[ "$WITH_DEBUG" == "1" ]]; then CONFIG_CFLAGS="$CONFIG_CFLAGS -g"; fi
if [[ "$WITH_THREADS" == "0" ]]; then add_feature "CONFIG_NO_THREADS"; fi
if ! [ -z "$WITH_OPTIMIZE" ]; then CONFIG_CFLAGS="$CONFIG_CFLAGS $WITH_OPTIMIZE"; fi
if ! [ -z "$CONFIG_PTHREAD" ]; then
	CONFIG_CFLAGS="$CONFIG_CFLAGS $CONFIG_PTHREAD";
	CONFIG_LDFLAGS="$CONFIG_LDFLAGS $CONFIG_PTHREAD";
fi
case "$TARGET" in
*CYGWIN* | *Cygwin* | *cygwin*)
	CONFIG_EXE=".exe"
	CONFIG_DLL=".dll"
	if [[ "$WITH_DEX" == "1" ]]; then
		CONFIG_DEX_LDFLAGS="$CONFIG_DEX_LDFLAGS -L$(realpath -s --relative-to="$OUT_ROOT" "${BIN_ROOT}")"
		CONFIG_DEX_LIBS="$CONFIG_DEX_LIBS -ldeemon"
	fi
	;;
*)
	CONFIG_EXE=""
	CONFIG_DLL=".so"
	if [[ "$WITH_DEX" == "1" ]]; then
		CONFIG_CORE_LDFLAGS="$CONFIG_CORE_LDFLAGS -Wl,--export-dynamic"
		CONFIG_DEX_LDFLAGS="$CONFIG_DEX_LDFLAGS -Wl,--allow-shlib-undefined"
		CONFIG_DEX_CFLAGS="$CONFIG_DEX_CFLAGS -fPIC"
	fi
	;;
esac



cmd mkdir -p "$BLD_ROOT"
cmd mkdir -p "$BIN_ROOT/lib"
if [ "$OUT_ROOT" != "$SRC_ROOT" ]; then
	unlink "$OUT_ROOT/Makefile" > /dev/null 2>&1
	cat > "$OUT_ROOT/Makefile" <<EOF
include $(realpath -s --relative-to="$OUT_ROOT" "$SRC_ROOT/Makefile")
EOF
fi

mv "$OUT_ROOT/include/deemon/config.h" "$OUT_ROOT/include/deemon/config.h.old" > /dev/null 2>&1
if ! [ -z "$FEATURES" ]; then
	cmd mkdir -p "$OUT_ROOT/include/deemon"
	cat > "$OUT_ROOT/include/deemon/config.h" <<EOF
/* Automatically generated file (by ./configure). - Do not edit! */
EOF
	for feat in $FEATURES; do
		feat="$(echo "${feat}" | sed -e 's/^[ \t]*//')"
		if [[ "$feat" == *"="* ]]; then
			N="$(echo "$feat" | cut -d '=' -f 1)"
			V="$(echo "$feat" | cut -d '=' -f 2)"
			if [[ "$V" == "("* ]]; then
				echo "#define $N$V" >> "$OUT_ROOT/include/deemon/config.h"
			else
				echo "#define $N $V" >> "$OUT_ROOT/include/deemon/config.h"
			fi
		elif ! [ -z "$feat" ]; then
			echo "#define $feat" >> "$OUT_ROOT/include/deemon/config.h"
		fi
	done
fi



########################################################################################
## Probe system features
CONFINC="$OUT_ROOT/include/deemon/config.h"
if ! [ -f "$CONFINC" ]; then
	cmd mkdir -p "$OUT_ROOT/include/deemon"
	cat > "$CONFINC" <<EOF
/* Automatically generated file (by ./configure). - Do not edit! */
EOF
fi

CONFTEST_H="$OUT_ROOT/conftest.h"
CONFTEST="$OUT_ROOT/conftest.c"
CONFTEST_OUT="$OUT_ROOT/conftest.o"
CONFTEST_EXE="$OUT_ROOT/conftest"
CONFTEST_MAIN="int main()"

cat > "$CONFTEST_H" <<EOF
#define _ATFILE_SOURCE 1
#define _KOS_SOURCE 1
#define _GNU_SOURCE 1
#define _XOPEN_SOURCE 700
#define _POSIX_C_SOURCE 200809L
#define _LARGEFILE_SOURCE 1
#define _LARGEFILE64_SOURCE 1
#define _CTYPE_MACRO_SOURCE 1
#define _TIME64_SOURCE 1
#define _BSD_SOURCE 1
#define _SVID_SOURCE 1
#define _DEFAULT_SOURCE 1
#define _XOPEN_SOURCE_EXTENDED 1
#define _DOS_SOURCE 1
#define __EXTENSIONS__ 1
EOF
CONFTEST_H_MODIFIED=yes
CC_HAS_GCH=yes

# Try to compile the current conftest
try_compile() {
	echo "exec: $CONFIG_CC $CONFIG_CFLAGS -Werror -include $CONFTEST_H -include $CONFINC -c -o $CONFTEST_OUT $CONFTEST" >> "$CONFIG_LOG"
	if test x"$CC_HAS_GCH" = xyes; then
		if test x"$CONFTEST_H_MODIFIED" = xyes; then
			if "$CONFIG_CC" $CONFIG_CFLAGS -Werror -o "${CONFTEST_H}.gch" "$CONFTEST_H" > /dev/null 2>&1; then
				CONFTEST_H_MODIFIED=no
			else
				CC_HAS_GCH=no
			fi
		fi
		if test x"$CONFTEST_H_MODIFIED" = xno; then
			"$CONFIG_CC" $CONFIG_CFLAGS -Werror \
				-include "$CONFTEST_H" -include "$CONFINC" \
				-c -o "$CONFTEST_OUT" "$CONFTEST" >> "$CONFIG_LOG" 2>&1
			return $?
		fi
	fi
	"$CONFIG_CC" $CONFIG_CFLAGS -Werror \
		-include "$CONFTEST_H" -include "$CONFINC" \
		-c -o "$CONFTEST_OUT" "$CONFTEST" >> "$CONFIG_LOG" 2>&1
	return $?
}
try_compile_raw() {
	echo "exec: $CONFIG_CC $CONFIG_CFLAGS -Werror -include $CONFINC -c -o $CONFTEST_OUT $CONFTEST" >> "$CONFIG_LOG"
	"$CONFIG_CC" $CONFIG_CFLAGS -Werror -include "$CONFINC" \
		-c -o "$CONFTEST_OUT" "$CONFTEST" >> "$CONFIG_LOG" 2>&1
	return $?
}
try_link_raw() {
	local extra_flags="$1"
	echo "exec: $CONFIG_CC $CONFIG_CFLAGS -Werror -o $CONFTEST_EXE $CONFTEST_OUT $extra_flags" >> "$CONFIG_LOG"
	"$CONFIG_CC" $CONFIG_CFLAGS -Werror -o "$CONFTEST_EXE" "$CONFTEST_OUT" $extra_flags >> "$CONFIG_LOG" 2>&1
	return $?
}
try_compile_minimal() {
	echo "exec: $CONFIG_CC $CONFIG_CFLAGS -Werror -c -o $CONFTEST_OUT $CONFTEST" >> "$CONFIG_LOG"
	"$CONFIG_CC" $CONFIG_CFLAGS -Werror -c -o "$CONFTEST_OUT" "$CONFTEST" >> "$CONFIG_LOG" 2>&1
	return $?
}

# log_checking_begin $message
CURRENT_CHECK_MESSAGE=""
log_checking_begin() {
	echo -n "[ ] $1..."
	echo "$1..." >> "$CONFIG_LOG"
	CURRENT_CHECK_MESSAGE="$1"
}

# log_checking_yes
# log_checking_yes $status
log_checking_yes() {
	local status="$1"
	if test -z "$status"; then
		status="yes"
	fi
	echo -e "\r[+] $CURRENT_CHECK_MESSAGE... ($status)"
	echo "$CURRENT_CHECK_MESSAGE... ($status)" >> "$CONFIG_LOG"
}

# log_checking_no
# log_checking_no $status
log_checking_no() {
	local status="$1"
	if test -z "$status"; then
		status="no"
	fi
	echo -e "\r[-] $CURRENT_CHECK_MESSAGE... ($status)"
	echo "$CURRENT_CHECK_MESSAGE... ($status)" >> "$CONFIG_LOG"
}

# e.g. try_check_feature "STDIO_H" "header <$1>"
try_check_feature() {
	log_checking_begin "Checking for $2"
	if try_compile; then
		log_checking_yes
		return 0
	else
		log_checking_no
		local FPROC=$(cat "$CONFTEST")
		FPROC="| ${FPROC//
/
| }"
		cat >> "$CONFIG_LOG" <<EOF
The failing program was:
$FPROC
--------------------------------------------------------------------------------
EOF
		return 1
	fi
}
try_check_feature_raw() {
	log_checking_begin "Checking for $2"
	if try_compile_raw; then
		log_checking_yes
		return 0
	else
		log_checking_no
		local FPROC=$(cat "$CONFTEST")
		FPROC="| ${FPROC//
/
| }"
		cat >> "$CONFIG_LOG" <<EOF
The failing program was:
$FPROC
--------------------------------------------------------------------------------
EOF
		return 1
	fi
}

# e.g. check_feature "STDIO_H" "header <$1>"
# Will write either CONFIG_HAVE_STDIO_H, or CONFIG_NO_STDIO_H
check_feature() {
	if try_check_feature "$1" "$2"; then
		echo "#define CONFIG_HAVE_$1" >> "$CONFINC"
		return 0
	else
		echo "#define CONFIG_NO_$1 /* Missing! */" >> "$CONFINC"
		return 1
	fi
}
check_feature_raw() {
	if try_check_feature_raw "$1" "$2"; then
		echo "#define CONFIG_HAVE_$1" >> "$CONFINC"
		return 0
	else
		echo "#define CONFIG_NO_$1 /* Missing! */" >> "$CONFINC"
		return 1
	fi
}

# e.g. check_header "stdio.h"
check_header() {
	cat > "$CONFTEST" <<EOF
#include <$1>
$CONFTEST_MAIN{return 0;}
EOF
	local FN="${1^^}"
	FN="${FN////_}"
	FN="${FN//./_}"
	if check_feature_raw "$FN" "header <$1>"; then
		echo "#include <$1>" >> "$CONFTEST_H"
		CONFTEST_H_MODIFIED=yes
		return 0
	fi
	return 1
}

# e.g. check_generic "_Exit"  "_Exit(0);"
check_generic() {
	cat > "$CONFTEST" <<EOF
$CONFTEST_MAIN{${2}}
EOF
	check_feature "$1" "$1"
	return $?
}

# Check if we need to add argc/argv to conftest files
log_checking_begin "Checking how to compile a simple source file"
cat > "$CONFTEST" <<EOF
$CONFTEST_MAIN{return 0;}
EOF

if ! try_compile_raw; then
	CONFTEST_MAIN="int main(int argc, char *argv[])"
	cat > "$CONFTEST" <<EOF
$CONFTEST_MAIN{return 0;}
EOF
	if ! try_compile_raw; then
		log_checking_no "Cannot compile a simple source file"
		exit 1
	fi
fi
log_checking_yes "'$CONFTEST_MAIN { ... }'"


log_checking_begin "Checking if '_end' and '-Wl,-defsym=__dex_start__=.' works"
cat > "$CONFTEST" <<EOF
extern __attribute__((visibility("hidden"))) char __dex_start__[];
extern __attribute__((visibility("hidden"))) char _end[];
$CONFTEST_MAIN{return (int)(_end - __dex_start__);}
EOF
if try_compile_raw && try_link_raw "-Wl,-defsym=__dex_start__=."; then
	log_checking_yes
	CONFIG_LDFLAGS="$CONFIG_LDFLAGS -Wl,-defsym=__dex_start__=."
	echo "#define CONFIG_HAVE___dex_start____AND___end" >> "$CONFINC"
else
	log_checking_no
	echo "#define CONFIG_NO___dex_start____AND___end" >> "$CONFINC"
fi


log_checking_begin "Checking if '-Wl,--build-id=md5' and 'src/deemon/linker-scripts/dex-build-id.ld' works"
cat > "$CONFTEST" <<EOF
extern __attribute__((visibility("hidden"))) char __dex_buildid__[];
$CONFTEST_MAIN{return (int)(__dex_buildid__[16] + __dex_buildid__[31]);}
EOF
_NEED_BUILDID_ALTERNATIVE=""
if try_compile_raw && try_link_raw "-Wl,--build-id=md5 $(realpath -s --relative-to="$OUT_ROOT" "${SRC_ROOT}/src/deemon/linker-scripts/dex-build-id.ld")"; then
	log_checking_yes
	CONFIG_LDFLAGS="$CONFIG_LDFLAGS -Wl,--build-id=md5 $(realpath -s --relative-to="$OUT_ROOT" "${SRC_ROOT}/src/deemon/linker-scripts/dex-build-id.ld")"
	echo "#define CONFIG_HAVE___dex_buildid__" >> "$CONFINC"
else
	log_checking_no
	echo "#define CONFIG_NO___dex_buildid__" >> "$CONFINC"
	_NEED_BUILDID_ALTERNATIVE="y"
fi


# Try to come up with an alternative to `-Wl,--build-id`
if ! test -z "$_NEED_BUILDID_ALTERNATIVE"; then
	UUIDGEN=""
	log_checking_begin "Checking if 'uuidgen' works"
	if uuidgen > /dev/null 2>&1; then
		log_checking_yes
		UUIDGEN="uuidgen"
	else
		log_checking_no
	fi
	if test -z "$UUIDGEN"; then
		log_checking_begin "Checking if 'cat /proc/sys/kernel/random/uuid' works"
		if cat /proc/sys/kernel/random/uuid > /dev/null 2>&1; then
			log_checking_yes
			UUIDGEN="cat /proc/sys/kernel/random/uuid"
		else
			log_checking_no
		fi
	fi
	if ! test -z "$UUIDGEN"; then
		log_checking_begin "Checking if '-Wl,-defsym=__dex_builduuid64_0__=...' works"
		cat > "$CONFTEST" <<EOF
#ifndef __UINT64_TYPE__
#define __UINT64_TYPE__ unsigned long long int
#endif
extern __attribute__((visibility("hidden"))) char __dex_builduuid64_0__[];
extern __attribute__((visibility("hidden"))) char __dex_builduuid64_1__[];
__UINT64_TYPE__ const my_build_uuid[2] = {
	(__UINT64_TYPE__)__dex_builduuid64_0__,
	(__UINT64_TYPE__)__dex_builduuid64_1__
};
$CONFTEST_MAIN{return my_build_uuid != 0;}
EOF
		_UUID_LDFLAGS="V=\"\$($UUIDGEN)\" && V=\"\${V//-/}\" && echo \"-Wl,-defsym=__dex_builduuid64_0__=0x\${V:0:16} -Wl,-defsym=__dex_builduuid64_1__=0x\${V:16:16}\""
		if try_compile_raw && try_link_raw "$(eval $_UUID_LDFLAGS)"; then
			log_checking_yes
			CONFIG_LDFLAGS="$CONFIG_LDFLAGS \$(shell ${_UUID_LDFLAGS//\$/\$\$})"
			echo "#define CONFIG_HAVE___dex_builduuid64__" >> "$CONFINC"
			_NEED_BUILDID_ALTERNATIVE=""
		else
			log_checking_no
			echo "#define CONFIG_NO___dex_builduuid64__" >> "$CONFINC"
			exit 1
		fi
		if ! test -z "$_NEED_BUILDID_ALTERNATIVE"; then
			log_checking_begin "Checking if '-Wl,-defsym=__dex_builduuid32_0__=...' works"
			cat > "$CONFTEST" <<EOF
#ifndef __UINT32_TYPE__
#define __UINT32_TYPE__ unsigned int
#endif
extern __attribute__((visibility("hidden"))) char __dex_builduuid32_0__[];
extern __attribute__((visibility("hidden"))) char __dex_builduuid32_1__[];
extern __attribute__((visibility("hidden"))) char __dex_builduuid32_2__[];
extern __attribute__((visibility("hidden"))) char __dex_builduuid32_3__[];
__UINT32_TYPE__ const my_build_uuid[4] = {
	(__UINT32_TYPE__)__dex_builduuid32_0__,
	(__UINT32_TYPE__)__dex_builduuid32_1__,
	(__UINT32_TYPE__)__dex_builduuid32_2__,
	(__UINT32_TYPE__)__dex_builduuid32_3__,
};
$CONFTEST_MAIN{return my_build_uuid != 0;}
EOF
			_UUID_LDFLAGS="V=\"\$($UUIDGEN)\" && V=\"\${V//-/}\" && echo \"-Wl,-defsym=__dex_builduuid32_0__=0x\${V:0:8} -Wl,-defsym=__dex_builduuid32_1__=0x\${V:8:8} -Wl,-defsym=__dex_builduuid32_2__=0x\${V:16:8} -Wl,-defsym=__dex_builduuid32_3__=0x\${V:24:8}\""
			if try_compile_raw && try_link_raw "$(eval $_UUID_LDFLAGS)"; then
				log_checking_yes
				CONFIG_LDFLAGS="$CONFIG_LDFLAGS \$(shell ${_UUID_LDFLAGS//\$/\$\$})"
				echo "#define CONFIG_HAVE___dex_builduuid32__" >> "$CONFINC"
				_NEED_BUILDID_ALTERNATIVE=""
			else
				log_checking_no
				echo "#define CONFIG_NO___dex_builduuid32__" >> "$CONFINC"
			fi
		fi
	fi
fi

if ! test -z "$_NEED_BUILDID_ALTERNATIVE"; then
	echo "[!] No linker-based method of embedding build IDs. Will use timestamps in sources," | tee -a "$CONFIG_LOG"
	echo "    but module build IDs will only change when certain files are re-compiled" | tee -a "$CONFIG_LOG"
fi



########################################################################################
## Also configure libffi (if needed)
########################################################################################
if [[ "$WITHOUT_DEX_SPECIFIC" == *"CTYPES"* ]]; then
	# The ctypes dex is disabled, so we don't even need libffi
	CONFIG_DEX_CTYPES_CC="$CONFIG_DEX_CC"
	CONFIG_DEX_CTYPES_CFLAGS=""
	CONFIG_DEX_CTYPES_LDFLAGS=""
	CONFIG_DEX_CTYPES_LIBS=""
else
	if [[ "$WITH_LIBFFI" != "1" ]]; then
		CONFIG_DEX_CTYPES_CFLAGS="-DCONFIG_NO_CFUNCTION"
		CONFIG_DEX_CTYPES_LDFLAGS=""
		CONFIG_DEX_CTYPES_LIBS=""
	elif [[ "$WITH_SYSTEM_LIBFFI" == "1" ]]; then
		CONFIG_DEX_CTYPES_CFLAGS=""
		CONFIG_DEX_CTYPES_LDFLAGS=""
		CONFIG_DEX_CTYPES_LIBS="-lffi"
	else
		_STATIC_LIBFFY_BUILD_ERROR=""
		if ! [ -f "$BLD_ROOT/libffi/include/ffi.h" ]; then
			echo "Configuring libffi (for dex.ctypes)..." | tee -a "$CONFIG_LOG"
			rm -rf "$BLD_ROOT/libffi" > /dev/null 2>&1
			cmd mkdir -p "$BLD_ROOT/libffi"
			cd "$BLD_ROOT/libffi"
			if [ -z "$LIBFFI_TARGET" ]; then
				case "$TARGET" in
				*-kos | *-kos-*)
					# libffi doesn't know KOS, but it's close
					# enough to linux, so we just use that
					LIBFFI_TARGET="$TARGET_CPU-linux-gnu"
					;;
				*)
					LIBFFI_TARGET="$TARGET"
					;;
				esac
			fi
			(
				export CROSS_PREFIX="$CONFIG_CROSS_PREFIX"
				export CC="$CONFIG_CC"
				export CXX="$CONFIG_CXX"
				export CPP="${CONFIG_CROSS_PREFIX}cpp"
				export AS="${CONFIG_CROSS_PREFIX}as"
				export AR="${CONFIG_CROSS_PREFIX}ar"
				export NM="${CONFIG_CROSS_PREFIX}nm"
				export TARGET="$LIBFFI_TARGET"
				if [[ "$TARGET" == "i686-w64-mingw32" ]]; then
					# Workaround for a configure-detection-bug:
					# https://bugzilla.mozilla.org/show_bug.cgi?id=1336569
					export CFLAGS="$CFLAGS -DSYMBOL_UNDERSCORE";
					export CXXFLAGS="$CXXFLAGS -DSYMBOL_UNDERSCORE";
				fi
				case "$TARGET" in
					*CYGWIN* | *Cygwin* | *cygwin*)
						;;
					*)
						# Force libffi to be built as position-independent,
						# thus preventing DT_TEXTREL in ctypes.so
						export CFLAGS="$CFLAGS -fPIC";
						export CXXFLAGS="$CXXFLAGS -fPIC";
						;;
				esac
				cmd bash "$SRC_ROOT/src/dex/ctypes/ffi/libffi/configure" \
					--host="$LIBFFI_TARGET" \
					--target="$LIBFFI_TARGET" \
					--enable-static \
					--prefix "$BLD_ROOT/libffi"
			) || {
				_STATIC_LIBFFY_BUILD_ERROR="$?"
			}
		fi
		if test -z "$_STATIC_LIBFFY_BUILD_ERROR" && ! [ -f "${BLD_ROOT}/libffi/.libs/libffi.a" ]; then
			echo "Building libffi (for dex.ctypes)..." | tee -a "$CONFIG_LOG"
			cd "$BLD_ROOT/libffi"
			trycmd make -j $(grep -c ^processor /proc/cpuinfo) || {
				_STATIC_LIBFFY_BUILD_ERROR=$?
				# libffi relies on libtool, which in turn contains some bashism,
				# though rather than being called by /bin/bash, it's called by
				# /bin/sh instead. So if you've just seen errors like this:
				# >> ./libtool: 1578: ./libtool: preserve_args+= --tag CC: not found
				# then the problem is that '[$(readlink /bin/sh) != "bash"]'
				# s.a. https://github.com/JuliaPackaging/BinaryBuilder.jl/issues/77
				#      Though for libffi the problem isn't a miss-configured kernel,
				#      but it unconditionally assuming that the /bin/sh-shell has
				#      support for all of the bashism it wants to throw at it...
				if [ "$(readlink "/bin/sh")" != "bash" ]; then
					echo "" | tee -a "$CONFIG_LOG"
					echo "" | tee -a "$CONFIG_LOG"
					echo "" | tee -a "$CONFIG_LOG"
					echo "Building libffi likely failed because you're using a custom shell in '/bin/sh'" | tee -a "$CONFIG_LOG"
					echo "Libffi relies on libtool, which in turn contains some bashism that may not be" | tee -a "$CONFIG_LOG"
					echo "supported by other shells. If you're seeing errors like:" | tee -a "$CONFIG_LOG"
					echo ">> ./libtool: 1578: ./libtool: preserve_args+= --tag CC: not found" | tee -a "$CONFIG_LOG"
					echo "then consider fixing this problem by install bash and running:" | tee -a "$CONFIG_LOG"
					echo "    'unlink /bin/sh; ln -s \"bash\" /bin/sh'" | tee -a "$CONFIG_LOG"
					echo "as root" | tee -a "$CONFIG_LOG"
					echo "" | tee -a "$CONFIG_LOG"
				fi
			}
		fi
		cd "$BLD_ROOT"
		if test -z "$_STATIC_LIBFFY_BUILD_ERROR"; then
			CONFIG_DEX_CTYPES_CFLAGS="-I$(realpath -s --relative-to="$OUT_ROOT" "${BLD_ROOT}/libffi/include")"
			CONFIG_DEX_CTYPES_LDFLAGS=""
			CONFIG_DEX_CTYPES_LIBS="$(realpath -s --relative-to="$OUT_ROOT" "${BLD_ROOT}/libffi/.libs/libffi.a")"
		else
			echo "" | tee -a "$CONFIG_LOG"
			echo "" | tee -a "$CONFIG_LOG"
			echo "" | tee -a "$CONFIG_LOG"
			echo "[!] Error building libffi (host might not be supported by built-in version of libffi)" | tee -a "$CONFIG_LOG"
			log_checking_begin "Checking if a system version of libffi is installed"
			cat > "$CONFTEST" <<EOF
#include <ffi.h>
#include <ffitarget.h>
$CONFTEST_MAIN{extern ffi_type a; extern ffi_cif b;return 0;}
EOF
			if try_compile_raw && try_link_raw "-lffi"; then
				log_checking_yes
				echo "[!] Using system version of libffi (implicit '--with-system-libffi')" | tee -a "$CONFIG_LOG"
				CONFIG_DEX_CTYPES_CFLAGS=""
				CONFIG_DEX_CTYPES_LDFLAGS=""
				CONFIG_DEX_CTYPES_LIBS="-lffi"
				WITH_SYSTEM_LIBFFI="1"
			else
				log_checking_no
				echo "[!] No working instance of libffi detected (implicit '--without-libffi')" | tee -a "$CONFIG_LOG"
				CONFIG_DEX_CTYPES_CFLAGS="-DCONFIG_NO_CFUNCTION"
				CONFIG_DEX_CTYPES_LDFLAGS=""
				CONFIG_DEX_CTYPES_LIBS=""
				WITH_LIBFFI="0"
			fi
		fi
	fi
	CONFIG_DEX_CTYPES_CC="$CONFIG_DEX_CC"
	case "$TARGET" in
	*-kos | *-kos-*)
		# In order to allow the handling of exceptions with <kos/except.h>,
		# we have to compile the ctypes dex in c++ (thus allowing the use of
		# try...catch for the purpose of handling handling exceptions)
		CONFIG_DEX_CTYPES_CC="$CONFIG_CXX"
		CONFIG_DEX_CTYPES_CFLAGS="$CONFIG_DEX_CTYPES_CFLAGS -fnon-call-exceptions"
		# Enable NOSTDLIB for ctypes to prevent libstdc++ from
		# being linked in, when we don't actually make use of it.
		CONFIG_DEX_CTYPES_LDFLAGS="-nostdlib -static-libgcc"
		CONFIG_DEX_CTYPES_LIBS="$CONFIG_DEX_CTYPES_LIBS -lc"
		CONFIG_DEX_CTYPES_LIBS="$CONFIG_DEX_CTYPES_LIBS -ldl"
		CONFIG_DEX_CTYPES_LIBS="$CONFIG_DEX_CTYPES_LIBS -lgcc"
		;;
	*)
		;;
	esac
fi




# Check for features
in_features_region=no
while read line; do
	if [[ "$in_features_region" == "yes" ]]; then
		if [[ "$line" == *"END:FEATURES"* ]]; then
			in_features_region=no
		else
			case "$line" in
			*( )header*( )\(\"* | *( )header_nostdinc*( )\(\"*)
				line="${line#*\"}"
				line="${line%%\"*}"
				check_header "$line"
				;;
			*( )func*( )\(\"* | *( )var*( )\(\"* | *( )feature*( )\(\"*)
				line="${line#*\"}"
				n="${line%%\"*}"
				line="${line#*\"}"
				case "$line" in
					*test*( ):*( )\"* )
						t="${line#*test*( ):*( )\"}"
						t="${t%%\"*}"
						;;
					*test*( ):*( )\'* )
						t="${line#*test*( ):*( )\'}"
						t="${t%%\'*}"
						;;
					*)
						t="(void)*&$n; return 0;"
						;;
				esac
				check_generic "$n" "$t"
				;;
			*( )func*( )\(\'* | *( )var*( )\(\'* | *( )feature*( )\(\'*)
				line="${line#*\'}"
				n="${line%%\'*}"
				line="${line#*\'}"
				case "$line" in
					*test*( ):*( )\"* )
						t="${line#*test*( ):*( )\"}"
						t="${t%%\"*}"
						;;
					*test*( ):*( )\'* )
						t="${line#*test*( ):*( )\'}"
						t="${t%%\'*}"
						;;
					*)
						t="(void)&$n; return 0;"
						;;
				esac
				check_generic "$n" "$t"
				;;
			*( )functest*( )\(\"*)
				line="${line#*\"}"
				t="${line%%\"*}"
				n="${t%%\(*}"
				t="return (int)!$t;"
				check_generic "$n" "$t"
				;;
			*( )functest*( )\(\'*)
				line="${line#*\'}"
				t="${line%%\'*}"
				n="${t%%\(*}"
				t="return (int)!$t;"
				check_generic "$n" "$t"
				;;
			*( )typ*( )\(\'*)
				line="${line#*\'}"
				t="${line%%\'*}"
				n="${t%%\(*}"
				t="$t x = ($t)123; return (int)x;"
				check_generic "$n" "$t"
				;;
			*( )typ*( )\(\"*)
				line="${line#*\"}"
				t="${line%%\"*}"
				n="${t%%\(*}"
				t="$t x = ($t)123; return (int)x;"
				check_generic "$n" "$t"
				;;
			*( )constant*( )\(\"*)
				n="${line#*\"}"
				n="${n%%\"*}"
				t="return (int)$n;"
				check_generic "$n" "$t"
				;;
			*( )constant*( )\(\'*)
				n="${line#*\'}"
				n="${n%%\'*}"
				t="return (int)$n;"
				check_generic "$n" "$t"
				;;
			*( )constant_nonzero*( )\(\"*)
				n="${line#*\"}"
				n="${n%%\"*}"
				cat > "$CONFTEST" <<EOF
$CONFTEST_MAIN{return (int)$n;}
EOF
				if try_check_feature "$n" "$n"; then
					cat > "$CONFTEST" <<EOF
$CONFTEST_MAIN{typedef int myT[$n != 0 ? 1 : -1]; extern myT foo; return foo[0];}
EOF
					check_feature "$n" "$n being non-zero"
				else
					echo "#define CONFIG_NO_$n /* Missing! */" >> "$CONFINC"
				fi
				;;
			*( )print*( )\"*)
				line="${line#*\"}"
				line="${line%%\"*}"
				echo "$line" >> "$CONFTEST_H"
				CONFTEST_H_MODIFIED=yes
				;;
			*( )print*( )\'*)
				line="${line#*\'}"
				line="${line%%\'*}"
				echo "$line" >> "$CONFTEST_H"
				CONFTEST_H_MODIFIED=yes
				;;
			*( )print*( )\;*)
				echo "" >> "$CONFTEST_H"
				CONFTEST_H_MODIFIED=yes
				;;
			*)
				;;
			esac
		fi
	else
		if [[ "$line" == *"BEGIN:FEATURES"* ]]; then
			in_features_region=yes
		fi
	fi
done < "$SRC_ROOT/include/deemon/system-features.h"

if [[ "$WITH_SYSTEM_LIBFFI" == 1 ]]; then
	check_ffi_cc() {
		cat > "$CONFTEST" <<EOF
#include <ffi.h>
$CONFTEST_MAIN{return $1;}
EOF
		if try_check_feature "$1" "$1"; then
			echo "#define CONFIG_HAVE_$1" >> "$CONFINC"
			return 0
		else
			echo "#define CONFIG_NO_$1 /* Missing! */" >> "$CONFINC"
			return 1
		fi
	}
	echo "#define CONFIG_HAVE_SYSTEM_FFI" >> "$CONFINC"
	check_ffi_cc FFI_SYSV
	check_ffi_cc FFI_STDCALL
	check_ffi_cc FFI_THISCALL
	check_ffi_cc FFI_FASTCALL
	check_ffi_cc FFI_MS_CDECL
	check_ffi_cc FFI_PASCAL
	check_ffi_cc FFI_REGISTER
	check_ffi_cc FFI_WIN64
	check_ffi_cc FFI_UNIX64
	check_ffi_cc FFI_GNUW64
	check_ffi_cc FFI_EFI64
fi


# ieee754 detection trick stolen from autoconf
log_checking_begin "Checking for ieee754"
cat > "$CONFTEST" <<EOF
double d = 90904234967036810337470478905505011476211692735615632014797120844053488865816695273723469097858056257517020191247487429516932130503560650002327564517570778480236724525140520121371739201496540132640109977779420565776568942592.0;
EOF
if try_compile_minimal; then
	echo "#define CONFIG_HAVE_FPU" >> "$CONFINC"
	if grep "seesnoon" "$CONFTEST_OUT" > /dev/null 2>&1; then
		log_checking_yes "little-endian"
		echo "#define CONFIG_HAVE_IEEE754" >> "$CONFINC"
		echo "#define CONFIG_HAVE_IEEE754_LE" >> "$CONFINC"
	elif grep "noonsees" "$CONFTEST_OUT" > /dev/null 2>&1; then
		log_checking_yes "big-endian"
		echo "#define CONFIG_HAVE_IEEE754" >> "$CONFINC"
		echo "#define CONFIG_HAVE_IEEE754_BE" >> "$CONFINC"
	else
		log_checking_no
		echo "#define CONFIG_NO_IEEE754" >> "$CONFINC"
	fi
else
	echo "#define CONFIG_NO_IEEE754" >> "$CONFINC"
	cat > "$CONFTEST" <<EOF
double d = 0.0;
EOF
	if try_compile_minimal; then
		log_checking_no
		echo "#define CONFIG_HAVE_FPU" >> "$CONFINC"
	else
		log_checking_no "no FPU support"
		echo "#define CONFIG_NO_FPU" >> "$CONFINC"
	fi
fi


# Cleanup temporary files related to configuration tests
unlink "$CONFTEST" > /dev/null 2>&1
unlink "${CONFTEST_H}.gch" > /dev/null 2>&1
unlink "$CONFTEST_H" > /dev/null 2>&1
unlink "$CONFTEST_OUT" > /dev/null 2>&1
unlink "$CONFTEST_EXE" > /dev/null 2>&1
unlink "${CONFTEST_EXE}.exe" > /dev/null 2>&1



if [ -f "$OUT_ROOT/include/deemon/config.h.old" ]; then
	if [ -f "$OUT_ROOT/include/deemon/config.h" ]; then
		if cmp --silent "$OUT_ROOT/include/deemon/config.h.old" "$OUT_ROOT/include/deemon/config.h"; then
			# Unchanged
			unlink "$OUT_ROOT/include/deemon/config.h"
			mv "$OUT_ROOT/include/deemon/config.h.old" "$OUT_ROOT/include/deemon/config.h"
		else
			# Changed
			unlink "$OUT_ROOT/include/deemon/config.h.old"
		fi
	else
		unlink "$OUT_ROOT/include/deemon/config.h.old"
	fi
fi

if [ -f "$OUT_ROOT/include/deemon/config.h" ]; then
	CONFIG_CFLAGS="$CONFIG_CFLAGS -include include/deemon/config.h"
fi




########################################################################################
## Print the used configuration
########################################################################################
#echo "Paths:"
#echo "    OUT_ROOT: '$OUT_ROOT'"
#echo "    SRC_ROOT: '$SRC_ROOT'"
#echo "    BIN_ROOT: '$BIN_ROOT'"
#echo "    BLD_ROOT: '$BLD_ROOT'"
#echo "Toolchain:"
#echo "    CONFIG_CC:     '$CONFIG_CC'"
#echo "    CONFIG_DEX_CC: '$CONFIG_DEX_CC'"
#echo "    TARGET:        '$TARGET'"
#echo "    TARGET_CPU:    '$TARGET_CPU'"
#echo "    CONFIG_EXE:    '$CONFIG_EXE'"
#echo "    CONFIG_DLL:    '$CONFIG_DLL'"
#echo "Libraries:"
#echo "    CONFIG_LIBM:      '$CONFIG_LIBM'"
#echo "    CONFIG_LIBDL:     '$CONFIG_LIBDL'"
#echo "    CONFIG_LIBSOCKET: '$CONFIG_LIBSOCKET'"
#echo "Compiler flags:"
#echo "    CONFIG_CFLAGS:       '$CONFIG_CFLAGS'"
#echo "    CONFIG_LDFLAGS:      '$CONFIG_LDFLAGS'"
#echo "    CONFIG_LIBS:         '$CONFIG_LIBS'"
#echo "    CONFIG_DEX_CC:       '$CONFIG_DEX_CC'"
#echo "    CONFIG_DEX_CFLAGS:   '$CONFIG_DEX_CFLAGS'"
#echo "    CONFIG_DEX_LDFLAGS:  '$CONFIG_DEX_LDFLAGS'"
#echo "    CONFIG_DEX_LIBS:     '$CONFIG_DEX_LIBS'"
#echo "    CONFIG_CORE_CFLAGS:  '$CONFIG_CORE_CFLAGS'"
#echo "    CONFIG_CORE_LDFLAGS: '$CONFIG_CORE_LDFLAGS'"
#echo "    CONFIG_CORE_LIBS:    '$CONFIG_CORE_LIBS'"
#if [[ "$WITHOUT_DEX_SPECIFIC" != *"CTYPES"* ]]; then
#	echo "CTypes compiler flags:"
#	echo "    CONFIG_DEX_CTYPES_CC:      '$CONFIG_DEX_CTYPES_CC'"
#	echo "    CONFIG_DEX_CTYPES_CFLAGS:  '$CONFIG_DEX_CTYPES_CFLAGS'"
#	echo "    CONFIG_DEX_CTYPES_LDFLAGS: '$CONFIG_DEX_CTYPES_LDFLAGS'"
#	echo "    CONFIG_DEX_CTYPES_LIBS:    '$CONFIG_DEX_CTYPES_LIBS'"
#fi
#echo "Features:"
#echo "    FEATURES:                  '$FEATURES'"
#echo "    WITH_DEX:                  '$WITH_DEX'"
#echo "    WITH_KOS_SYSTEM_HEADERS:   '$WITH_KOS_SYSTEM_HEADERS'"


if [[ "$WITH_KOS_SYSTEM_HEADERS" == "1" ]]; then
	CONFIG_CFLAGS="$CONFIG_CFLAGS -I$(realpath -s --relative-to="$OUT_ROOT" "${SRC_ROOT}/include/deemon/kos-headers")"
fi

unlink "$OUT_ROOT/config.mk" > /dev/null 2>&1
cat > "$OUT_ROOT/config.mk" <<EOF
# Automatically generated file (by ./configure). - Do not edit!
SRC_ROOT := $SRC_ROOT
BIN_ROOT := $BIN_ROOT
BLD_ROOT := $BLD_ROOT

CC = $CONFIG_CC
CXX = $CONFIG_CXX
EXE = $CONFIG_EXE
DLL = $CONFIG_DLL
CFLAGS = $CONFIG_CFLAGS
LDFLAGS = $CONFIG_LDFLAGS
LIBS = $CONFIG_LIBS
LIBM = $CONFIG_LIBM
LIBDL = $CONFIG_LIBDL
LIBSOCKET = $CONFIG_LIBSOCKET

DEX_CC = $CONFIG_DEX_CC
DEX_CFLAGS = $CONFIG_DEX_CFLAGS
DEX_LDFLAGS = $CONFIG_DEX_LDFLAGS
DEX_LIBS = $CONFIG_DEX_LIBS
CORE_CFLAGS = $CONFIG_CORE_CFLAGS
CORE_LDFLAGS = $CONFIG_CORE_LDFLAGS
CORE_LIBS = $CONFIG_CORE_LIBS
EOF

if [[ "$WITH_DEX" == "0" ]]; then
	echo "CONFIG_WITHOUT_DEX :=" >> "$OUT_ROOT/config.mk"
fi
if ! [ -z "$WITHOUT_DEX_SPECIFIC" ]; then
	for name in $WITHOUT_DEX_SPECIFIC; do
		echo "CONFIG_WITHOUT_DEX_$name :=" >> "$OUT_ROOT/config.mk"
	done
fi
if ! [ -z "$CONFIG_DEX_CTYPES_CC" ]; then
	echo "DEX_CTYPES_CC = $CONFIG_DEX_CTYPES_CC" >> "$OUT_ROOT/config.mk"
fi
if ! [ -z "$CONFIG_DEX_CTYPES_CFLAGS" ]; then
	echo "DEX_CTYPES_CFLAGS = $CONFIG_DEX_CTYPES_CFLAGS" >> "$OUT_ROOT/config.mk"
fi
if ! [ -z "$CONFIG_DEX_CTYPES_LDFLAGS" ]; then
	echo "DEX_CTYPES_LDFLAGS = $CONFIG_DEX_CTYPES_LDFLAGS" >> "$OUT_ROOT/config.mk"
fi
if ! [ -z "$CONFIG_DEX_CTYPES_LIBS" ]; then
	echo "DEX_CTYPES_LIBS = $CONFIG_DEX_CTYPES_LIBS" >> "$OUT_ROOT/config.mk"
fi