# Auxiliary functions for custom build system
# Copyright (c) 2002 Serge van den Boom
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

BUILDLOG=/dev/null
TEMPFILE="/tmp/build.$$.tmp"
#KEEPTEMPFILES=keeptempfiles


# Description: perform a command, and set the exit status to the opposite.
#              (true 
# Arguments:   $1 - the command to run
#              rest - arguments to the command
not() {
	local CMD
	CMD=$1
	shift
	"$CMD" "$@"
	return "$(($? == 0))"
}

# Description: prints a command to stdout and then executes it
# Arguments:   command with arguments
# Returns:     the return value of the command
echo_and_perform() {
	cat << EOF
$@
EOF
	"$@"
}

# Description: Get the contents of a variable with a specific name,
#              but don't expand it. (evalVar does expand it)
#              Use this instead of 'eval', so that you won't have to
#              worry about escaping.
#              NB. this function only works on global variables.
# Arguments:   $1 - the name of the variable
# Returns:     0
# Prints:      the value of the variable
getVar() {
	local RESULT
	eval RESULT=\$$1
	cat << EOF
$RESULT
EOF
}

# Description: Get the contents of a variable with a specific name,
#              and expand it. (getVar doesn't expand it)
#              Use this instead of 'eval', so that you won't have to
#              worry about escaping.
#              NB. this function only works on global variables.
# Arguments:   $1 - the name of the variable
# Returns:     0
# Prints:      the value of the variable
evalVar() {
	local RESULT
	eval RESULT=\$$1
	eval RESULT=\""$RESULT"\"
	cat << EOF
$RESULT
EOF
}

# Description: Set the value of a variable with a specific name,
#              and expand it.
#              Use this instead of 'eval', so that you won't have to
#              worry about escaping.
#              NB. this function only works on global variables.
# Arguments:   $1 - the name of the variable
#              $2 - the value to assign to it (will not be expanded)
setVar() {
	eval $1=\$2
}

# Description: delete the files passed as arguments, unless
#              $KEEPTEMPFILES is set.
deleteTempFiles() {
	if [ -n "$KEEPTEMPFILES" ]; then
		return
	fi

	rm -f -- "$@"
}

# Description: read text from stdin to use as a c file to compile
# Arguments:   $1 - CFLAGS to use for compilation (optional)
#              $2 - LDFLAGS to use for linking (optional)
# Returns:     0 - if compile successful
#              something else - if compile failed
try_compile_c() {
	local SYSTEM_FLAGS RESULT

	if [ -z "$COMPILE_C" ]; then
		echo "Fatal: Program \$COMPILE_C is not defined!" >&2
		exit 1
	fi

	SYSTEM_FLAGS="$SYSTEM_BUILD_CFLAGS $SYSTEM_BUILD_LDFLAGS $SYSTEM_HOST_CFLAGS $SYSTEM_HOST_LDFLAGS"
	cat > "$TEMPFILE.c"

	echo_and_perform $COMPILE_C $SYSTEM_FLAGS $1 "$TEMPFILE.c" \
			-o "$TEMPFILE.c.o" >> "$BUILDLOG" 2>&1
	RESULT=$?
	
	if [ $RESULT -eq 0 ]; then
		echo_and_perform $LINK $SYSTEM_FLAGS $2 "$TEMPFILE.c.o" \
				-o "$TEMPFILE.out" >> "$BUILDLOG" 2>&1
		RESULT=$?
	fi
	
	if [ $RESULT -ne 0 ]; then
		echo "Failed program was:" >> "$BUILDLOG"
		echo "+++ START $TEMPFILE.c" >> "$BUILDLOG"
		cat "$TEMPFILE.c" >> "$BUILDLOG"
		echo "+++ END $TEMPFILE.c" >> "$BUILDLOG"
	fi

	deleteTempFiles "$TEMPFILE.c $TEMPFILE.c.o $TEMPFILE.out"

	echo >> "$BUILDLOG"
	return $RESULT
}

# Description: read text from stdin to use as a c file to compile
# Arguments:   $1 - CFLAGS to use for compilation (optional)
#              $2 - LDFLAGS to use for linking (optional)
# Returns:     128 - if compiling or linking failed
#              otherwise - exit status of the program
try_compile_and_run_c() {
	local SYSTEM_FLAGS RESULT

	if [ -z "$COMPILE_C" ]; then
		echo "Fatal: Program \$COMPILE_C is not defined!" >&2
		exit 1
	fi

	SYSTEM_FLAGS="$SYSTEM_BUILD_CFLAGS $SYSTEM_BUILD_LDFLAGS $SYSTEM_HOST_CFLAGS $SYSTEM_HOST_LDFLAGS"
	cat > "$TEMPFILE.c"

	echo_and_perform $COMPILE_C $SYSTEM_FLAGS $1 "$TEMPFILE.c" \
			-o "$TEMPFILE.c.o" >> "$BUILDLOG" 2>&1
	RESULT=$?
	
	if [ $RESULT -eq 0 ]; then
		echo_and_perform $LINK $SYSTEM_FLAGS $2 "$TEMPFILE.c.o" \
				-o "$TEMPFILE.out" >> "$BUILDLOG" 2>&1
		RESULT=$?
	fi

	if [ $RESULT -eq 0 ]; then
		"$TEMPFILE.out"
		RESULT=$?
	fi

	deleteTempFiles "$TEMPFILE.c $TEMPFILE.c.o $TEMPFILE.out"

	echo >> "$BUILDLOG"
	return $RESULT
}

# Description: Output a message to stderr, unless BUILD_SILENT is set
# Arguments: the message
build_message() {
	if [ -z "$BUILD_SILENT" ]; then
	cat >&2 << EOF
$@
EOF
	fi
}

# Description: check if a string is lexicographically before
#              another string
# Arguments:   $1 - the first string
#              $2 - the second string
# Returns:     0 if $1 is lexicographically before $2
#              1 otherwise
lexlt() {
	# The 'test' builtin in some sh shells can't do this.
	# To execute the non-builtin 'test' you need the path, and
	# that differs per system (/bin/test or /usr/bin/test).
	# It says '>=' instead of '<' because expr prints '1' for true,
	# and sh uses 0.
	return `expr "$1" ">=" "$2"`
}

# Description: Check if one version is sufficiently new.
# Arguments:   $1 - the required version
#              $2 - the available version
# Returns:     0 - if $2 is at least as new as $1
#              1 - if $2 is older than $1, or the two strings don't compare
version_match() {
	# To compare the two version strings, the numbers in the version
	# compared numerically, and all string parts should be equal.
	local REST1 REST2 NUM1 NUM2 STR1 STR2 CHECKNUMS
	REST1=$1
	REST2=$2
	CHECKNUMS=0

	while [ -n "$REST1" -a -n "$REST2" ]; do
		NUM1=`$SED -e 's/^\([0-9]*\).*$/\1/' << EOF
$REST1
EOF
`
		NUM2=`$SED -e 's/^\([0-9]*\).*$/\1/' << EOF
$REST2
EOF
`
		REST1=`$SED -e 's/^[0-9]*//' << EOF
$REST1
EOF
`
		REST2=`$SED -e 's/^[0-9]*//' << EOF
$REST2
EOF
`
		if [ "(" -n "$NUM1" -a -z "$NUM2" ")" -o \
				"(" -z "$NUM1" -a -n "$NUM2" ")" ]; then
			# Only one of the versions contains a number here. No match.
			return 1
		fi
		if [ "(" -n "$NUM1" -a -z "$NUM2" ")" -o \
				"(" -z "$NUM1" -a -n "$NUM2" ")" ]; then
			# Only one of the versions contains a number here. No match.
			return 1
		fi

		if [ "$CHECKNUMS" -eq 0 ]; then
			if [ "$NUM1" -gt "$NUM2" ]; then
				# Too old.
				return 1
			fi
			if [ "$NUM1" -lt "$NUM2" ]; then
				# A major number is larger. Minor numbers may be smaller.
				CHECKNUMS=1
			fi
		fi

		STR1=`$SED -e 's/^\([^0-9]*\).*$/\1/' << EOF
$REST1
EOF
`
		STR2=`$SED -e 's/^\([^0-9]*\).*$/\1/' << EOF
$REST2
EOF
`
		REST1=`$SED -e 's/^[^0-9]*//' << EOF
$REST1
EOF
`
		REST2=`$SED -e 's/^[^0-9]*//' << EOF
$REST2
EOF
`

		if [ "x$STR1" "!=" "x$STR2" ]; then
			# String parts don't match
			return 1
		fi
	done

	if [ -n "$REST1" -o -n "$REST2" ]; then
		# One version string contains extra information. No match.
		return 1
	fi

	return 0
}

# Description: try to detect a list of program dependencies.
#              This only makes sure the PROG_xxx_PRESENT flag is set.
#              It does not bail out if a dependency is not found.
#              This function is called for programs in
#              PROG_xxx_DEPEND_DETECT_BIN or LIB_xxx_DEPEND_DETECT_BIN.
#              Using have_program in the respective depend functions would
#              not save the PRESENT flag, as it is executed in a subshell.
# Arguments:   $1 - the list of programs
detect_dependencies_program() {
	local PROGS PROG
	PROGS=$1
	for PROG in $PROGS; do
		have_program "$PROG"
	done
}

# Description: try to detect a list of library dependencies.
#              This only makes sure the LIB_xxx_PRESENT flag is set.
#              It does not bail out if a dependency is not found.
#              This function is called for libraries in
#              PROG_xxx_DEPEND_DETECT_LIB or LIB_xxx_DEPEND_DETECT_LIB.
#              Using have_library in the respective depend functions would
#              not save the PRESENT flag, as it is executed in a subshell.
# Arguments:   $1 - the list of libaries
detect_dependencies_library() {
	local LIBS LIB
	LIBS=$1
	for LIB in $LIBS; do
		have_library "$LIB"
	done
}

# Description: check if a program is present in the path or as a built-in
#              command.
# Arguments:   $1 - The name of the program as it is executed
# Returns:     0 - if the command is found
#              1 - if the command is not found
have_command() {
	type "$1" > /dev/null 2>&1 || false
			# The '|| false' is because if 'type' does not recognise the
			# command, it might return a different value than 1, on some
			# shells.
}

# Description: check if a program is present in the path or as a built-in
#              command.
# Arguments:   $1 - The name of the program as used in config_proginfo after
#                   "BIN_"
have_program() {
	local PROG TEMP_NAME TEMP_FILE TEMP_VERSION TEMP_PRESENT TEMP_DETECT
	local TEMP_DEPEND_DETECT_BIN TEMP_DEPEND_DETECT_LIB

	PROG=$1
	TEMP_NAME=`evalVar "PROG_${PROG}_NAME"`
	if [ -z "$TEMP_NAME" ]; then
		echo "Fatal: Program '$PROG' is not defined!" >&2
		exit 1
	fi
	
	TEMP_PRESENT=`getVar "PROG_${PROG}_PRESENT"`
	if [ -n "$TEMP_PRESENT" ]; then
		return "$TEMP_PRESENT"
	fi

	# If a detection method is specified, try that one first.
	TEMP_DETECT=`evalVar "PROG_${PROG}_DETECT"`	
	if [ -n "$TEMP_DETECT" ]; then
		TEMP_DEPEND_DETECT_BIN=`evalVar "PROG_${PROG}_DEPEND_DETECT_BIN"`
		TEMP_DEPEND_DETECT_LIB=`evalVar "PROG_${PROG}_DEPEND_DETECT_LIB"`
		detect_dependencies_program "$TEMP_DEPEND_DETECT_BIN"
		detect_dependencies_library "$TEMP_DEPEND_DETECT_LIB"
		$TEMP_DETECT
		# NB. TEMP_DETECT should make sure PROG_${PROG}_VERSION and
                # PROG_${PROG}_FILE are set.
		case $? in
			0)  # Program found
				setVar "PROG_${PROG}_PRESENT" 0
				;;
			1)  # Lib not found
				setVar "PROG_${PROG}_PRESENT" 1
				;;
			2)  # Use default detection
				;;
		esac
	fi

	# If detection via a specified detection method was inconclusive,
	# or no detection method was specified, try default detection
	# based on whether the command name exists.
	TEMP_PRESENT=`getVar "$PROG_${PROG}_PRESENT"`
	if [ -z "$TEMP_PRESENT" ]; then
		TEMP_FILE=`evalVar "PROG_${PROG}_FILE"`
		have_command "${TEMP_FILE%% *}"
		if [ $? -eq 0 ]; then
			# Program found
			setVar "PROG_${PROG}_PRESENT" 0
		fi
	fi
	
	# If detection has yielded no results so far, we're calling it
	# "not found".
	TEMP_PRESENT=`getVar "PROG_${PROG}_PRESENT"`
	if [ -z "$TEMP_PRESENT" ]; then
		setVar "PROG_${PROG}_PRESENT" 1
	fi

	TEMP_PRESENT=`getVar "PROG_${PROG}_PRESENT"`
	if [ "$TEMP_PRESENT" -eq 1 ]; then
		build_message "$TEMP_NAME not found."
		return 1
	fi

	# We have found the program.
	# Test whether the version is sufficient.
	if [ $# -gt 1 ]; then
		# Minimum version supplied
		TEMP_VERSION=`evalVar "PROG_${PROG}_VERSION"`
		if [ -z "$TEMP_VERSION" ]; then
			setVar "PROG_${PROG}_PRESENT" 1
			echo "Fatal: Could not determine the version of $TEMP_NAME" >&2
			exit 1
		fi
		if not version_match "$2" "$TEMP_VERSION"; then
			setVar "PROG_${PROG}_PRESENT" 1
			build_message "Found version $TEMP_VERSION of $TEMP_NAME, \
but version $2 is required!"
			return 1
		fi
		setVar "PROG_${PROG}_PRESENT" 0
		build_message "$TEMP_NAME version $TEMP_VERSION found."
		return 0
	fi

	setVar "PROG_${PROG}_PRESENT" 0
	build_message "$TEMP_NAME found."
	return 0
}

# Description: check if a build tool is present, and define the appropriate
#              environment variable for it.
# Arguments:   $1 - The type of compile tool. One of PREPROC_C, MKDEP_C,
#                   COMPILE_C, PREPROC_OBJC, MKDEP_OBJC, COMPILE_OBJC,
#                   and LINK.
have_build_tool() {
	local TOOL TEMP_NAME TEMP_PRESENT DEPENDS DEPEND SUCCESS COMMAND

	TOOL=$1

	TEMP_NAME=`evalVar "BUILDTOOL_${TOOL}_NAME"`
	if [ -z "$TEMP_NAME" ]; then
		echo "Fatal: Build tool '$TOOL' is not defined!" >&2
		exit 1
	fi

	TEMP_PRESENT=`getVar "BUILDTOOL_${TOOL}_PRESENT"`
	if [ -n "$TEMP_PRESENT" ]; then
		return "$TEMP_PRESENT"
	fi

	SUCCESS=0
	DEPENDS=`getVar "BUILDTOOL_${TOOL}_DEPEND"`
	for DEPEND in $DEPENDS; do
		if not have_program "$DEPEND"; then
			SUCCESS=1
		fi
	done

	setVar "BUILDTOOL_${TOOL}_PRESENT" "$SUCCESS"

	COMMAND=`evalVar "BUILDTOOL_${TOOL}_COMMAND"`
			# Environment variables in $BUILDTOOL_xxx_COMMAND are expanded.
	
	if [ $SUCCESS -eq 0 ]; then
		build_message "We have a $TEMP_NAME."
		setVar "$TOOL" "$COMMAND"
	else
		build_message "No $TEMP_NAME found."
	fi

	return $SUCCESS
}
	
have_build_tools_language() {
	local LANGUAGE

	LANGUAGE=$1

	have_build_tool "PREPROC_$LANGUAGE" || return 1
	have_build_tool "MKDEP_$LANGUAGE" || return 1
	have_build_tool "COMPILE_$LANGUAGE" || return 1

	return 0
}


# Description: check if a library is present on the system
# Arguments:   $1 - The name of the library as used in config_proginfo after
#                   "LIB_"
#              $2 - (optional) minimum version required
# Pre:         variables LIB_${1}_NAME, LIB_${1}_CFLAGS, and
#              LIB_${1}_LDFLAGS are expected to exist. If two arguments are
#              supplied, so is LIB_${1}_VERSION.
# Returns:     0 - if the library is found
#              1 - if the library is not found
have_library() {
	local LIB TEMP_NAME TEMP_PRESENT TEMP_LDFLAGS TEMP_CFLAGS \
			TEMP_VERSION TEMP_DETECT
	local TEMP_DEPEND_DETECT_BIN TEMP_DEPEND_DETECT_LIB

	LIB=$1
	TEMP_NAME=`evalVar "LIB_${LIB}_NAME"`
	if [ -z "$TEMP_NAME" ]; then
		echo "Fatal: Library '$LIB' is not defined!" >&2
		exit 1
	fi

	TEMP_PRESENT=`getVar "LIB_${LIB}_PRESENT"`
	if [ -n "$TEMP_PRESENT" ]; then
		return "$TEMP_PRESENT"
	fi
	
	# If a detection method is specified, try that one first.
	TEMP_DETECT=`evalVar "LIB_${LIB}_DETECT"`
	if [ -n "$TEMP_DETECT" ]; then
		TEMP_DEPEND_DETECT_BIN=`evalVar "LIB_${LIB}_DEPEND_DETECT_BIN"`
		TEMP_DEPEND_DETECT_LIB=`evalVar "LIB_${LIB}_DEPEND_DETECT_LIB"`
		detect_dependencies_program "$TEMP_DEPEND_DETECT_BIN"
		detect_dependencies_library "$TEMP_DEPEND_DETECT_LIB"
		$TEMP_DETECT
		# NB. TEMP_DETECT should make sure PROG_$LIB_VERSION is set.
		# return value of $TEMP_DETECT is used below.
		case $? in
			0)  # Lib found
				setVar "LIB_${LIB}_PRESENT" 0
				;;
			1)  # Lib not found
				setVar "LIB_${LIB}_PRESENT" 1
				;;
			2)  # Use default detection
				;;
		esac
	fi

	# If detection via a specified detection method was inconclusive,
	# or no detection method was specified, try default detection
	# based on whether we can compile against the library.
	TEMP_PRESENT=`getVar "LIB_${LIB}_PRESENT"`
	if [ -z "$TEMP_PRESENT" ]; then
		TEMP_CFLAGS=`evalVar "LIB_${LIB}_CFLAGS"`
		TEMP_LDFLAGS=`evalVar "LIB_${LIB}_LDFLAGS"`

		try_compile_c "$CFLAGS $TEMP_CFLAGS" "$LDFLAGS $TEMP_LDFLAGS" << EOF
int main(void) {
	return 0;
}
EOF
		if [ $? -eq 0 ]; then
			# Build successful
			setVar "LIB_${LIB}_PRESENT" 0
		fi
	fi
	
	# If detection has yielded no results so far, we're calling it
	# "not found".
	TEMP_PRESENT=`getVar "LIB_${LIB}_PRESENT"`
	if [ -z "$TEMP_PRESENT" ]; then
		setVar "LIB_${LIB}_PRESENT" 1
	fi

	TEMP_PRESENT=`getVar "LIB_${LIB}_PRESENT"`
	if [ "$TEMP_PRESENT" -eq 1 ]; then
		build_message "$TEMP_NAME not found."
		return 1
	fi

	# We have found the library.
	# Test whether the version is sufficient.
	if [ $# -gt 1 ]; then
		# Minimum version supplied
		TEMP_VERSION=`evalVar "LIB_${LIB}_VERSION"`
		if [ -z "$TEMP_VERSION" ]; then
			setVar "LIB_${LIB}_PRESENT" 1
			echo "Fatal: Could not determine the version of $TEMP_NAME" >&2
			exit 1
		fi
		if not version_match "$2" "$TEMP_VERSION"; then
			setVar "LIB_${LIB}_PRESENT" 1
			build_message "Found version $TEMP_VERSION of $TEMP_NAME, \
but version $2 is required!"
			return 1
		fi
		setVar "LIB_${LIB}_PRESENT" 0
		build_message "$TEMP_NAME version $TEMP_VERSION found."
		return 0
	fi

	setVar "LIB_${LIB}_PRESENT" 0
	build_message "$TEMP_NAME found."
	return 0
}

# Description: check if a library is present on the system.
#              If it is, add the appropriate flags to CFLAGS and LDFLAGS.
#              If not, bail out.
# Arguments:   $1 - The name of the library as used in config_proginfo after
#                   "LIB_"
#              $2 - (optional) minimum version required
# Pre:         variables LIB_${1}_NAME, LIB_${1}_CFLAGS, and
#              LIB_${1}_LDFLAGS are expected to exist. If two arguments are
#              supplied, so is LIB_${1}_VERSION.
use_library() {
	local TEMP_CFLAGS TEMP_LDFLAGS
	have_library "$@"
	[ $? -eq 0 ] || exit 1

	TEMP_CFLAGS=`evalVar "LIB_${1}_CFLAGS"`
	TEMP_LDFLAGS=`evalVar "LIB_${1}_LDFLAGS"`
	CFLAGS="$CFLAGS $TEMP_CFLAGS"
	LDFLAGS="$LDFLAGS $TEMP_LDFLAGS"
	return 0
}

# Description: check if a library are being provided by a framework outside
#              of the normal system build process.
#              If it is, mark it as found and add appropriate flags
#              If not, do nothing. Do not even mark it as not found; it might
#              be available by some other means.
#              This function is currently specific to macOS builds.
# Arguments:   $1        - The name of the library as used in config_proginfo
#              $2        - (optional, default $1) the name of the framework
#              DEPS_PATH - environment variable that if set specifies where to
#                          check for the framework.
# Pre:         LIB_${1}_NAME is expected to exist.
have_framework() {
	local TEMP_LIBNAME LIB LIBVAR FRAMEWORK_PATH
	# If we aren't on a Mac, there is no framework
	if [[ "x$HOST_SYSTEM" != "xDarwin" ]]; then
		return 1
	fi
	# If DEPS_PATH was not configured, there is no framework
	if [[ -z "$DEPS_PATH" ]]; then
		return 1
	fi
	LIBVAR=$1
	LIB=$2
	if [[ -z "$2" ]]; then
		LIB=$LIBVAR
	fi
	TEMP_LIBNAME=`evalVar "LIB_${LIBVAR}_NAME"`
	FRAMEWORK_PATH="${DEPS_PATH}/${LIB}.framework"
	if [[ -d "$FRAMEWORK_PATH" ]]; then
		build_message "${TEMP_LIBNAME} found in ${DEPS_PATH}."
		setVar "LIB_${LIBVAR}_PRESENT" 0
		setVar "LIB_${LIBVAR}_CFLAGS" "-F${DEPS_PATH} -I${FRAMEWORK_PATH}/Headers"
		setVar "LIB_${LIBVAR}_LDFLAGS" "-F${DEPS_PATH} -framework ${LIB}"
		return 0
	fi
	build_message "${TEMP_LIBNAME} not found in ${DEPS_PATH}."
	return 1
}

# Description: check if a symbol is defined
# Arguments:   $1 - the name of the symbol
#              $2 - the C code that does the actual checking
have_symbol_generic() {
	local CODE DETECT EXTRA

	DETECT=`evalVar "SYMBOL_${1}_DETECT"`
	if [ -n "$DETECT" ]; then
		$DETECT
		return $?
	fi

	EXTRA=`evalVar "SYMBOL_${1}_EXTRA"`
	CODE=`evalVar "SYMBOL_${1}_CODE"`
	if [ -z "$CODE" ]; then
		CODE=$2
	fi

	try_compile_c "$CFLAGS $TEMP_CFLAGS" "$LDFLAGS $TEMP_LDFLAGS" << EOF > /dev/null 2>&1
#include <sys/types.h>
$EXTRA

$CODE
EOF
}

# Description: check if a symbol is defined.
# Arguments:   $1 - the name of the symbol
have_symbol() {
	local SYMBOL TEMP_PRESENT CODE
	SYMBOL=$1

	TEMP_PRESENT=`getVar "SYMBOL_${SYMBOL}_PRESENT"`
	if [ -n "$TEMP_PRESENT" ]; then
		return "$TEMP_PRESENT"
	fi

	CODE=`cat << EOF	
int main(void) {
	(void) $SYMBOL;
	return 0;
}
EOF
`

	have_symbol_generic "$SYMBOL" "$CODE"
	if [ $? -gt 0 ]; then
		build_message "Symbol '$SYMBOL' not found."
		setVar "SYMBOL_${SYMBOL}_PRESENT" 1
		return 1
	fi
	build_message "Symbol '$SYMBOL' found."
	setVar "SYMBOL_${SYMBOL}_PRESENT" 0
	return 0
}

# Description: check if a type is present.
# Arguments:   $1 - the name of the symbol
have_type() {
	local TYPE TEMP_PRESENT CODE
	TYPE=$1
	
	TEMP_PRESENT=`getVar "TYPE_${TYPE}_PRESENT"`
	if [ -n "$TEMP_PRESENT" ]; then
		return "$TEMP_PRESENT"
	fi

	CODE=`cat << EOF	
int main(void) {
	$TYPE var;
	(void) var;
	return 0;
}
EOF
			`

	have_symbol_generic "$TYPE" "$CODE"
	if [ $? -gt 0 ]; then
		build_message "Type '$TYPE' not found."
		setVar "TYPE_${TYPE}_PRESENT" 1
		return 1
	fi
	build_message "Type '$TYPE' found."
	setVar "TYPE_${TYPE}_PRESENT" 0
	return 0
}

# Description: check if a symbol is defined.
#              sets HAVE_<NAME> accordingly, where <NAME> is the capitalized
#              name of the symbol.
# Arguments:   $1 - the name of the symbol
define_have_symbol() {
	local NAME VALUE DEFNAME

	DEFNAME=`getVar "SYMBOL_${1}_DEFNAME"`
	if [ -z "$DEFNAME" ]; then
		# Why not "tr [:lower:] [:upper:]"? Because the capital "i" is not
		# "I" in Turkish... An alternative would be setting LC_CTYPE to POSIX.
		NAME=`$TR "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
				<< EOF
$1
EOF
				`
		DEFNAME="HAVE_$NAME"
	fi

	if have_symbol "$1"; then
		add_symbol "$DEFNAME" "#define $DEFNAME"
		add_symbol "${DEFNAME}_FLAG" 1
	else
		add_symbol "$DEFNAME" "#undef $DEFNAME"
		add_symbol "${DEFNAME}_FLAG" 0
	fi
}

# Description: check if a type is present.
#              set HAVE_<NAME> accordingly, where <NAME> is the capitalized
#              name of the symbol.
# Arguments:   $1 - the name of the symbol
define_have_type() {
	local NAME VALUE DEFNAME

	DEFNAME=`getVar "TYPE_${1}_DEFNAME"`
	if [ -z "$DEFNAME" ]; then
		# Why not "tr [:lower:] [:upper:]"? Because the capital "i" is not
		# "I" in Turkish... An alternative would be setting LC_CTYPE to POSIX.
		NAME=`$TR "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
				<< EOF
$1
EOF
				`
		DEFNAME="HAVE_$NAME"
	fi

	if have_type "$1"; then
		add_symbol "$DEFNAME" "#define $DEFNAME"
		add_symbol "${DEFNAME}_FLAG" 1
	else
		add_symbol "$DEFNAME" "#undef $DEFNAME"
		add_symbol "${DEFNAME}_FLAG" 0
	fi
}

# Description: check if a header is available.
# Arguments:   $1 - the name of the header file
have_header() {
	local HEADER NAME EXTRA
	HEADER=$1

	NAME=${HEADER%.h}
	EXTRA=`evalVar "HEADER_${NAME}_EXTRA"`

	try_compile_c "$CFLAGS $TEMP_CFLAGS" "$LDFLAGS $TEMP_LDFLAGS" << EOF > /dev/null 2>&1
$EXTRA
#include <$HEADER>
int main(void) {
	return 0;
}
EOF
	if [ $? -gt 0 ]; then
		build_message "Header '$HEADER' not found."
		return 1
	fi
	build_message "Header '$HEADER' found."
	return 0
}

# Description: check if a header is available.
#              sets HAVE_<NAME> accordingly, where <NAME> is the capitalized
#              name of the header file. "sys/time.h" becomes "SYS_TIME_H".
# Arguments:   $1 - the name of the header file
define_have_header() {
	local NAME VALUE DEFNAME
	
	DEFNAME=`getVar "HEADER_${1%.h}_DEFNAME"`
	if [ -z "$DEFNAME" ]; then
		# Why not "tr [:lower:] [:upper:]"? Because the capital "i" is not
		# "I" in Turkish... An alternative would be setting LC_CTYPE to POSIX.
		NAME=`$TR "/.abcdefghijklmnopqrstuvwxyz" \
				"__ABCDEFGHIJKLMNOPQRSTUVWXYZ" << EOF
$1
EOF
				`
		DEFNAME="HAVE_$NAME"
	fi

	if have_header "$1"; then
		add_symbol "$DEFNAME" "#define $DEFNAME"
		add_symbol "${DEFNAME}_FLAG" 1
	else
		add_symbol "$DEFNAME" "#undef $DEFNAME"
		add_symbol "${DEFNAME}_FLAG" 0
	fi
}

# Description: check if a macro is available.
# Arguments:   $1 - the name of the macro
have_macro() {
	local MACRO EXTRA
	MACRO=$1

	EXTRA=`evalVar "MACRO_${NAME}_EXTRA"`

	try_compile_c "$CFLAGS $TEMP_CFLAGS" "$LDFLAGS $TEMP_LDFLAGS" << EOF > /dev/null 2>&1
$EXTRA
#ifndef $MACRO
#	error
#endif
int main(void) {
	return 0;
}
EOF
	if [ $? -gt 0 ]; then
		build_message "Preprocessor macro '$MACRO' not found."
		return 1
	fi
	build_message "Preprocessor macro '$MACRO' found."
	return 0
}

# Description: check if a macro is defined
#              sets MACRO_<NAME> to a non-empty string if the macro with
#              the specified name is defined, and to an empty string if it
#              is not.
# Arguments:   $1 - the name of the symbol
define_have_macro() {
	local NAME

	NAME=$1

	if have_macro "$1"; then
		add_symbol "MACRO_$NAME" "1"
	else
		add_symbol "MACRO_$NAME" ""
	fi
}

# Description: Add a symbol to be replaced by substitute_vars
#              $HAVE_SYMBOLS will contain the variable names of all
#              symbols added by define_have_symbol and should be passed to
#              substitute_vars for the file you want them in.
# Arguments:   $1 - the symbol to add
#              $2 - the value of the symbol
add_symbol() {
	local NAME

	eval NAME="$1"
	eval "$NAME"=\"\$2\"
	HAVE_SYMBOLS="$HAVE_SYMBOLS $NAME"
}

check_endianness() {
	local ENDIAN	

	if [ "$BUILD_SYSTEM" '!=' "$HOST_SYSTEM" ]; then
		case "$BUILD_HOST_ENDIAN" in
			"")
				build_message "Cross-compiling - assuming little-endian host."
				ENDIAN=little
				;;
			big)
				build_message "Cross-compiling for a big-endian host."
				ENDIAN=big
				;;
			little)
				build_message "Cross-compiling for a little-endian host."
				ENDIAN=little
				;;
			*)
				build_message "Bad endianness specified. Use \"little\" or \"big\""
				exit 1
				;;
		esac
	else
		# Detect endianness
		try_compile_and_run_c "$CFLAGS" "$LDFLAGS" << EOF
int main(void) {
	int i;

	i = 1;
	return *((unsigned char *) &i);
}
EOF
		if [ $? -eq 0 ]; then
			build_message "Big-endian machine detected."
			ENDIAN=big
		else
			build_message "Little-endian machine detected."
			ENDIAN=little
		fi
	fi

	case "$ENDIAN" in
		big)
			add_symbol WORDS_BIGENDIAN "#define WORDS_BIGENDIAN"
			add_symbol "WORDS_BIGENDIAN_FLAG" 1
			;;
		little)
			add_symbol WORDS_BIGENDIAN "#undef WORDS_BIGENDIAN"
			add_symbol "WORDS_BIGENDIAN_FLAG" 0
			;;
	esac
}


# Description: If pkg-config is installed, check if there's a pkg-config
#              entry for some binary dependency.
#              If successful, it sets the appropriate BIN_xxx_VERSION.
# Arguments:   $1 - The name of the program as it is known in
#                   config_proginfo after "BIN_"
#              $2 - The name of the dependency as it would be known to
#                   pkg-config.
try_pkgconfig_prog() {
	have_program pkgconfig || return 1

	local PROG PKG_NAME TEMP_NAME
	PROG=$1
	PKG_NAME=$2

	TEMP_NAME=`evalVar "PROG_${PROG}_NAME"`
	if [ -z "$TEMP_NAME" ]; then
		echo "Fatal: Program '$PROG' is not defined!" >&2
		exit 1
	fi

	if $PROG_pkgconfig_FILE --exists "$PKG_NAME"; then
		local TEMP_VERSION
		TEMP_VERSION=$($PROG_pkgconfig_FILE --modversion "$PKG_NAME")
		setVar "PROG_${PROG}_VERSION" "$TEMP_VERSION"
		return 0
	else
		return 2
	fi
}


# Description: If pkg-config is installed, check if there's a pkg-config
#              entry for some dependency.
#              If successful, it sets the appropriate LIB_xxx_VERSION,
#              LIB_xxx_CFLAGS and LIB_xxx_LDFLAGS.
# Arguments:   $1 - The name of the library as it is known in
#                   config_proginfo after "LIB_"
#              $2 - The name of the dependency as it would be known to
#                   pkg-config.
try_pkgconfig_lib() {
	have_program pkgconfig || return 1

	local LIB PKG_NAME TEMP_NAME
	LIB=$1
	PKG_NAME=$2

	TEMP_NAME=`evalVar "LIB_${LIB}_NAME"`
	if [ -z "$TEMP_NAME" ]; then
		echo "Fatal: Library '$LIB' is not defined!" >&2
		exit 1
	fi

	if $PROG_pkgconfig_FILE --exists "$PKG_NAME"; then
		local TEMP_VERSION TEMP_CFLAGS TEMP_LDFLAGS
		TEMP_VERSION=$($PROG_pkgconfig_FILE --modversion "$PKG_NAME")
		TEMP_CFLAGS=$($PROG_pkgconfig_FILE --cflags "$PKG_NAME")
		TEMP_LDFLAGS=$($PROG_pkgconfig_FILE --libs "$PKG_NAME")
		setVar "LIB_${LIB}_VERSION" "$TEMP_VERSION"
		setVar "LIB_${LIB}_CFLAGS" "$TEMP_CFLAGS"
		setVar "LIB_${LIB}_LDFLAGS" "$TEMP_LDFLAGS"
		return 2  # Force testing using the new CFLAGS and LDFLAGS
		#return 0
	else
		return 2
	fi
}


# Description: substitute variables in files.
#              Every supplied variable name found between @'s in the
#              supplied files, is replaced by its value.
# Arguments:   $1 - The name of the variable which contains a list of
#                   variables to substitute in the files.
#              $2 - The name of the variable which contains a list of
#                   files to substitute variables in.
#                   If a filename ends on .in, that filename is used as
#                   source, and the filename without .in as target.
#                   If a filename doesn't end on .in, that filename is used
#                   as target, and the filename with .in attached as source.
#              $3 - A path to which the input file names are relative
#              $4 - A path to which the output file names are relative
substitute_vars() {
	local VARS VAR VALUE FILES FILE SRC_PATH DST_PATH

	eval VARS=\"\$$1\"
	eval FILES=\"\$$2\"
	SRC_PATH="$3"
	DST_PATH="$4"

	for VAR in $VARS; do
		# Escape all / in VAR so that we can use / as seperator char for sed
		eval VALUE=\"\$$VAR\"
		VALUE=$(echo "$VALUE" | $SED -e 's,\([\&/]\),\\\1,g')
		cat << EOF
s/@${VAR}@/${VALUE}/g
EOF
	done > "${TEMPFILE}.sed"

	for FILE in $FILES; do
		FILE="${FILE%.in}"
		cp -p -- "$SRC_PATH/$FILE".in "$DST_PATH/$FILE"
				# The copy is done so that the file modes are equal.
		$SED -f "${TEMPFILE}.sed" < "$SRC_PATH/$FILE".in > "$DST_PATH/$FILE"
	done
	deleteTempFiles "${TEMPFILE}.sed"
}

# Define the build system type.
set_build_system() {
	BUILD_SYSTEM=`uname -s`
}

# Define the host system type.
set_host_system() {
	local UHOST

	if [ -z "$BUILD_HOST" ]; then
		HOST_SYSTEM=$BUILD_SYSTEM
	else
		case "$BUILD_HOST" in
			*-*-*)
				HOST_SYSTEM="${BUILD_HOST#*-}"
				HOST_SYSTEM="${HOST_SYSTEM%-*}"
				;;
		esac

		# Use a single capitalization.
		# What is used is whatever 'uname -s' would give on such a platform.
		case "$BUILD_HOST" in
			[Ll][Ii][Nn][Uu][Xx])
				HOST_SYSTEM="Linux" ;;
			[Ff][Rr][Ee][Ee][Bb][Ss][Dd])
				HOST_SYSTEM="FreeBSD" ;;
			[Oo][Pp][Ee][Nn][Bb][Ss][Dd])
				HOST_SYSTEM="OpenBSD" ;;
			[Mm][Ii][Nn][Gg][Ww]|[Mm][Ii][Nn][Gg][Ww]32)
				HOST_SYSTEM="MINGW32" ;;
			[Cc][Yy][Gg][Ww][Ii][Nn]*)
				HOST_SYSTEM="CYGWIN" ;;
			[Dd][Aa][Rr][Ww][Ii][Nn])
				HOST_SYSTEM="Darwin" ;;
			[Ss][Uu][Nn][Oo][Ss])
				HOST_SYSTEM="SunOS" ;;
			[Qq][Nn][Xx])
				HOST_SYSTEM="QNX" ;;
			[Cc][Ee][Gg][Cc][Cc])
				HOST_SYSTEM="cegcc" ;;
			[Ww][Ii][Nn][Ss][Cc][Ww])
				HOST_SYSTEM="WINSCW" ;;
			[Aa][Rr][Mm][Vv]5)
				HOST_SYSTEM="ARMV5" ;;
			[Gg][Cc][Cc][Ee])
				HOST_SYSTEM="GCCE" ;;				
			*)
				build_message "Warning: host type '$BUILD_HOST' unknown. Using defaults."
				;;
		esac
	fi

}

set_system() {
	set_build_system
	set_host_system
}

prepare_build_system() {
	# Include information about programs we can detect for the build system.
	. build/unix/config_proginfo_build
}

prepare_host_system() {
	# Include information about programs we can detect for the host system.
	. build/unix/config_proginfo_host
}

# Some initialisations
HAVE_SYMBOLS=""

config_requirements() {
	# Requirements for the config program itself
	have_program echon || exit 1
	ECHON="$PROG_echon_FILE"
	have_program sed || exit 1
	SED="$PROG_sed_FILE"
	have_program tr || exit 1
	TR="$PROG_tr_FILE"
	have_program make || exit 1
	MAKE="$PROG_make_FILE"
}