configure

#!/bin/sh

# configure script for FlexibleSUSY
# Author: Alexander Voigt

PROGRAM_NAME=FlexibleSUSY
FLEXIBLESUSY_MAJOR=1
FLEXIBLESUSY_MINOR=7
FLEXIBLESUSY_PATCH=1
FLEXIBLESUSY_EXTRA=""
FLEXIBLESUSY_VERSION="${FLEXIBLESUSY_MAJOR}.${FLEXIBLESUSY_MINOR}.${FLEXIBLESUSY_PATCH}${FLEXIBLESUSY_EXTRA}"
GIT_COMMIT=$(git rev-parse HEAD 2> /dev/null || echo unknown)
GM2CALC_VERSION="1.3.0"

# directory of this script
BASEDIR=$(dirname $0)

# absolute path to this script
ABSBASEDIR=$(cd "$BASEDIR"; pwd | sed 's/ /\\\\ /g')

# config directory
CONFIGDIR="${BASEDIR}/config"

# current date
DATE=$(date 2>/dev/null || echo unknown)

# platform information
debmultiarch=""

# default library directories
ld_library_path=$(echo "${LD_LIBRARY_PATH}" | tr ':' ' ')
default_lib_paths="${ld_library_path} /usr/lib /usr/local/lib"
default_inc_paths="/usr/include /usr/local/include"

# configure log file
logfile="$BASEDIR/config.log"
statusfile="$BASEDIR/config.status"
sarahconfig="$BASEDIR/config.sarah"
mathconfig="$BASEDIR/config.math"

# whether we are in 32-bit or 64-bit environment
machine_word_size="unknown"

# operating system
operating_system="unknown"

# kernel version (uname -r)
kernel_version="unknown"

# target makefile
MAKEFILE=$BASEDIR/Makefile
MAKEFILE_TMPL=${CONFIGDIR}/Makefile.in

# target config script
FSCONFIG=$BASEDIR/flexiblesusy-config
FSCONFIG_TMPL=${CONFIGDIR}/flexiblesusy-config.in

# target sarah dependency generation script
SARAH_DEP_GEN=${CONFIGDIR}/list_sarah_model_files.sh
SARAH_DEP_GEN_TMPL=${CONFIGDIR}/list_sarah_model_files.sh.in

# target config header
CONFIGHDR=${CONFIGDIR}/config.h
CONFIGHDR_TMPL=${CONFIGDIR}/config.h.in

# target tex file with package version
TEXVERSION=$BASEDIR/doc/version.tex
TEXVERSION_TMPL=$BASEDIR/doc/version.tex.in

# target dox file with Doxygen \mainpage
DOC_MAINPAGE=$BASEDIR/doc/mainpage.dox
DOC_MAINPAGE_TMPL=$BASEDIR/doc/mainpage.dox.in

# target makefile file for the standalone example
STANDALONE_MAKEFILES="\
 ${BASEDIR}/examples/standalone-model/Makefile \
 ${BASEDIR}/examples/standalone-rge/Makefile"
STANDALONE_MAKEFILE_TMPL="${BASEDIR}/config/Makefile.standalone.in"

# target makefile file for the tower example
TOWER_MAKEFILES="
 ${BASEDIR}/examples/tower/Makefile"
TOWER_MAKEFILE_TMPL="${BASEDIR}/config/Makefile.tower.in"

# target makefile file for the customized betas example
CUSTOMBETAS_MAKEFILES="
 ${BASEDIR}/examples/customized-betas/Makefile"
CUSTOMBETAS_MAKEFILE_TMPL="${BASEDIR}/config/Makefile.customized-betas.in"

# options
deprecated_options=""
options="                    \
   enable_colors             \
   enable_compile            \
   enable_compiler_warnings  \
   enable_debug              \
   enable_fflite             \
   enable_lapack             \
   enable_librarylink        \
   enable_looptools          \
   enable_mass_error_check   \
   enable_silent             \
   enable_shared_libs        \
   enable_sqlite             \
   enable_static             \
   enable_threads            \
   enable_tsil               \
   enable_verbose            \
"

# BEGIN: NOT EXPORTED ##########################################
options="${options}          \
   enable_meta               \
"
# END:   NOT EXPORTED ##########################################

enable_compile="yes"
enable_compiler_warnings="no"
enable_colors="no"
enable_debug=""
enable_mass_error_check="no"
enable_fflite="no"
enable_lapack="automatic"
enable_librarylink="automatic"
enable_ilp64mkl_workaround="automatic"
enable_looptools="no"
enable_meta="no"
# BEGIN: NOT EXPORTED ##########################################
enable_meta="yes"
# END:   NOT EXPORTED ##########################################
enable_silent="no"
enable_sqlite="automatic"
enable_shared_libs="no"
enable_static="no"
enable_threads="automatic"
enable_tsil="automatic"
enable_verbose="no"

# corresponding preprocessor define statements
DEFINE_ENABLE_COLOR_PRINTOUT="#undef ENABLE_COLOR_PRINTOUT"
DEFINE_ENABLE_DEBUG="#undef ENABLE_DEBUG"
DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR="#undef CHECK_EIGENVALUE_ERROR"
DEFINE_ENABLE_FFLITE="#undef ENABLE_FFLITE"
DEFINE_ENABLE_LAPACK="#undef ENABLE_LAPACK"
DEFINE_ENABLE_LIBRARYLINK="#undef ENABLE_LIBRARYLINK"
DEFINE_ENABLE_ILP64MKL_WORKAROUND="#undef ENABLE_ILP64MKL_WORKAROUND"
DEFINE_ENABLE_LOOPTOOLS="#undef ENABLE_LOOPTOOLS"
DEFINE_ENABLE_RANDOM="#undef ENABLE_RANDOM"
DEFINE_ENABLE_SILENT="#undef ENABLE_SILENT"
DEFINE_ENABLE_SQLITE="#undef ENABLE_SQLITE"
DEFINE_ENABLE_THREADS="#define ENABLE_THREADS 1"
DEFINE_ENABLE_TSIL="#undef ENABLE_TSIL"
DEFINE_ENABLE_VERBOSE="#undef ENABLE_VERBOSE"
DEFINE_ENABLE_TWO_SCALE_SOLVER="#undef ENABLE_TWO_SCALE_SOLVER"
DEFINE_ENABLE_LATTICE_SOLVER="#undef ENABLE_LATTICE_SOLVER"
DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER="#undef ENABLE_SEMI_ANALYTIC_SOLVER"
DEFINE_ENABLE_ADDONS=""

boost_lib_dir=""
boost_inc_dir=""
eigen_inc_dir=""
BOOSTFLAGS=""
gsl_config="gsl-config"
blas_lib_dir=""
lapack_lib_dir=""
looptools_lib_dir=""
looptools_inc_dir=""
GSLFLAGS=""
CPPFLAGS=""
CXXFLAGS="-std=c++11 -O2 -fPIC"
CFLAGS="-O2"
FFLAGS="-O2 -fPIC"
FLIBS=""
BOOSTTESTLIBS=""
BOOSTTHREADLIBS=""
THREADLIBS=""
CXX="g++"
CC="gcc"
EIGENFLAGS=""
FC="gfortran"
GSLLIBS=""
INSTALL_DIR=""
BLASLIBS=""
LAPACKLIBS=""
MATH="math"
OPTIONAL_MODULES=""
pthread_lib_dir=""
STATIC_LIB_EXT=".a"
STATIC_LIB_CMD="ar cru"
STATIC_LDFLAGS="-static"
STATIC_LDLIBS="-lquadmath -ldl"
SHARED_LIB_EXT=".so"
SHARED_LIB_CMD="$CXX -shared -o"
SHARED_LDFLAGS=""
SHARED_LDLIBS=""
MODULE_LIBEXT="$STATIC_LIB_EXT"
MODULE_MAKE_LIB_CMD="$STATIC_LIB_CMD"
LIBLNK_LIBEXT="$SHARED_LIB_EXT"
LIBLNK_MAKE_LIB_CMD="$SHARED_LIB_CMD"
LOOPFUNCFLAGS=""
LOOPFUNCLIBS=""
LDFLAGS="$SHARED_LDFLAGS"
LDLIBS="$SHARED_LDLIBS"
sqlite_lib_dir=""
sqlite_inc_dir=""
tsil_lib_dir=""
tsil_inc_dir=""
# available RG solvers
SOLVERS="two_scale"
available_solvers="two_scale lattice semi_analytic"
# models that will be compiled
MODELS="all"
# BEGIN: NOT EXPORTED ##########################################
MODELS=""
# END:   NOT EXPORTED ##########################################
# addons that will be compiled
ADDONS=""

# C++ compiler type and version
cxx_compiler_type="unknown"
cxx_compiler_version="unknown"

# required C++ compiler versions
required_cxx_compiler_version="unknown"
required_gpp_compiler_version="4.7.2"
required_clang_compiler_version="3.1.0"
required_icpc_compiler_version="12.1.0"

# C++ compiler versions accepting `-std=c++11'
std_cxx11_compiler_version="unknown"
std_cxx11_gpp_version="4.7.0"
std_cxx11_clang_version="3.0.0"
std_cxx11_icpc_version="13.0.0"

# required boost version
required_boost_version="1.37.0"

# required Mathematica version
required_mathematica_version="7"

# required SARAH version
required_sarah_major="4"
required_sarah_minor="0"
required_sarah_patch="4"
required_sarah_version="${required_sarah_major}.${required_sarah_minor}.${required_sarah_patch}"
SARAH_VERSION="unknown"
SARAH_MAJOR="0"
SARAH_MINOR="0"
SARAH_PATCH="0"

# Mathematica version (0 = unknown)
MATH_VERSION="0"

# Mathematica system ID
MATH_SYSTEMID=""

# Mathematica installation directory
MATH_INSTDIR=""

# string to eval when script terminates, normally or not
actions_at_exit=""

#_____________________________________________________________________
at_exit() {
    local action
    for action in "$@"; do
	printf "%s\n" "$actions_at_exit" | grep -F -e "$action" > /dev/null ||
	actions_at_exit="$actions_at_exit
$action"
    done
}

#_____________________________________________________________________
do_actions_at_exit() {
    logmsg "Executing clean-up actions:$actions_at_exit"
    eval "$actions_at_exit"
}

#_____________________________________________________________________
write_configure_parameters() {
    # This function writes all parameters [$*] to config.status
    echo "$*" > "$statusfile"
}

#_____________________________________________________________________
message() {
    # Write a simple message to std out (and to the log file)
    if test $# -lt 1 ; then
        echo "message: Too few arguments"
        return 1
    fi
    echo "$*"
    logmsg "$*"
}

#_____________________________________________________________________
logmsg() {
    # Write message to the log file.  Use -n as first parameter to
    # prevent a newline at the end of the message.
    if test $# -lt 1 ; then
        echo "logmsg: Too few arguments"
        return 1
    fi
    if test "x$1" = "x-n"; then
       shift
       printf "%s" "$*" >> $logfile
    else
       echo "$*" >> $logfile
    fi
}

#_____________________________________________________________________
log_package_information() {
    logmsg "Package:    ${PROGRAM_NAME}"
    logmsg "Version:    ${FLEXIBLESUSY_VERSION}"
    logmsg "Date:       ${DATE}"
    logmsg "Git commit: ${GIT_COMMIT}"
}

#_____________________________________________________________________
guess_machine_word_size() {
    local chip="$(uname -m | tr '[A-Z]' '[a-z]')"
    case "$chip" in
        *32|i[36]86)
             machine_word_size="32"; return 0 ;;
        *64) machine_word_size="64"; return 0 ;;
        *)   machine_word_size="unknown"
             message "Warning: could not guess machine word size"
             return 1 ;;
    esac
}

#_____________________________________________________________________
contains() {
    # Check if string $1 contains $2
    if test $# -lt 2 ; then
        echo "contains: Too few arguments"
        return 1
    fi
    local string="$1"
    local substring="$2"
    for f in ${string}; do
        test "x$f" = "x$substring" && return 0
    done
    return 1 # not found
}

#_____________________________________________________________________
contains_not() {
    # Check if string $1 does not contain $2
    if test $# -lt 2 ; then
        echo "contains: Too few arguments"
        return 1
    fi
    ! contains "$1" "$2"
}

#_____________________________________________________________________
check_library() {
    # This function will try to locate a library [$1] in the directory
    # given in $2 or in a default path [$*].
    #
    # The result of the search is stored in found_lib and found_dir,
    # which should be immediately copied, since the variables value will
    # be overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -lt 3 ; then
        echo "check_library: Too few arguments"
        return 1
    fi

    # Save arguments in local names
    lib=$1       ; shift
    libdirl=$1
    libdirs="$*"
    # check if we got a specific argument as to where the library
    # is to be found
    if test ! "x$libdirl" = "x" ; then
        libdirs=$libdirl
    fi

    # Write a message
    checking_msg "$lib"

    libs=""
    for i in $lib ; do
        for ext in .a .lib "" .so .sl .dylib .dll.a ; do
            libs="$libs $i$ext"
        done
    done

    found_dir=""
    found_lib=""

    if test "x$machine_word_size" = "x64"; then
	for p in ${libdirs}; do
            libdir64=$(echo "$p" | grep lib | sed -e 's|lib$|lib64|g' -e 's|lib/|lib64/|g')
            libdirs="$libdirs $libdir64"
	done
    fi
    if test "x$machine_word_size" = "x32"; then
	for p in ${libdirs}; do
            libdir32=$(echo "$p" | grep lib | sed -e 's|lib$|lib32|g' -e 's|lib/|lib32/|g')
            libdirs="$libdirs $libdir32"
	done
    fi
    # look first in the DEB_HOST_MULTIARCH directories
    if test "x$debmultiarch" != "x" ; then
	for p in ${libdirs}; do
            multiarch_libdir=$(echo "$p" | sed "s|lib$|lib/$debmultiarch|")
            libdirs="$multiarch_libdir $libdirs"
	done
    fi

    for p in ${libdirs}; do
        for l in ${libs}; do
            liblist=$(echo $p/$l) # expands wildcard
            for n in ${liblist} ; do
                if test -f $n ; then
                    found_dir=$p
                    found_lib=$l
                    break 3
                fi
            done
        done
    done

    if test "x$found_dir" = "x" || test "x$found_lib" = "x" ; then
        result "not found in $libdirs"
        return 1
    else
        result "found in $found_dir"
    fi

    return 0
}

#_____________________________________________________________________
check_header() {
    # This function will try to locate a header file [$1] in the
    # directory given in $2 or in a default path [$*].
    #
    # The result of the search is stored in found_hdr and found_dir,
    # which should be immediately copied, since the variables value
    # will be overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -lt 2 ; then
        echo "check_header: Too few arguments"
        return 1
    fi

    # Save arguments in local names
    hdr=$1       ; shift
    hdrdirl=$1
    hdrdirs="$*"
    # check if we got a specific argument as to where the library
    # is to be found
    if test ! "x$hdrdirl" = "x" ; then
        hdrdirs=$hdrdirl
    fi

    # Write a message
    checking_msg "$hdr"

    hdrs=""
    for i in $hdr ; do
        for ext in "" .h .hpp ; do
            hdrs="$hdrs $i$ext"
        done
    done

    found_dir=""
    found_hdr=""

    for p in ${hdrdirs}; do
        for h in ${hdrs}; do
            hdrlist=$(echo $p/$h) # expands wildcard
            for n in ${hdrlist} ; do
                if test -f $n ; then
                    found_dir=$p
                    found_hdr=$hdr
                    break 3
                fi
            done
        done
    done

    if test "x$found_dir" = "x" || test "x$found_hdr" = "x" ; then
        result "not found in $hdrdirs"
        return 1
    else
        result "found in $found_dir"
    fi

    return 0
}

#_____________________________________________________________________
checking_msg() {
    # Write a simple "checking" message to std out.
    if test $# -lt 1 ; then
        echo "checking_msg: Too few arguments"
        return 1
    fi
    printf "Checking for"
    logmsg -n "Checking for"
    while test $# -gt 1 ; do
        printf " %s," "$1"
        logmsg -n " $1,"
        shift
        if test $# -eq 1 ; then
            printf " or"
            logmsg -n " or"
        fi
    done
    printf " %s ... " "$1"
    logmsg -n " $1 ... "
}

#_____________________________________________________________________
result() {
    echo "$*"
    logmsg ""
    logmsg "   Result: $*"
}

#_____________________________________________________________________
check_symbol() {
    # This function will try to locate a symbol [$1] in a specific
    # library [$2] and in a given directory [$3].
    # The result of the check is stored in found_symbol, 1 if true,
    # 0 otherwise, which should be immediately copied, since the variable
    # will be overwritten at next invocation of this function.

    local symbol
    local symbollib
    local symboldir

    # Assert that we got enough arguments
    if test $# -ne 3 ; then
        echo "check_symbol: not 3 arguments"
        found_symbol=0
        return 1
    fi

    # Save arguments in logical names
    symbol=$1     ; shift
    symbollib=$1  ; shift
    symboldir=$1

    if test "x$symbollib" = "x" ; then
        found_symbol=0
        return 1
    fi

    symbollib=$(echo $symbollib | sed -e 's/^-l/lib/')

    if test ! "x$symboldir" = "x" ; then
        symboldir=$(echo $symboldir | sed -e 's/^-L//')
    fi

    # Check if we got a specific argument as to where the library
    # is to be found
    symbolfile=$symbollib
    exts=".so .lib .dylib"
    if test ! "x$shared" = "xno" ; then
        exts="$exts .a"
    else
        exts=".a $exts"
    fi

    usrlib="/usr/lib"
    if test "x$machine_word_size" = "x32" ; then
        usrlib="/usr/lib32 $usrlib"
    fi
    if test "x$machine_word_size" = "x64" ; then
        usrlib="/usr/lib64 $usrlib"
    fi

    for d in "$symboldir" $usrlib ; do
        logmsg " Checking in $d"
        if test ! -r $d/$symbollib ; then
            logmsg "  $d/$symbollib not readable"
            for i in $exts ; do
                logmsg "   Checking extension $i with $d/$symbollib"
                if test -r $d/$symbollib$i ; then
                    logmsg "   $d/$symbollib$i readable"
                    symbolfile=$d/$symbollib$i
                    break 2
                fi
             done
        else
            logmsg "  $d/$symbollib readable"
            symbolfile=$d/$symbollib
            break
        fi
    done

    if test "x$symbolfile" = "x" || test ! -r $symbolfile ; then
       found_symbol=0
       logmsg " Symbol not found"
       return 1
    fi

    checking_msg "$symbol in $symbolfile"
    nm $symbolfile 2>&1 | grep $symbol > /dev/null 2>&1 ||
    nm -D $symbolfile 2>&1 | grep $symbol > /dev/null 2>&1
    if test $? -eq 0 ; then
        found_symbol=1
        logmsg -n "symbol found"
    else
        nm $symbolfile 2>&1 | grep "no symbols" > /dev/null 2>&1
        # if test $? -eq 0 ; then
        #     logmsg " $symbolfile is stripped, trying to link"
        #     # stripped library - only safe test is to link against the library
        #     check_link $symbolfile "" $symbol
        #     found_symbol=$link_result
        # else
            found_symbol=0
        # fi
    fi

    if test $found_symbol -eq 1 ; then
        result "ok"
	return 0
    else
        result "no"
	return 1
    fi
}

#_____________________________________________________________________
split_version() {
    local version="$1"
    local major_var="$2"
    local minor_var="$3"
    local patch_var="$4"

    set -- $(printf "%s" "$version" |
	     sed 's/^\([[:digit:].]*\).*$/\1/' | tr . ' ')
    eval "$major_var=\"${1:-0}\""
    eval "$minor_var=\"${2:-0}\""
    eval "$patch_var=\"${3:-0}\""
}

#_____________________________________________________________________
major_minor_patch_at_least() {
    local     major=$1
    local     minor=$2
    local     patch=$3
    local min_major=$4
    local min_minor=$5
    local min_patch=$6

    if   [ $major -gt $min_major ]; then return 0
    elif [ $major -lt $min_major ]; then return 1
    elif [ $minor -gt $min_minor ]; then return 0
    elif [ $minor -lt $min_minor ]; then return 1
    elif [ $patch -ge $min_patch ]; then return 0
    else				 return 1
    fi
}

#_____________________________________________________________________
version_at_least() {
    local version="$1"
    local min_version="$2"

    local major minor patch
    split_version "$version" major minor patch

    local m_major m_minor m_patch
    split_version "$min_version" m_major m_minor m_patch

    major_minor_patch_at_least $major $minor $patch $m_major $m_minor $m_patch
}

#_____________________________________________________________________
try_compile_cpp_program() {
    # This function compiles a C++ testprogram with the header
    # inclusion given in [$1] and a statement given in [$2].

    if test $# -ne 2 ; then
        echo "try_compile_cpp_program: Two arguments required!"
        exit 1
    fi

    local _header="$1"
    local _statement="$2"

    logmsg ""
    logmsg "==================================="
    logmsg "Trying to compile test program with"
    logmsg "   Header: ${_header}"
    logmsg "   Statement: ${_statement}"

    local _suppress_separator=true

    try_compile_run_cpp_program "${_header}
int main() {
   ${_statement};
   return 0;
}"
}

#_____________________________________________________________________
try_compile_run_cpp_program() {
    # This function compiles a C++ source code given in [$1]
    # using the compiler given in [$2] or $CXX if $2 is unset
    # with compiler flags given in [$3] or $CXXFLAGS if $3 is unset.
    # It subsequently executes the resulting executable whose
    # output through stdout and stderr is stored in cpp_output
    # and whose exit code is stored in cpp_exit.

    if [ $# -lt 1 -o $# -gt 3 ]; then
        echo "try_compile_run_cpp_program: 1, 2, or 3 arguments required!"
        exit 1
    fi

    local cxx="$2"
    if [ -z "$cxx" ]; then
	if test "x${CXX}" = "x"; then
            echo "try_compile_run_cpp_program: CXX is not set!"
            exit 1
	fi
	cxx="$CXX"
    fi
    local cxxflags="$3"
    [ -z "$cxxflags" ] && cxxflags="$CXXFLAGS"
    local source_code="$1"
    local _src="${BASEDIR}/conftest.cpp"
    local _exe="${BASEDIR}/conftest.x"
    local _log="${BASEDIR}/conftest.log"

    at_exit "rm -f \"${_exe}\" \"${_src}\" \"${_log}\""

    logmsg ""
    [ "$_suppress_separator" = true ] ||
    logmsg "==================================="
    logmsg "Trying to compile test program"

    printf "%s\n" "$source_code" > ${_src}

    # compile the source
    ${cxx} -o ${_exe} ${cxxflags} ${_src} > ${_log} 2>&1 || {
        logmsg "   Status: compilation failed!"
        logmsg ""
        logmsg "The test program was:"
        logmsg "---------------------"
	printf "%s\n" "$source_code" >> $logfile
        logmsg "---------------------"
        logmsg "Compiler: ${cxx}"
        logmsg "Compiler flags: ${cxxflags}"
        logmsg "Compilation command:"
        echo "   ${cxx} -o ${_exe} ${cxxflags} ${_src} > ${_log} 2>&1" >> $logfile
        logmsg "Compiler error message:"
        cat ${_log} >> $logfile
	logmsg "==================================="
	return 1
    }

    logmsg "   Status: compilation successful."

    # run the executable
    logmsg "Running executable: $_exe"
    cpp_output=$(${_exe} 2>&1)
    cpp_exit="$?"
    logmsg "The executable returned exit code: $cpp_exit"
    if [ -z "$cpp_output" ]; then
	logmsg "The executable produced no output."
    else
	logmsg "The executable produced output:"
	printf "%s\n" "${cpp_output}" >> $logfile
    fi

    logmsg "==================================="

    return 0
}

#_____________________________________________________________________
use_solver() {
    # This function tests if a certain solver [$1] is used.

    # Assert that we got enough arguments
    if test $# -ne 1 ; then
        echo "use_solver: Exactly one argument required"
        return 1
    fi

    # check if the argument is in the list of used solvers
    contains "$SOLVERS" "$1"
}

#_____________________________________________________________________
exists_in_path () {
    # This function will try to locate an executable [$1] in $PATH.
    #
    # The result of the search is stored in cmd, which should be
    # immediately copied, since the variables value will be
    # overwritten at next invocation of this function.

    # Assert that we got enough arguments
    if test $# -ne 1 ; then
        echo "exists_in_path: Exactly one argument required"
        return 1
    fi

    cmd=$(command -v -- "$1")
    case "$cmd" in
	/*) return 0 ;;
	alias\ *) return 1 ;; # alias
	*) return 1 ;; # built-in or function
    esac
}

#_____________________________________________________________________
is_empty_dir() {
    if test $# -ne 1 ; then
        echo "is_empty_dir: Exactly one argument required"
        return 1
    fi

    find "$1" -maxdepth 0 -empty | read v
}

#_____________________________________________________________________
check_install() {
    if test -z "${INSTALL_DIR}"; then
        return 0
    fi

    checking_msg "availability of install"

    if exists_in_path "install"; then
        result "ok"
    else
        result "no ok"
        message "Error: The installation program \`install' needs to be installed."
        message "   \`install' is part of the GNU coreutils and can be downloaded from"
        message "   https://www.gnu.org/software/coreutils/"
        exit 1
    fi
}

#_____________________________________________________________________
check_install_dir() {
    if test -z "${INSTALL_DIR}"; then
        return 0
    fi

    checking_msg "source code installation directory"

    # check if $INSTALL_DIR exists
    if test -d "${INSTALL_DIR}"; then
        # check if $INSTALL_DIR is empty
        if is_empty_dir "${INSTALL_DIR}"; then
            result "ok"
        else
            result "ok"
            message "Warning: Source code installation directory is non-empty."
            message "   Existing files might be overwritten!"
        fi
    else
        result "ok"
        logmsg "Source code installation directory does not exist."
    fi

    # escape spaces
    INSTALL_DIR=$(echo "${INSTALL_DIR}" | sed 's/ /\\\\ /g')

    logmsg "Source code installation directory: ${INSTALL_DIR}"
}

#_____________________________________________________________________
check_solvers() {
    if test -z "${SOLVERS}"; then
        logmsg "No RGE solvers specified"
        return 0
    fi

    checking_msg "RGE solvers"
    local algs="$(echo $SOLVERS | tr ',' ' ')"
    SOLVERS=""
    for a in ${algs}; do
        case "$a" in
            all)
                SOLVERS="$available_solvers"; break ;;
            two_scale|lattice|semi_analytic)
                SOLVERS="$SOLVERS $a"
                continue ;;
            *)
                message "Error: unknown solver: $a";
                message "Available solvers: $available_solvers";
                exit 1 ;;
        esac
    done

    # strip whitespace
    SOLVERS="$(echo ${SOLVERS} | sed -e 's/^ *//' -e 's/ *$//')"

    result "ok (${SOLVERS})"
    logmsg "   Solvers: ${SOLVERS}"
}

#_____________________________________________________________________
check_models() {
    if test -z "${MODELS}" -o ! -d "$BASEDIR"/models ; then
        logmsg "No models specified"
        MODELS=""
        return 0
    fi

    checking_msg "models"
    local models="$(echo $MODELS | tr ',' ' ')"
    MODELS=""
    for a in ${models}; do
        case "$a" in
            all)
                MODELS=$(find "$BASEDIR"/models/* -maxdepth 0 -type d -print0 | tr '\0' ' ' | sed -e 's|^\./||' -e 's| \./| |g' -e 's| *$||g')
                break ;;
            *)
                if test -d "$BASEDIR/models/$a"; then
                    if contains_not "$MODELS" "models/$a"; then
                        MODELS="$MODELS models/$a"
                    fi
                    continue
                else
                    result "not ok"
                    message "Error: model directory \"$BASEDIR/models/$a\" does not exist!"
                    message "   Please create the directory and put a model file in it."
                    message "   You can use \`./createmodel --name=<model>' to create one."
                    exit 1
                fi ;;
        esac
    done

    # test model dependencies (SoftsusyNMSSM depends on SoftsusyMSSM)
    if contains "${MODELS}" "models/SoftsusyNMSSM"; then
        if contains_not "${MODELS}" "models/SoftsusyMSSM"; then
            result "not ok"
            message "Error: model SoftsusyNMSSM requires model SoftsusyMSSM !"
            message "   Please select the model SoftsusyMSSM as well:"
            message "   --with-models=SoftsusyMSSM,SoftsusyNMSSM"
            exit 1
        fi
    fi

    # check for Makefile module, start script and FlexibleSUSY model
    # file
    for m in ${MODELS}; do
        if ! test -r ${m}/module.mk; then
            result "not ok"
            message "Error: No Makefile module found in ${m}"
            message "   Please create ${m}/module.mk !"
            exit 1
        fi
        if ! test -r ${m}/start.m; then
            logmsg ""
            logmsg "Note: No start script found in ${m}"
        fi
        if ! test -r ${m}/FlexibleSUSY.m; then
            logmsg ""
            logmsg "Note: No FlexibleSUSY model file found in ${m}"
        fi
    done

    local model_names="$(echo ${MODELS} | sed -e 's|models/||g' -e 's/^ *//' -e 's/ *$//')"

    result "ok (${model_names})"
    logmsg "   Models: ${MODELS}"
}

#_____________________________________________________________________
check_addons() {
    if test -z "${ADDONS}"; then
        logmsg "No addons specified"
        return 0
    fi

    checking_msg "addons"
    local addons="$(echo $ADDONS | tr ',' ' ')"
    ADDONS=""
    for a in ${addons}; do
        case "$a" in
            all)
                ADDONS=$(find "$BASEDIR"/addons/* -maxdepth 0 -type d -print0 | tr '\0' ' ' | sed -e 's|^\./||' -e 's| \./| |g' -e 's| *$||g')
                break ;;
            *)
                if test -d "$BASEDIR/addons/$a" ; then
                    ADDONS="$ADDONS addons/$a"
                    continue
                else
                    result "not ok"
                    message "Error: addon directory \"$BASEDIR/addons/$a\" does not exist!"
                    message "Please create the directory and put an addon in it."
                    exit 1
                fi ;;
        esac
    done

    # check for Makefile module
    for m in ${ADDONS}; do
        if ! test -r ${m}/module.mk; then
            result "not ok"
            message "Error: No Makefile module found in ${m}"
            message "   Please create ${m}/module.mk !"
            exit 1
        fi
    done

    local addon_names="$(echo ${ADDONS} | sed -e 's|addons/||g' -e 's/^ *//' -e 's/ *$//')"

    result "ok (${addon_names})"
    logmsg "   Addons: ${ADDONS}"
}

#_____________________________________________________________________
check_librarylink() {
    if [ "x$enable_librarylink" = "xautomatic" ] ; then
        checking_msg "LibraryLink"
        # building LibraryLink needs Mathematica headers
        if [ -n "$MATH" ] ; then
            result "yes"
            enable_librarylink=yes
        else
            result "no"
            enable_librarylink=no
        fi
    fi
}

#_____________________________________________________________________
check_platform() {
    # checks which platform we have

    logmsg ""
    logmsg "# Platform information"
    logmsg ""
    logmsg "hostname = $( (hostname || uname -n) 2>/dev/null | sed 1q)"
    logmsg "uname -m = $( (uname -m) 2>/dev/null || echo unknown)"
    logmsg "uname -r = $( (uname -r) 2>/dev/null || echo unknown)"
    logmsg "uname -s = $( (uname -s) 2>/dev/null || echo unknown)"
    logmsg "uname -v = $( (uname -v) 2>/dev/null || echo unknown)"
    logmsg "Machine word size: ${machine_word_size}"
    logmsg ""

    for p in $(echo "$PATH" | tr ':' ' '); do
        logmsg "PATH: ${p}"
    done
    logmsg ""

    for p in ${ld_library_path}; do
        logmsg "LD_LIBRARY_PATH: ${p}"
    done
    logmsg ""

    operating_system=$( (uname -s) 2>/dev/null || echo unknown)
    kernel_version=$( (uname -r) 2>/dev/null || echo unknown)
}

#_____________________________________________________________________
check_multiarch() {
    local linuxdist=""
    debmultiarch=""

    exists_in_path "lsb_release"
    if [ -n "$cmd" ] ; then
        if lsb_release -d | grep -i 'debian\|deepin\|linux lite\|mint\|elementary\|ubuntu\|zorin' > /dev/null 2>&1; then
            linuxdist="multiarch"
        fi
    fi

    if test "x$linuxdist" = "xmultiarch"; then
        if type dpkg-architecture > /dev/null 2>&1 ; then
            if $(dpkg-architecture -qDEB_HOST_MULTIARCH > /dev/null 2>&1) ; then
                checking_msg "dpkg-architecture"
                debmultiarch=$(dpkg-architecture -qDEB_HOST_MULTIARCH 2> /dev/null)
                result "$debmultiarch"
            fi
        else
            result "$(basename $0): dpkg-architecture or dpkg-dev MUST be installed"
            exit 1
        fi
    fi
}

#_____________________________________________________________________
check_boost() {
    check_header "boost/version.hpp" "$boost_inc_dir" \
	"$default_inc_paths"
    if test "x$found_hdr" = "x" ; then
        message "Error: could not find boost/version.hpp in ${boost_inc_dir} ${default_inc_paths}"
        message "   Boost ${required_boost_version} or higher must be installed,"
        message "   see http://www.boost.org"
        exit 1
    else
        if contains_not "${BOOSTFLAGS}" "-I$found_dir"; then
            BOOSTFLAGS="${BOOSTFLAGS} -I$found_dir"
        fi
    fi
}

#_____________________________________________________________________
check_boost_version() {
    checking_msg "boost version >= $required_boost_version"

    try_compile_run_cpp_program "#include <iostream>
#include <boost/version.hpp>
int main() {
   int boost_major = BOOST_VERSION / 100000;
   int boost_minor = BOOST_VERSION / 100 % 1000;
   int boost_patch = BOOST_VERSION % 100;
   std::cout << boost_major << '.' << boost_minor << '.' << boost_patch << '\n';
   return 0;
}" "$CXX" "${BOOSTFLAGS}" && [ $cpp_exit = 0 ] || {
        result "unknown"
        message "Warning: could not determine boost version because"
        message "   compilation or execution of the boost test program failed."
	return 1
    }

    local boost_version="$cpp_output"

    version_at_least "$boost_version" "$required_boost_version" || {
        result "not ok (version ${boost_version})"
        message "Error: the installed boost version is too old."
        message "   Please install version ${required_boost_version} or higher."
        message "   You can use --with-boost-incdir= and --with-boost-libdir="
        message "   to use a boost installation from a non-default location."
        exit 1
    }
    result "ok (version ${boost_version})"
    logmsg "   Required boost version: ${required_boost_version}"
    logmsg "   Boost version found: ${boost_version}"
}

#_____________________________________________________________________
check_boost_test_libs() {
    check_library \
	"libboost_unit_test_framework libboost_unit_test_framework-mt" \
	"$boost_lib_dir" "$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        message "Warning: libboost_unit_test_framework(-mt) must be installed"
        message "  to compile and run the tests, see http://www.boost.org"
    else
        local BOOSTTESTLIBS_=-l$(
	    echo "$found_lib" | sed 's/^lib\(.*\)\..*$/\1/')
        if [ -z "$boost_lib_dir" ]; then
            # assume that the linker will look in the default paths
            BOOSTTESTLIBS="$BOOSTTESTLIBS_"
        else
            BOOSTTESTLIBS="-L$boost_lib_dir $BOOSTTESTLIBS_"
        fi
    fi
}

#_____________________________________________________________________
check_boost_test_incl() {
    check_header "boost/test/unit_test.hpp" "$boost_inc_dir" \
	"$default_inc_paths"
    if test "x$found_hdr" = "x" ; then
        message "Warning: boost/test/unit_test.hpp must be installed"
        message "  to compile and run the tests, see http://www.boost.org"
    fi
}

#_____________________________________________________________________
check_boost_thread_libs() {
    check_library "libboost_thread libboost_thread-mt" \
	"$boost_lib_dir" "$default_lib_paths"
    if [ -z "$found_lib" ]; then
        message "Error: libboost_thread or libboost_thread-mt must be installed"
        message "  to enable multithreading in the lattice method, see http://www.boost.org"
        message "  You can disable the lattice method with the --with-solvers= flag."
        exit 1
    fi
    local BOOSTTHREADLIBS_=-l$(echo "$found_lib" | sed 's/^lib\(.*\)\..*$/\1/')

    check_library "libboost_system libboost_system-mt" \
	"$boost_lib_dir" "$default_lib_paths"
    if [ -z "$found_lib" ]; then
        message "Error: libboost_system or libboost_system-mt must be installed"
        message "  to enable multithreading in the lattice method, see http://www.boost.org"
        message "  You can disable the lattice method with the --with-solvers= flag."
        exit 1
    fi
    BOOSTTHREADLIBS_="$BOOSTTHREADLIBS_ "-l$(
	echo "$found_lib" | sed 's/^lib\(.*\)\..*$/\1/')

    if [ -z "$boost_lib_dir" ]; then
        # assume that the linker will look in the default paths
        BOOSTTHREADLIBS="$BOOSTTHREADLIBS_"
    else
        BOOSTTHREADLIBS="-L$boost_lib_dir $BOOSTTHREADLIBS_"
    fi
}

#_____________________________________________________________________
check_boost_thread_incl() {
    check_header "boost/thread/thread.hpp" "$boost_inc_dir" \
	"$default_inc_paths"
    if test "x$found_hdr" = "x" ; then
        message "Error: boost/thread/thread.hpp must be installed"
        message "  to enable multithreading in the lattice method, see http://www.boost.org"
        message "  You can disable the lattice method with the --with-solvers= flag."
        exit 1
    else
        if contains_not "${BOOSTFLAGS}" "-I$found_dir"; then
            BOOSTFLAGS="${BOOSTFLAGS} -I$found_dir"
        fi
    fi
}

#_____________________________________________________________________
check_std_threads() {
    # check for C++ std::thread and std::mutex
    if test "x${enable_threads}" = "xyes" -o  "x${enable_threads}" = "xautomatic" ; then
        checking_msg "std::thread"
        if try_compile_cpp_program "#include <thread>
#include <mutex>" "std::mutex mtx; std::thread thr;";
        then
            enable_threads="yes"
            result "ok"
        else
            result "not available"
            message "Error: C++ std::thread and std::mutex is not available."
            message "   Either reconfigure with \`--disable-threads' or use a"
            message "   C++ compiler which supports C++ std::thread and std::mutex."
            enable_threads="no"
            exit 1
        fi
    fi
}

#_____________________________________________________________________
check_thread_libs() {
    # link libpthread only if $enable_threads = yes
    # I'm assuming here, that no other library we link needs libpthread.
    if [ "x$enable_threads" = "xyes" -o -n "$pthread_lib_dir" ] ; then
        check_library "libpthread" "$pthread_lib_dir" "$default_lib_paths"
        if [ -z "$found_lib" ]; then
            message "Error: libpthread must be installed to enable multithreading!"
            exit 1
        fi
        THREADLIBS=-l$(echo "$found_lib" | sed 's/^lib\(.*\)\..*$/\1/')
        # need to link whole libpthread.a for static linking
        if [ "x$enable_static" = xyes ] ; then
            THREADLIBS="-Wl,--push-state,-z,muldefs,--whole-archive ${THREADLIBS} -Wl,--pop-state"
        fi
        if [ -n "$pthread_lib_dir" ]; then
            THREADLIBS="-L$pthread_lib_dir $THREADLIBS"
        fi
    fi
}

#_____________________________________________________________________
check_cxx_compiler_type() {
    checking_msg "type of C++ compiler ${CXX}"

    get_cxx_compiler_type "$CXX" cxx_compiler_type || return 1

    case "$cxx_compiler_type" in
    gnu)   result "GNU"
	   required_cxx_compiler_version="$required_gpp_compiler_version"
	   std_cxx11_compiler_version="$std_cxx11_gpp_version" ;;
    clang) result "Clang"
	   required_cxx_compiler_version="$required_clang_compiler_version"
	   std_cxx11_compiler_version="$std_cxx11_clang_version" ;;
    intel) result "Intel"
	   required_cxx_compiler_version="$required_icpc_compiler_version"
	   std_cxx11_compiler_version="$std_cxx11_icpc_version" ;;
    *)     result "unknown" ;;
    esac

    logmsg "C++ compiler type: ${cxx_compiler_type}"
}

#_____________________________________________________________________
check_cxx_compiler_version() {
    checking_msg "$CXX compiler version >= $required_cxx_compiler_version"

    case "$cxx_compiler_type" in
    gnu)   get_gpp_version   "$CXX" cxx_compiler_version || return 1 ;;
    clang) get_clang_version "$CXX" cxx_compiler_version || return 1 ;;
    intel) get_icpc_version  "$CXX" cxx_compiler_version || return 1 ;;
    *)     message "Warning: could not check C++ compiler version because"
           message "   its type is unknown."
	   return 1 ;;
    esac

    version_at_least \
	"$cxx_compiler_version" "$required_cxx_compiler_version" || {
        result "not ok (version $cxx_compiler_version)"
        message "Error: the installed $CXX version is too old."
        message "   Please install version $required_cxx_compiler_version or higher."
        exit 1
    }
    result "ok (version $cxx_compiler_version)"
    logmsg "   Required $CXX version: $required_cxx_compiler_version"
    logmsg "   $CXX version found: $cxx_compiler_version"
}

#_____________________________________________________________________
check_icpc_features() {
    local compiler="$1"
    local version="$2"

    checking_msg "$compiler compiler features"

    local major minor patch
    split_version "$version" major minor patch

    # disable multi-threading for versions < 14.0.0
    if ! major_minor_patch_at_least $major $minor $patch "14" "0" "0" &&
       [ "$enable_threads" = "yes" -o "$enable_threads" = "automatic" ]; then
	message ""
	message "   Warning: multi-threading support requires $compiler 14.0.0 or newer."
	enable_threads="no"
    else
	result "ok"
    fi
}

#_____________________________________________________________________
get_cxx_compiler_type() {
    if test $# -ne 2; then
        message "get_cxx_compiler_type(): too few arguments"
        exit 1
    fi

    local compiler="$1"
    local ret_var="$2"

    local output
    output=$($compiler -dM -E -x c++ /dev/null) || {
        message "Warning: could not determine compiler type of $compiler because"
        message "   execution of $compiler failed."
	return 1
    }

    local compiler_type
    if   printf "%s" "$output" |
         grep '#define[[:space:]]*\(__llvm__\|__clang__\)' > /dev/null; then
	compiler_type=clang
    elif printf "%s" "$output" |
	 grep '#define[[:space:]]*__INTEL_COMPILER' > /dev/null; then
	compiler_type=intel
    elif printf "%s" "$output" |
	 grep '#define[[:space:]]*__GNUC__' > /dev/null; then
	compiler_type=gnu
    else
	compiler_type=unknown
    fi

    eval "$ret_var=\"$compiler_type\""
}

#_____________________________________________________________________
get_gpp_version() {
    if test $# -ne 2; then
        message "get_gpp_version(): too few arguments"
        exit 1
    fi

    local compiler="$1"
    local ret_var="$2"

    local output
    output=$($compiler -dM -E -x c++ /dev/null) || {
        message "Warning: could not determine $compiler version because"
        message "   execution of $compiler failed."
	return 1
    }
    local major=$(printf "%s" "$output" |
	sed 's/^.*__GNUC__[[:space:]]*\([[:digit:]]*\).*$/\1/p;d')
    local minor=$(printf "%s" "$output" |
	sed 's/^.*__GNUC_MINOR__[[:space:]]*\([[:digit:]]*\).*$/\1/p;d')
    local patch=$(printf "%s" "$output" |
	sed 's/^.*__GNUC_PATCHLEVEL__[[:space:]]*\([[:digit:]]*\).*$/\1/p;d')

    eval "$ret_var=\"$major.$minor.$patch\""
}

#_____________________________________________________________________
get_icpc_version() {
    if test $# -ne 2; then
        message "get_icpc_version(): too few arguments"
        exit 1
    fi

    local compiler="$1"
    local ret_var="$2"

    local output
    output=$($compiler -dM -E -x c++ /dev/null) || {
        message "Warning: could not determine $compiler version because"
        message "   execution of $compiler failed."
	return 1
    }
    local version=$(printf "%s" "$output" |
	sed 's/^.*__INTEL_COMPILER[[:space:]]*\([[:digit:]]*\)\([[:digit:]]\)\([[:digit:]]\).*$/\1.\2.\3/p;d')

    eval "$ret_var=\"$version\""
}

#_____________________________________________________________________
check_cxx_compiler_features() {
    case "$cxx_compiler_type" in
    intel) check_icpc_features "$CXX" "$cxx_compiler_version" ;;
    esac
}

#_____________________________________________________________________
get_clang_version() {
    if test $# -ne 2; then
        message "get_clang_version(): too few arguments"
        exit 1
    fi

    local compiler="$1"
    local ret_var="$2"

    local output
    output=$($compiler -dM -E -x c++ /dev/null) || {
        message "Warning: could not determine $compiler version because"
        message "   execution of $compiler failed."
	return 1
    }
    local major=$(printf "%s" "$output" |
	sed 's/^.*__clang_major__[[:space:]]*\([[:digit:]]*\).*$/\1/p;d')
    local minor=$(printf "%s" "$output" |
	sed 's/^.*__clang_minor__[[:space:]]*\([[:digit:]]*\).*$/\1/p;d')
    local patch=$(printf "%s" "$output" |
	sed 's/^.*__clang_patchlevel__[[:space:]]*\([[:digit:]]*\).*$/\1/p;d')

    eval "$ret_var=\"$major.$minor.$patch\""
}

#_____________________________________________________________________
check_cc() {
    checking_msg "C compiler $CC"
    exists_in_path "$CC"
    if [ -z "$cmd" ] ; then
        result "not found"
        message "Error: A C compiler must be installed to compile FlexibleSUSY!"
        message "   Use --with-cc= to specify the C compiler to be used."
        exit 1
    else
        result "found $cmd"
    fi
}

#_____________________________________________________________________
check_cxx() {
    checking_msg "C++ compiler $CXX"
    exists_in_path "$CXX"
    if [ -z "$cmd" ] ; then
        result "not found"
        message "Error: A C++ compiler must be installed to compile the models!"
        message "   Use --with-cxx= to specify the C++ compiler to be used."
        exit 1
    else
        result "found $cmd"
    fi
}

#_____________________________________________________________________
check_cxxflags() {
    case "$CXXFLAGS" in
    *-std=c++11*)
	version_at_least "$cxx_compiler_version" \
			 "$std_cxx11_compiler_version" || {
	    message "Replacing \`-std=c++11' by \`-std=c++0x' since $CXX is older than $std_cxx11_compiler_version"
	    CXXFLAGS=$(
		printf "%s" "$CXXFLAGS" | sed 's/-std=c++11/-std=c++0x/')
	}
    esac

    if test "x$enable_compiler_warnings" = "xyes" ; then
        if test "x${cxx_compiler_type}" = "xgnu"; then
            CXXFLAGS="${CXXFLAGS} -Wall -pedantic -Wextra\
 -Wcast-align -Woverloaded-virtual -Wnon-virtual-dtor\
 -Wno-unused-local-typedefs"
        elif test "x${cxx_compiler_type}" = "xintel"; then
            CXXFLAGS="${CXXFLAGS} -w3 -Wnon-virtual-dtor"
        fi
    fi

    if [ "x$enable_shared_libs" = "xyes" -o "x$enable_librarylink" = "xyes" ] ; then
        # check if -fPIC is in CXXFLAGS
        case "${CXX}" in
            g++*|clang++*|icpc*)
                if contains_not "${CXXFLAGS}" "-fPIC" ; then
                    message "   Warning: could not find -fPIC in CXXFLAGS, appending it"
                    CXXFLAGS="${CXXFLAGS} -fPIC"
                fi ;;
        esac
    fi

    case "$operating_system" in
    CYGWIN_NT*)
	! printf "%s" "${CXXFLAGS}" |
	grep -e '-U[[:space:]]*__STRICT_ANSI__' > /dev/null 2>&1 && {
            message "Appending -U__STRICT_ANSI__ to CXXFLAGS to enable math macros"
	    message "   possibly disabled on Cygwin."
            CXXFLAGS="${CXXFLAGS} -U__STRICT_ANSI__"
	} ;;
    esac
}

#_____________________________________________________________________
check_eigen_incl() {
    eigen_inc_paths="$default_inc_paths /usr/include/eigen3 \
                     /usr/local/include/eigen3"
    check_header "Eigen/Core" "$eigen_inc_dir" "$eigen_inc_paths"
    if test "x$found_hdr" = "x" ; then
        message "Error: Eigen 3 must be installed, see http://eigen.tuxfamily.org"
        message "   You can use --with-eigen-incdir= to use an eigen installation"
        message "   from a non-default location."
        exit 1
    else
        EIGENFLAGS="-I$found_dir"
    fi
}

#_____________________________________________________________________
check_eigen_version() {
    checking_msg "eigen version"

    try_compile_run_cpp_program "#include <iostream>
#include <Eigen/Core>
int main() {
   std::cout << EIGEN_WORLD_VERSION << '.' << EIGEN_MAJOR_VERSION << '.' << EIGEN_MINOR_VERSION << '\n';
   return 0;
}" "$CXX" "${EIGENFLAGS}" && [ $cpp_exit = 0 ] || {
        result "unknown"
        message "Warning: could not determine eigen version because"
        message "   compilation or execution of the eigen test program failed."
	return 1
    }

    local eigen_version="$cpp_output"

    result "ok (version ${eigen_version})"
    logmsg "   Eigen version found: ${eigen_version}"
}

#_____________________________________________________________________
check_gsl_config() {
    checking_msg "GSL configuration $gsl_config"
    exists_in_path "$gsl_config"
    if [ -z "$cmd" ] ; then
        result "not found"
        message "Error: Gnu Scientific Library (GSL) needs to be installed!"
        message "  Either add the path to the \`gsl-config' program to \$PATH or"
        message "  use $0 --with-gsl-config=<path to gsl-config>"
        exit 1
    else
        result "found $cmd"
        GSLFLAGS=$($cmd --cflags)
        GSLLIBS=$($cmd --libs)
    fi
}

#_____________________________________________________________________
check_fc() {
    checking_msg "Fortran compiler $FC"
    exists_in_path "$FC"
    if [ -z "$cmd" ] ; then
        result "not found"
        message "Error: A Fortran compiler must be installed to compile the"
        message "   two-loop MSSM Higgs contributions!"
        message "   Use --with-fc= to specify the Fortran compiler to be used."
        exit 1
    else
        result "found $cmd"
    fi
}

#_____________________________________________________________________
check_fflags() {
    case "${FC}" in
        gfortran*)
            if contains_not "${FFLAGS}" "-frecursive" ; then
                logmsg "Note: Adding -frecursive to FFLAGS for thread safety."
                FFLAGS="${FFLAGS} -frecursive"
            fi
            ;;
        ifort*)
            if contains_not "${FFLAGS}" "-recursive" ; then
                logmsg "Note: Adding -recursive to FFLAGS for thread safety."
                FFLAGS="${FFLAGS} -recursive"
            fi
            ;;
    esac

    # check if -fPIC is in FFLAGS
    if [ "x$enable_shared_libs" = "xyes" -o "x$enable_librarylink" = "xyes" ] ; then
        case "${FC}" in
            gfortran*|ifort*)
                if contains_not "${FFLAGS}" "-fPIC" ; then
                    message "   Warning: could not find -fPIC in FFLAGS, appending it"
                    FFLAGS="${FFLAGS} -fPIC"
                fi ;;
        esac
    fi
}

#_____________________________________________________________________
check_fortran_libs() {
    if test "x${FLIBS}" != "x" ; then
        return
    fi

    case "$FC" in
        gfortran*)
            gfortran_lib_search_paths=$(${FC} -print-search-dirs | sed -n -e '/libraries:/s/libraries: *=//p' | tr ':' ' ')
            check_library "libgfortran" "$gfortran_lib_search_paths" "$default_lib_paths"
            if test "x$found_lib" = "x" ; then
                message "Error: libgfortran not found in $gfortran_lib_search_paths $default_lib_paths"
                exit 1
            else
                FLIBS="-L$found_dir -lgfortran -lm"
            fi ;;
        g77|f77)
            FLIBS="-lg2c -lm" ;;
        ifort)
            FLIBS="-lifcore -limf -ldl -lintlc -lsvml" ;;
    esac
}

#_____________________________________________________________________
check_linking() {
    if [ "x$enable_static" = xyes ] ; then
        # static linking requires static libraries
        [ "x$enable_shared_libs" = xyes ] && \
            message "Note: Static libraries will be created, because they are needed for static linking (--enable-static)."
        enable_shared_libs=no
        LDFLAGS="$STATIC_LDFLAGS"
        LDLIBS="$STATIC_LDLIBS"
    else
        LDFLAGS="$SHARED_LDFLAGS"
        LDLIBS="$SHARED_LDLIBS"
    fi

    if [ "x$enable_shared_libs" = xyes ] ; then
        MODULE_LIBEXT="$SHARED_LIB_EXT"
        MODULE_MAKE_LIB_CMD="$SHARED_LIB_CMD"
    else
        MODULE_LIBEXT="$STATIC_LIB_EXT"
        MODULE_MAKE_LIB_CMD="$STATIC_LIB_CMD"
    fi

    # LibraryLink lib must always be shared
    LIBLNK_LIBEXT="$SHARED_LIB_EXT"
    LIBLNK_MAKE_LIB_CMD="$SHARED_LIB_CMD"
}

#_____________________________________________________________________
check_blas_libs_using_options() {
    check_library "libblas" "$blas_lib_dir" \
	"$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        message "Warning: could not find libblas, proceeding without it."
        message "  It can be downloaded from http://www.netlib.org/blas"
	enable_lapack="no"
    else
        local BLASLIBS_=-lblas
        if [ -z "$blas_lib_dir" ]; then
            # assume that the linker will look in the default paths
            BLASLIBS="$BLASLIBS_"
        else
            BLASLIBS="-L$blas_lib_dir $BLASLIBS_"
        fi
	check_symbol ztpsv_ "$found_lib" "$found_dir"
    fi
}

#_____________________________________________________________________
# Mathematica 9.0 or newer is shipped with Intel MKL with the ILP64
# interface whereas LP64 is the standard 64 bit programming model
# which external LAPACK/BLAS would also follow:
# http://www.unix.org/version2/whatsnew/lp64_wp.html.  When
# Mathematica loads a LibraryLink library, calls to LAPACK/BLAS
# subroutines are bound to the MKL ILP64.  This means that an FS
# object cannot call an external LAPACK/BLAS subroutine if LibraryLink
# is enabled.  In this case, FS attempts to circumvent the conflict by
# calling the LAPACK subroutines from the MKL installed with
# Mathematica.  This workaround is however possible only when FS
# executables are dynamically linked since Mathematica does not come
# with a static MKL.
check_ilp64mkl_in_math() {
    [ "$enable_librarylink" = "no" ] && return 0
    [ "$enable_lapack" = "no" ] && return 0

    local math_lib_dir="$MATH_INSTDIR/SystemFiles/Libraries/$MATH_SYSTEMID"

    check_library "libmkl_intel_ilp64" "$math_lib_dir" "$default_lib_paths"
    [ -z "$found_lib" ] && return 0

    enable_ilp64mkl_workaround="yes"

    if [ "$enable_static" = "yes" ]; then
	if [ "$enable_lapack" = "yes" ]; then
	    message "Error: --enable-{static,lapack,librarylink} together conflict with the Intel MKL ILP64 linked to this version of Mathematica"
	    exit 1
	else
	    enable_lapack="no"
	fi
    else
	LAPACKLIBS="-L$math_lib_dir -Wl,-rpath,$math_lib_dir -lmkl_intel_ilp64 -lmkl_intel_thread -lmkl_core -liomp5"
	check_symbol ztpsv_ "$found_lib" "$found_dir"
	check_symbol dgbsv_ "$found_lib" "$found_dir"
    fi
}

#_____________________________________________________________________
check_lapack_libs_using_options() {
    check_library "liblapack" "$lapack_lib_dir" \
	"$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        message "Warning: could not find liblapack, proceeding without it."
        message "  It can be downloaded from http://www.netlib.org/lapack"
	enable_lapack="no"
    else
        local LAPACKLIBS_=-llapack
        if [ -z "$lapack_lib_dir" ]; then
            # assume that the linker will look in the default paths
            LAPACKLIBS="$LAPACKLIBS_"
        else
            LAPACKLIBS="-L$lapack_lib_dir $LAPACKLIBS_"
        fi
	check_symbol dgbsv_ "$found_lib" "$found_dir"
    fi
}

#_____________________________________________________________________
check_looptools_libs() {
    check_library "libooptools" "$looptools_lib_dir" \
	"$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        message "Error: libooptools must be installed if you want"
        message "   to use LoopTools, see http://www.feynarts.de/looptools/"
        message "   You can use the --with-looptools-libdir= option to specify the"
        message "   location of the libooptools library."
        exit 1
    else
        local LOOPTOOLSLIBS_="-looptools"
        if [ -z "$looptools_lib_dir" ]; then
            # assume that the linker will look in the default paths
            LOOPTOOLSLIBS="$LOOPTOOLSLIBS_"
        else
            LOOPTOOLSLIBS="-L$looptools_lib_dir $LOOPTOOLSLIBS_"
        fi
    fi
}

#_____________________________________________________________________
check_looptools_incl() {
    check_header "clooptools.h" "$looptools_inc_dir" \
	"$default_inc_paths"
    if test "x$found_hdr" = "x" ; then
        message "Error: clooptools.h must be installed if you want"
        message "   to use LoopTools, see http://www.feynarts.de/looptools/"
        message "   You can use the --with-looptools-incdir= option to specify the"
        message "   location of the clooptools.h header."
        exit 1
    else
        # assume that the compiler will look in the default paths
        if [ -n "$looptools_inc_dir" ]; then
            LOOPTOOLSFLAGS="-I$looptools_inc_dir"
        fi
    fi
}

#_____________________________________________________________________
check_loop_functions() {
    if test "$enable_fflite" = "yes" -a "$enable_looptools" = "yes"; then
	message "Error: do not \`--enable-fflite' and \`--enable-looptools' at the same time"
	exit 1
    fi

    if test "$enable_looptools" = "yes" ; then
        LOOPFUNCFLAGS="$LOOPTOOLSFLAGS"
        LOOPFUNCLIBS="$LOOPTOOLSLIBS"
    fi

    if test "$enable_fflite" = "yes" ; then
        LOOPFUNCFLAGS=""
        LOOPFUNCLIBS="fflite/libfflite${MODULE_LIBEXT}"
    fi
}

#_____________________________________________________________________
check_sqlite_libs() {
    check_library "libsqlite3" "$sqlite_lib_dir" \
       "$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        message "Warning: libsqlite3 not found."
        message "   Support for SQLite will be is disabled."
        return 1
    else
        local SQLITELIBS_="-lsqlite3"
        if [ -z "$sqlite_lib_dir" ]; then
            # assume that the linker will look in the default paths
            SQLITELIBS="$SQLITELIBS_"
        else
            SQLITELIBS="-L$sqlite_lib_dir $SQLITELIBS_"
        fi
    fi
    return 0
}

#_____________________________________________________________________
check_sqlite_incl() {
    check_header "sqlite3.h" "$sqlite_inc_dir" \
	"$default_inc_paths"
    if test "x$found_hdr" = "x" ; then
        message "Warning: sqlite.h not found in $sqlite_inc_dir $default_inc_paths."
        message "   Support for SQLite will be is disabled."
        return 1
    else
        # assume that the compiler will look in the default paths
        if [ -n "$sqlite_inc_dir" ]; then
            SQLITEFLAGS="-I$sqlite_inc_dir"
        fi
    fi
    return 0
}

#_____________________________________________________________________
check_sqlite() {
    if test "x$enable_sqlite" != "xno" ; then
        if check_sqlite_incl && check_sqlite_libs ; then
            enable_sqlite=yes
        else
            enable_sqlite=no
        fi
    fi
}

#_____________________________________________________________________
check_tsil_libs() {
    check_library "libtsil" "$tsil_lib_dir" \
       "$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        return 1
    else
        local TSILLIBS_="-ltsil"
        if [ -z "$tsil_lib_dir" ]; then
            # assume that the linker will look in the default paths
            TSILLIBS="$TSILLIBS_"
        else
            TSILLIBS="-L$tsil_lib_dir $TSILLIBS_"
        fi
    fi
    return 0
}

#_____________________________________________________________________
check_tsil_incl() {
    check_header "tsil.h" "$tsil_inc_dir" \
	"$default_inc_paths"
    if test "x$found_hdr" = "x" ; then
        return 1
    else
        # assume that the compiler will look in the default paths
        if [ -n "$tsil_inc_dir" ]; then
            TSILFLAGS="-I$tsil_inc_dir"
        fi
    fi
    return 0
}

#_____________________________________________________________________
check_tsil() {
    if test "x$enable_tsil" != "xno" ; then
        if check_tsil_incl && check_tsil_libs ; then
            enable_tsil=yes
        else
            if [ "x$enable_tsil" = xyes ] ; then
                message "Error: TSIL not found."
                exit 1
            fi
            enable_tsil=no
        fi
    fi
}

#_____________________________________________________________________
find_symbol_using_pkgconfig() {
    local symbol
    local pkg
    local ldpaths
    local libnames
    local pkg_flags=$([ "x$enable_static" = xyes ] && echo "--static")
    pkg="$1"
    linker_flags=""
    type pkg-config > /dev/null 2>&1 || {
	logmsg "pkg-config not found"
	return 1
    }
    pkg-config --exists "$pkg" || {
	logmsg "pkg-config does not manage $pkg"
	return 1
    }
    ldpaths=$(pkg-config ${pkg_flags} --libs-only-L "$pkg")
    libnames=$(pkg-config ${pkg_flags} --libs-only-l "$pkg")
    shift
    for symbol; do
	for dopt in $default_lib_paths $ldpaths; do
	    for lopt in $libnames; do
		if check_symbol "$symbol" "$lopt" "$dopt"; then
		    logmsg "found $symbol in $dopt $lopt"
		    linker_flags=$(pkg-config ${pkg_flags} --libs "$pkg")
		    continue 3
		fi
	    done
	done
	return 1
    done
    return 0
}

#_____________________________________________________________________
check_blas_libs() {
    [ "$enable_lapack" = "no" ] && return 0
    [ "$enable_ilp64mkl_workaround" = "yes" ] && return 0

    # user has set BLASLIBS explicitly, no need to search
    test -n "$BLASLIBS" && return 0

    if find_symbol_using_pkgconfig blas ztpsv_; then
	BLASLIBS="$linker_flags"
    else
	check_blas_libs_using_options
    fi
}

#_____________________________________________________________________
check_lapack_libs() {
    [ "$enable_lapack" = "no" ] && return 0
    [ "$enable_ilp64mkl_workaround" = "yes" ] && return 0

    # user has set LAPACKLIBS explicitly, no need to search
    test -n "$LAPACKLIBS" && return 0

    if find_symbol_using_pkgconfig lapack dgbsv_; then
	LAPACKLIBS="$linker_flags"
    else
	check_lapack_libs_using_options
    fi
}

#_____________________________________________________________________
check_static_lib_cmd() {
    checking_msg "build static library command $STATIC_LIB_CMD"
    # strip arguments from the actual command
    makelib_cmd=$(echo "$STATIC_LIB_CMD" | awk '{ print $1; }')

    exists_in_path "$makelib_cmd"
    if [ -z "$cmd" ] ; then
        result "not found"
        message "Error: A program which builds static libraries must be installed!"
        message "   Use --with-static-lib-cmd= to specify the program to be used."
        exit 1
    else
        result "found $cmd"
    fi
}

#_____________________________________________________________________
check_shared_lib_cmd() {
    checking_msg "build shared library command $SHARED_LIB_CMD"
    # strip arguments from the actual command
    makelib_cmd=$(echo "$SHARED_LIB_CMD" | awk '{ print $1; }')

    exists_in_path "$makelib_cmd"
    if [ -z "$cmd" ] ; then
        result "not found"
        message "Error: A program which builds shared libraries must be installed!"
        message "   Use --with-shared-lib-cmd= to specify the program to be used."
        exit 1
    else
        result "found $cmd"
    fi
}

#_____________________________________________________________________
check_math_cmd() {
    checking_msg "Mathematica kernel $MATH"
    exists_in_path "$MATH"
    if [ -z "$cmd" ] ; then
        result "not found"
	MATH=""
	[ "${enable_meta}" = "yes" -o "$enable_librarylink" = "yes" ] || return

        message "Error: Mathematica needs to be installed to run the meta code or to enable LibraryLink!"
        message "   You can use the --with-math-cmd= option to specify the location of"
        message "   the math kernel."
        case "$operating_system" in
            Linux)  message "   It is usually installed in /usr/local/Wolfram/Mathematica/" ;;
            Darwin) message "   It is usually installed in /Applications/Mathematica.app/"  ;;
            CYGWIN_NT*) message "   It is usually installed in /cygdrive/c/Program Files/Wolfram Research/Mathematica/" ;;
        esac
        exit 1
    else
        result "found $cmd"
    fi
}

#_____________________________________________________________________
check_mathematica_info() {
    [ -z "$MATH" ] && return 0

    local _math_info_check_progr="${BASEDIR}/check_math_info.m"
    local _ok=false

    at_exit "rm -f \"${_math_info_check_progr}\""

    cat <<EOF > ${_math_info_check_progr}
error = 0;
Put[\$VersionNumber,
    OutputForm[\$SystemID],
    OutputForm[\$InstallationDirectory],
    "${mathconfig}"];
If[\$VersionNumber < ${required_mathematica_version},
   error = 1;
  ];
Quit[error];
EOF

    checking_msg "Mathematica version >= ${required_mathematica_version}"
    "$MATH" -run "Get[\"${_math_info_check_progr}\"]" > /dev/null 2>&1 &&
	_ok=true
    if test -r "${mathconfig}"; then
        MATH_VERSION=$(sed -n '1p' "${mathconfig}")
	MATH_SYSTEMID=$(sed -n '2p' "${mathconfig}")
        MATH_INSTDIR=$(sed -n '3p' "${mathconfig}")
    else
	_ok=false
    fi

    if $_ok; then
        result "ok (version ${MATH_VERSION} for ${MATH_SYSTEMID} in ${MATH_INSTDIR})"
    else
        result "not ok (version ${MATH_VERSION} for ${MATH_SYSTEMID} in ${MATH_INSTDIR})"
        message "Error: Mathematica ${required_mathematica_version} or higher needs to be installed!"
        exit 1
    fi
}

#_____________________________________________________________________
check_random_number_generator() {
    # check for random number generator
    checking_msg "random number generator"
    if try_compile_cpp_program "#include <random>" "std::minstd_rand generator; std::uniform_real_distribution<double> distribution(0., 1.);";
    then
        result "ok"
        DEFINE_ENABLE_RANDOM="#define ENABLE_RANDOM 1"
        logmsg "Enabling random number generator: ${DEFINE_ENABLE_RANDOM}"
    else
        result "not found"
        DEFINE_ENABLE_RANDOM="#undef ENABLE_RANDOM"
        logmsg "Disabling random number generator: ${DEFINE_ENABLE_RANDOM}"
    fi
}

#_____________________________________________________________________
check_sarah() {
    checking_msg "SARAH installation"
    rm -f ${sarahconfig}
    "$MATH" <<EOF > /dev/null
Needs["SARAH\`"];
If[!ValueQ[SA\`Version] || !StringQ[\$sarahDir], Quit[1]];
Export["${sarahconfig}", SA\`Version, "String"];
Quit[0];
EOF
    local _sarah_is_available="$?"
    if test "x${_sarah_is_available}" = "x0" ; then
        if test -r "${sarahconfig}" ; then
            SARAH_VERSION=$(cat "${sarahconfig}")
            split_version "$SARAH_VERSION" SARAH_MAJOR SARAH_MINOR SARAH_PATCH

            if ! major_minor_patch_at_least $SARAH_MAJOR $SARAH_MINOR $SARAH_PATCH "${required_sarah_major}" "${required_sarah_minor}" "${required_sarah_patch}"
            then
                result "not ok"
                message "Error: SARAH version ${SARAH_VERSION} no longer supported!"
                message "   Please use version ${required_sarah_version} or higher."
                exit 1
            else
                result "ok (version ${SARAH_VERSION})"
            fi
        else
            result "not ok"
            message "Error: Cannot not check SARAH version."
            exit 1
        fi
    else
        result "not ok"
        message "Error: SARAH is not installed correctly."
        message "   Please make sure Needs[\"SARAH\`\"] works correctly."
        exit 1
    fi
}

#_____________________________________________________________________
check_cygpath() {
    checking_msg "cygpath.exe"
    exists_in_path "cygpath.exe"
    if [ -z "$cmd" ]; then
        message "Error: cygpath.exe must be installed to locate the SARAH model files."
        message "   Please recheck the Cygwin installation since it is a part of the"
	message "   core cygwin package."
    else
	result "found $cmd"
    fi
}

#_____________________________________________________________________
enable_defines() {
    if test "x$enable_colors" = "xyes" ; then
        DEFINE_ENABLE_COLOR_PRINTOUT="#define ENABLE_COLOR_PRINTOUT 1"
        message "Enabling colored output"
        logmsg "   ${DEFINE_ENABLE_COLOR_PRINTOUT}"
    else
        DEFINE_ENABLE_COLOR_PRINTOUT="#undef ENABLE_COLOR"
        logmsg "Disabling colored output"
        logmsg "   ${DEFINE_ENABLE_COLOR_PRINTOUT}"
    fi

    if test "x$enable_debug" = "xyes" ; then
        DEFINE_ENABLE_DEBUG="#define ENABLE_DEBUG 1"
        CXXFLAGS="$CXXFLAGS -g"
        FFLAGS="$FFLAGS -g"
        message "Enabling debug mode"
        logmsg "   ${DEFINE_ENABLE_DEBUG}"
        logmsg "   CXXFLAGS = ${CXXFLAGS}"
        logmsg "   FFLAGS   = ${FFLAGS}"
    elif test "x$enable_debug" = "x" ; then
        DEFINE_ENABLE_DEBUG="#undef ENABLE_DEBUG"
        logmsg "Disabling debug mode"
        logmsg "   ${DEFINE_ENABLE_DEBUG}"
    elif test "x$enable_debug" = "xno" ; then
        DEFINE_ENABLE_DEBUG="#undef ENABLE_DEBUG"
        CPPFLAGS="$CPPFLAGS -DNDEBUG"
        message "Disabling debug mode and assertions"
        logmsg "   ${DEFINE_ENABLE_DEBUG}"
        logmsg "   CPPFLAGS = ${CPPFLAGS}"
    fi

    if test "x$enable_mass_error_check" = "xyes" ; then
        DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR="#define CHECK_EIGENVALUE_ERROR 1"
        message "Enabling mass eigenvalue error check"
        logmsg "   ${DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR}"
    else
        DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR="#undef CHECK_EIGENVALUE_ERROR"
        logmsg "Disabling eigenvalue error check"
        logmsg "   ${DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR}"
    fi

    if test "x$enable_fflite" = "xyes" ; then
        DEFINE_ENABLE_FFLITE="#define ENABLE_FFLITE 1"
        message "Enabling usage of fflite"
    else
        DEFINE_ENABLE_FFLITE="#undef ENABLE_FFLITE"
        logmsg "Disabling usage of fflite"
    fi
    logmsg "   ${DEFINE_ENABLE_FFLITE}"

    if test "x$enable_lapack" = "xno" ; then
        DEFINE_ENABLE_LAPACK="#undef ENABLE_LAPACK"
        message "Disabling LAPACK"
        logmsg "   ${DEFINE_ENABLE_LAPACK}"
    else
        enable_lapack=yes
        DEFINE_ENABLE_LAPACK="#define ENABLE_LAPACK 1"
        logmsg "Enabling LAPACK"
        logmsg "   ${DEFINE_ENABLE_LAPACK}"
    fi

    if test "x$enable_librarylink" = "xyes" ; then
        DEFINE_ENABLE_LIBRARYLINK="#define ENABLE_LIBRARYLINK 1"
        logmsg "Enabling LibraryLink"
        logmsg "   ${DEFINE_ENABLE_LIBRARYLINK}"
    else
        enable_librarylink=no
        DEFINE_ENABLE_LIBRARYLINK="#undef ENABLE_LIBRARYLINK"
        message "Disabling LibraryLink"
        logmsg "   ${DEFINE_ENABLE_LIBRARYLINK}"
    fi

    if test "x$enable_ilp64mkl_workaround" = "xyes" ; then
        DEFINE_ENABLE_ILP64MKL_WORKAROUND="#define ENABLE_ILP64MKL_WORKAROUND 1"
        message "Enabling MKL ILP64 workaround"
        logmsg "   ${DEFINE_ENABLE_ILP64MKL_WORKAROUND}"
    else
        enable_ilp64mkl_workaround=no
        DEFINE_ENABLE_ILP64MKL_WORKAROUND="#undef ENABLE_ILP64MKL_WORKAROUND"
        logmsg "Disabling usage of ILP64 MKL"
        logmsg "   ${DEFINE_ENABLE_ILP64MKL_WORKAROUND}"
    fi

    if test "x$enable_looptools" = "xyes" ; then
        DEFINE_ENABLE_LOOPTOOLS="#define ENABLE_LOOPTOOLS 1"
        message "Enabling usage of LoopTools"
	message "Warning: LoopTools is thread-unsafe since it accepts the renormalization scale"
	message "   via a global variable.  This might lead to a race condition if different"
	message "   RGE solvers run in multiple threads.  For such an application, consider the"
	message "   alternative \`--enable-fflite'."
        logmsg "   ${DEFINE_ENABLE_LOOPTOOLS}"
    else
        DEFINE_ENABLE_LOOPTOOLS="#undef ENABLE_LOOPTOOLS"
        logmsg "Disabling usage of LoopTools"
        logmsg "   ${DEFINE_ENABLE_LOOPTOOLS}"
    fi

    if test "x$enable_silent" = "xyes" ; then
        DEFINE_ENABLE_SILENT="#define ENABLE_SILENT 1"
        CPPFLAGS="$CPPFLAGS"
        message "Enabling silent mode"
        logmsg "   ${DEFINE_ENABLE_SILENT}"
    else
        DEFINE_ENABLE_SILENT="#undef ENABLE_SILENT"
        logmsg "Disabling silent mode"
        logmsg "   ${DEFINE_ENABLE_SILENT}"
    fi

    if test "x$enable_verbose" = "xyes" ; then
        if test "x$enable_silent" = "xyes" ; then
            message "Warning: ignoring --enable-verbose because silent mode is enabled!"
            DEFINE_ENABLE_VERBOSE="#undef ENABLE_VERBOSE"
            logmsg "Disabling verbose mode"
            logmsg "   ${DEFINE_ENABLE_VERBOSE}"
        else
            DEFINE_ENABLE_VERBOSE="#define ENABLE_VERBOSE 1"
            message "Enabling verbose mode"
            logmsg "   ${DEFINE_ENABLE_VERBOSE}"
        fi
    fi

    if test "x${enable_sqlite}" = "xyes" ; then
        DEFINE_ENABLE_SQLITE="#define ENABLE_SQLITE 1"
        logmsg "Enabling sqlite"
        logmsg "   ${DEFINE_ENABLE_SQLITE}"
    else
        enable_sqlite=no
        DEFINE_ENABLE_SQLITE="#undef ENABLE_SQLITE"
        message "Disabling sqlite"
        logmsg "   ${DEFINE_ENABLE_SQLITE}"
    fi

    if test "x${enable_threads}" = "xyes" ; then
        DEFINE_ENABLE_THREADS="#define ENABLE_THREADS 1"
        logmsg "Enabling multi-threading"
        logmsg "   ${DEFINE_ENABLE_THREADS}"
    else
        enable_threads=no
        DEFINE_ENABLE_THREADS="#undef ENABLE_THREADS"
        message "Disabling multi-threading"
        logmsg "   ${DEFINE_ENABLE_THREADS}"
    fi

    if test "x${enable_tsil}" = "xyes" ; then
        DEFINE_ENABLE_TSIL="#define ENABLE_TSIL 1"
        message "Enabling TSIL"
        logmsg "   ${DEFINE_ENABLE_TSIL}"
    else
        enable_tsil=no
        DEFINE_ENABLE_TSIL="#undef ENABLE_TSIL"
        message "Disabling TSIL"
        logmsg "   ${DEFINE_ENABLE_TSIL}"
    fi

    for s in ${SOLVERS}; do
	case "$s" in
	    all)
		DEFINE_ENABLE_TWO_SCALE_SOLVER="#define ENABLE_TWO_SCALE_SOLVER 1"
		DEFINE_ENABLE_LATTICE_SOLVER="#define ENABLE_LATTICE_SOLVER 1"
                DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER="#define ENABLE_SEMI_ANALYTIC_SOLVER 1"
		logmsg "   ${DEFINE_ENABLE_TWO_SCALE_SOLVER}"
		logmsg "   ${DEFINE_ENABLE_LATTICE_SOLVER}"
                logmsg "   ${DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER}"
		break ;;
	    two_scale)
		DEFINE_ENABLE_TWO_SCALE_SOLVER="#define ENABLE_TWO_SCALE_SOLVER 1";
		logmsg "   ${DEFINE_ENABLE_TWO_SCALE_SOLVER}"
		continue ;;
	    lattice)
		DEFINE_ENABLE_LATTICE_SOLVER="#define ENABLE_LATTICE_SOLVER 1";
		logmsg "   ${DEFINE_ENABLE_LATTICE_SOLVER}"
		continue ;;
            semi_analytic)
                DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER="#define ENABLE_SEMI_ANALYTIC_SOLVER 1";
                logmsg "   ${DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER}"
                continue ;;
	    *)
		message "Error: unknown solver: $a";
                message "Available solvers: $available_solvers";
                exit 1 ;;
	esac
    done

    for a in ${ADDONS}; do
        local addon_name="$(basename ${a})"
        DEFINE_ENABLE_ADDONS="${DEFINE_ENABLE_ADDONS}\n#define ENABLE_${addon_name} 1"
    done
}

#_____________________________________________________________________
replace_markers() {
    sed -e "s|@FLEXIBLESUSY_VERSION@|$FLEXIBLESUSY_VERSION|" \
	-e "s|@FLEXIBLESUSY_MAJOR@|$FLEXIBLESUSY_MAJOR|" \
	-e "s|@FLEXIBLESUSY_MINOR@|$FLEXIBLESUSY_MINOR|" \
	-e "s|@FLEXIBLESUSY_PATCH@|$FLEXIBLESUSY_PATCH|" \
	-e "s|@FLEXIBLESUSY_EXTRA@|$FLEXIBLESUSY_EXTRA|" \
        -e "s|@GIT_COMMIT@|$GIT_COMMIT|"   \
	-e "s|@PKGNAME@|$PROGRAM_NAME|"    \
	-e "s|@ABSBASEDIR@|$ABSBASEDIR|"   \
	-e "s|@ADDONS@|$ADDONS|"           \
	-e "s|@INSTALL_DIR@|$INSTALL_DIR|" \
	-e "s|@ALGORITHMS@|$SOLVERS|"   \
	-e "s|@BLASLIBS@|$BLASLIBS|"       \
	-e "s|@BOOSTTESTLIBS@|$BOOSTTESTLIBS|"     \
	-e "s|@BOOSTTHREADLIBS@|$BOOSTTHREADLIBS|"     \
	-e "s|@BOOSTFLAGS@|$BOOSTFLAGS|"   \
	-e "s|@THREADLIBS@|$THREADLIBS|"   \
	-e "s|@CPPFLAGS@|$CPPFLAGS|"       \
	-e "s|@CXXFLAGS@|$CXXFLAGS|"       \
	-e "s|@CXX@|$CXX|"                 \
	-e "s|@CFLAGS@|$CFLAGS|"           \
	-e "s|@CC@|$CC|"                   \
	-e "s|@FC@|$FC|"                   \
	-e "s|@FFLAGS@|$FFLAGS|"           \
	-e "s|@FLIBS@|$FLIBS|"             \
	-e "s|@FSCONFIG@|$FSCONFIG|"       \
	-e "s|@EIGENFLAGS@|$EIGENFLAGS|"   \
	-e "s|@GSLLIBS@|$GSLLIBS|"         \
	-e "s|@GSLFLAGS@|$GSLFLAGS|"       \
	-e "s|@LAPACKLIBS@|$LAPACKLIBS|"   \
        -e "s|@LDFLAGS@|$LDFLAGS|"         \
        -e "s|@LDLIBS@|$LDLIBS|"           \
	-e "s|@SARAH_DEP_GEN@|$SARAH_DEP_GEN|"   \
	-e "s|@ENABLE_COLOR_PRINTOUT@|$enable_colors|" \
	-e "s|@ENABLE_COMPILE@|$enable_compile|" \
	-e "s|@ENABLE_COMPILER_WARNINGS@|$enable_compiler_warnings|" \
	-e "s|@ENABLE_CHECK_EIGENVALUE_ERROR@|$enable_mass_error_check|" \
	-e "s|@ENABLE_DEBUG@|$enable_debug|"      \
	-e "s|@ENABLE_FFLITE@|$enable_fflite|" \
	-e "s|@ENABLE_ILP64MKL_WORKAROUND@|$enable_ilp64mkl_workaround|" \
	-e "s|@ENABLE_LAPACK@|$enable_lapack|" \
	-e "s|@ENABLE_LIBRARYLINK@|$enable_librarylink|" \
	-e "s|@ENABLE_LOOPTOOLS@|$enable_looptools|" \
	-e "s|@ENABLE_META@|$enable_meta|" \
	-e "s|@ENABLE_SILENT@|$enable_silent|"    \
	-e "s|@ENABLE_SQLITE@|$enable_sqlite|"    \
	-e "s|@ENABLE_THREADS@|$enable_threads|"  \
	-e "s|@ENABLE_TSIL@|$enable_tsil|"        \
	-e "s|@ENABLE_VERBOSE@|$enable_verbose|"  \
	-e "s|@LOOPFUNCLIBS@|$LOOPFUNCLIBS|"      \
	-e "s|@LOOPFUNCFLAGS@|$LOOPFUNCFLAGS|"    \
	-e "s|@LOOPTOOLSLIBS@|$LOOPTOOLSLIBS|"    \
	-e "s|@LOOPTOOLSFLAGS@|$LOOPTOOLSFLAGS|"  \
	-e "s|@OPTIONAL_MODULES@|$OPTIONAL_MODULES|" \
        -e "s|@SHARED_LIB_CMD@|$SHARED_LIB_CMD|"  \
        -e "s|@STATIC_LIB_CMD@|$STATIC_LIB_CMD|"  \
	-e "s|@SQLITELIBS@|$SQLITELIBS|"          \
	-e "s|@SQLITEFLAGS@|$SQLITEFLAGS|"        \
	-e "s|@TSILLIBS@|$TSILLIBS|"              \
	-e "s|@TSILFLAGS@|$TSILFLAGS|"            \
	-e "s|@MODELS@|$MODELS|"           \
	-e "s|@ENABLE_SHARED_LIBS@|$enable_shared_libs|" \
	-e "s|@ENABLE_STATIC@|$enable_static|"           \
	-e "s|@MATH@|$MATH|"               \
	-e "s|@MODULE_LIBEXT@|$MODULE_LIBEXT|"  \
	-e "s|@MODULE_MAKE_LIB_CMD@|$MODULE_MAKE_LIB_CMD|" \
	-e "s|@LIBLNK_LIBEXT@|$LIBLNK_LIBEXT|"  \
	-e "s|@LIBLNK_MAKE_LIB_CMD@|$LIBLNK_MAKE_LIB_CMD|"
}

#_____________________________________________________________________
help() {
cat <<EOF
Usage: ./$(basename $0) [options]
Options:

  --help,-h         Print this help message
  --version,-v      Print version information

enable/disable options, prefix with either --enable- or --disable-

  colors            Colored output (default: $enable_colors)
  compile           Compile the source code (default: $enable_compile)
  compiler-warnings Enable compiler warnings (default: $enable_compiler_warnings)
  debug             Debug messages and assertions (no default)
  mass-error-check  Check mass eigenvalue precision (default: $enable_mass_error_check)
  fflite            Use fflite to compute the loop functions (default: $enable_fflite)
  lapack            Enable LAPACK (default: $enable_lapack)
  librarylink       Build LibraryLink library for Mathematica interface (default: $enable_librarylink)
  looptools         Use LoopTools to compute the loop functions (default: $enable_looptools)
EOF
# BEGIN: NOT EXPORTED ##########################################
cat <<EOF
  meta              Create model classes (default: $enable_meta)
EOF
# END:   NOT EXPORTED ##########################################
cat <<EOF
  silent            Suppress all command line output (default: $enable_silent)
  sqlite            Enable SQLite (default: $enable_sqlite)
  shared-libs       Create shared libraries (default: $enable_shared_libs)
  static            Create statically linked executables (default: $enable_static)
  threads           Enable multi-threading (default: $enable_threads)
  tsil              Enable TSIL (default: $enable_tsil)
  verbose           Verbose messages (default: $enable_verbose)

Package directories, compilation settings and model selection

  --with-addons=            Comma separated list of addons to be build
                            (default: $ADDONS)
  --with-blas-libdir=       Path to search for BLAS library
  --with-blas-libs=         BLAS libraries to be linked
  --with-boost-libdir=      Path to search for BOOST libraries
  --with-boost-incdir=      Path to search for BOOST headers
  --with-cxx=               C++ compiler (default: $CXX)
  --with-cxxflags=          C++ compiler flags (default: $CXXFLAGS)
  --with-eigen-incdir=      Path to search for Eigen headers
  --with-fc=                Fortran compiler (default: $FC)
  --with-fflags=            Fortran compiler flags (default: $FFLAGS)
  --with-flibs=             Fortran libraries (default: $FLIBS)
                            If empty, FLIBS will be determined automatically.
  --with-gsl-config=        Path to gsl-config (default: $gsl_config)
  --with-install-dir=       Path to source code installation directory
  --with-lapack-libdir=     Path to search for LAPACK library
  --with-lapack-libs=       LAPACK libraries to be linked
  --with-looptools-libdir=  Path to search for LoopTools libraries
  --with-looptools-incdir=  Path to search for LoopTools headers
EOF
# BEGIN: NOT EXPORTED ##########################################
cat <<EOF
  --with-math-cmd=          Mathematic kernel (default: $MATH)
EOF
# END:   NOT EXPORTED ##########################################
cat <<EOF
  --with-models=            Comma separated list of models to be build
                            (default: $MODELS)
                            possible values: all <model1>,<model2>,...
  --with-optional-modules=  Load optional FlexibleSUSY modules
                            (for example the \`test' or \`examples' module)
  --with-pthread-libdir=    Path to search for pthread library
  --with-shared-ldflags=    Linker flags for shared library linking (default: $SHARED_LDFLAGS)
  --with-shared-ldlibs=     Additional libraries to be linked during shared library linking (default: $SHARED_LDLIBS)
  --with-shared-lib-cmd=    Command to make shared library (default: $SHARED_LIB_CMD)
  --with-shared-lib-ext=    File extension for shared library (default: $SHARED_LIB_EXT)
  --with-solvers=           Comma separated list of RG solver algorithms
                            (default: $SOLVERS)
                            possible values: all $available_solvers
  --with-sqlite-libdir=     Path to search for SQLite library
  --with-sqlite-incdir=     Path to search for SQLite header
  --with-static-ldflags=    Linker flags for static linking (default: $STATIC_LDFLAGS)
  --with-static-ldlibs=     Additional libraries to be linked during static linking (default: $STATIC_LDLIBS)
  --with-static-lib-cmd=    Command to make static library (default: $STATIC_LIB_CMD)
  --with-static-lib-ext=    File extension for static library (default: $STATIC_LIB_EXT)
  --with-tsil-libdir=       Path to search for TSIL library
  --with-tsil-incdir=       Path to search for TSIL header
EOF
}

#_____________________________________________________________________
version() {
cat <<EOF
$PROGRAM_NAME $FLEXIBLESUSY_VERSION
$PROGRAM_NAME 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 3 of the License, or
(at your option) any later version.  See http://www.gnu.org/licenses/
EOF
}

trap do_actions_at_exit 0
trap "exit 1" INT QUIT TERM

rm -f $logfile
write_configure_parameters "$*"

if test $# -gt 0 ; then
    while test ! "x$1" = "x" ; do
        case "$1" in
            -*=*) optarg=$(echo "$1" | sed 's/[-_a-zA-Z0-9]*=//') ;;
            *) optarg= ;;
        esac

        case $1 in
            --enable-*)
                f=$(echo "$1" | sed -e 's/--//' -e 's/-/_/g')
                eval prev='$'$(echo "${f}")
                if test "x${prev}" = "xyes"; then
                    echo "INFO: $1: already enabled by default."
                fi
                if test ! "x$(echo ${deprecated_options} | grep ${f})" = "x"; then
                    echo "WARNING: option $1 is deprecated and ignored"'!'
                fi
                eval ${f}=yes
                for c in $options ; do
                    if test "x$c" = "x$f" ; then
                        f=""
                    fi
                done
                for c in $deprecated_options ; do
                    if test "x$c" = "x$f" ; then
                        f=""
                    fi
                done
                if test "x$f" != "x" ; then
                    echo "Invalid option '$1'. Try $0 --help" ; exit 1 ;
                fi
                ;;
            --disable-*)
                f=$(echo "$1" | sed -e 's/--disable/enable/' -e 's/-/_/g')
                eval prev='$'$(echo "${f}")
                if test "x${prev}" = "xno"; then
                    echo "INFO: $1: already disabled by default."
                fi
                eval ${f}=no
                for c in $options ; do
                    if test "x$c" = "x$f" ; then
                        f=""
                    fi
                done
                if test "x$f" != "x" ; then
                    echo "Invalid option '$1'. Try $0 --help" ; exit 1 ;
                fi
                ;;
            --with-addons=*)         ADDONS=$optarg ;;
            --with-solvers=*)        SOLVERS=$optarg ;;
            --with-blas-libdir=*)    blas_lib_dir=$optarg ;;
            --with-blas-libs=*)      BLASLIBS=$optarg ;;
            --with-boost-libdir=*)   boost_lib_dir=$optarg ;;
            --with-boost-incdir=*)   boost_inc_dir=$optarg ;;
            --with-cc=*)             CC=$optarg ;;
            --with-cflags=*)         CFLAGS=$optarg ;;
            --with-cxx=*)            CXX=$optarg ;;
            --with-cxxflags=*)       CXXFLAGS=$optarg ;;
            --with-eigen-incdir=*)   eigen_inc_dir=$optarg ;;
            --with-fc=*)             FC=$optarg ;;
            --with-fflags=*)         FFLAGS=$optarg ;;
            --with-flibs=*)          FLIBS=$optarg ;;
            --with-gsl-config=*)     gsl_config=$optarg ;;
            --with-install-dir=*)    INSTALL_DIR=$optarg ;;
            --with-lapack-libdir=*)  lapack_lib_dir=$optarg ;;
            --with-lapack-libs=*)    LAPACKLIBS=$optarg ;;
            --with-looptools-libdir=*) looptools_lib_dir=$optarg ;;
            --with-looptools-incdir=*) looptools_inc_dir=$optarg ;;
            --with-math-cmd=*)       MATH=$optarg ;;
            --with-models=*)         MODELS=$optarg ;;
            --with-optional-modules=*) OPTIONAL_MODULES="$(echo $optarg | tr ',' ' ')" ;;
            --with-pthread-libdir=*) pthread_lib_dir=$optarg ;;
            --with-shared-ldflags=*) SHARED_LDFLAGS=$optarg ;;
            --with-shared-ldlibs=*)  SHARED_LDLIBS=$optarg ;;
            --with-shared-lib-cmd=*) SHARED_LIB_CMD=$optarg ;;
            --with-shared-lib-ext=*) SHARED_LIB_EXT=$optarg ;;
            --with-sqlite-libdir=*)  sqlite_lib_dir=$optarg ;;
            --with-sqlite-incdir=*)  sqlite_inc_dir=$optarg ;;
            --with-static-ldflags=*) STATIC_LDFLAGS=$optarg ;;
            --with-static-ldlibs=*)  STATIC_LDLIBS=$optarg ;;
            --with-static-lib-cmd=*) STATIC_LIB_CMD=$optarg ;;
            --with-static-lib-ext=*) STATIC_LIB_EXT=$optarg ;;
            --with-tsil-libdir=*)    tsil_lib_dir=$optarg ;;
            --with-tsil-incdir=*)    tsil_inc_dir=$optarg ;;
            --help|-h)               help; exit 0 ;;
            --version|-v)            version; exit 0 ;;
            *)  echo "Invalid option '$1'. Try $0 --help" ; exit 1 ;;
        esac
        shift
    done
fi

log_package_information
guess_machine_word_size
check_platform
check_solvers
check_install
check_install_dir

check_math_cmd
check_mathematica_info

if test "x${enable_meta}" = "xyes"; then
    check_sarah
    case "$operating_system" in
	CYGWIN_NT*) check_cygpath ;;
    esac
fi

if test "x${enable_compile}" = "xyes"; then
    check_multiarch
    check_librarylink
    check_cxx
    check_cxx_compiler_type
    check_cxx_compiler_version
    check_cxx_compiler_features
    check_cxxflags
    check_cc
    check_fc
    check_fflags
    check_linking
    check_boost
    check_boost_version
    check_boost_test_incl
    check_boost_test_libs
    check_eigen_incl
    check_eigen_version
    check_fortran_libs
    check_gsl_config
    check_ilp64mkl_in_math
    check_blas_libs
    check_lapack_libs
    if use_solver "lattice"; then
        check_boost_thread_incl
        check_boost_thread_libs
    fi
    if test "x$enable_looptools" = "xyes"; then
        check_looptools_incl
        check_looptools_libs
    fi
    check_loop_functions
    check_sqlite
    check_tsil
    check_static_lib_cmd
    check_shared_lib_cmd
    check_random_number_generator
    check_std_threads
    check_thread_libs
fi

check_models
check_addons

enable_defines

replace_markers \
    < $MAKEFILE_TMPL > $MAKEFILE

# BEGIN: NOT EXPORTED ##########################################

replace_markers \
    < $STANDALONE_MAKEFILE_TMPL | tee $STANDALONE_MAKEFILES > /dev/null

replace_markers \
    < $TOWER_MAKEFILE_TMPL | tee $TOWER_MAKEFILES > /dev/null

replace_markers \
    < $CUSTOMBETAS_MAKEFILE_TMPL | tee $CUSTOMBETAS_MAKEFILES > /dev/null

# END:   NOT EXPORTED ##########################################

replace_markers \
    < $FSCONFIG_TMPL > $FSCONFIG

sed -e "s|@FLEXIBLESUSY_VERSION@|$FLEXIBLESUSY_VERSION|" \
    -e "s|@FLEXIBLESUSY_MAJOR@|$FLEXIBLESUSY_MAJOR|" \
    -e "s|@FLEXIBLESUSY_MINOR@|$FLEXIBLESUSY_MINOR|" \
    -e "s|@FLEXIBLESUSY_PATCH@|$FLEXIBLESUSY_PATCH|" \
    -e "s|@FLEXIBLESUSY_EXTRA@|$FLEXIBLESUSY_EXTRA|" \
    -e "s|@GIT_COMMIT@|$GIT_COMMIT|"                 \
    -e "s|@GM2CALC_VERSION@|$GM2CALC_VERSION|"       \
    -e "s|@PKGNAME@|$PROGRAM_NAME|"                  \
    -e "s|@BLASLIBS@|$BLASLIBS|"                     \
    -e "s|@BOOSTTESTLIBS@|$BOOSTTESTLIBS|"           \
    -e "s|@BOOSTTHREADLIBS@|$BOOSTTHREADLIBS|"       \
    -e "s|@BOOSTFLAGS@|$BOOSTFLAGS|"                 \
    -e "s|@THREADLIBS@|$THREADLIBS|"                 \
    -e "s|@CPPFLAGS@|$CPPFLAGS|"                     \
    -e "s|@CXX@|$CXX|"                               \
    -e "s|@CXXFLAGS@|$CXXFLAGS|"                     \
    -e "s|@CC@|$CC|"                                 \
    -e "s|@CFLAGS@|$CFLAGS|"                         \
    -e "s|@EIGENFLAGS@|$EIGENFLAGS|"                 \
    -e "s|@FC@|$FC|"                                 \
    -e "s|@FFLAGS@|$FFLAGS|"                         \
    -e "s|@FLIBS@|$FLIBS|"                           \
    -e "s|@GSLLIBS@|$GSLLIBS|"                       \
    -e "s|@GSLFLAGS@|$GSLFLAGS|"                     \
    -e "s|@LAPACKLIBS@|$LAPACKLIBS|"                 \
    -e "s|@LDFLAGS@|$LDFLAGS|"                       \
    -e "s|@LDLIBS@|$LDLIBS|"                         \
    -e "s|@LOOPFUNCLIBS@|$LOOPFUNCLIBS|"             \
    -e "s|@LOOPFUNCFLAGS@|$LOOPFUNCFLAGS|"           \
    -e "s|@MATH_VERSION@|$MATH_VERSION|"             \
    -e "s|@MATH_INSTDIR@|$MATH_INSTDIR|"             \
    -e "s|@MATH_SYSTEMID@|$MATH_SYSTEMID|"           \
    -e "s|@SARAH_VERSION@|$SARAH_VERSION|"           \
    -e "s|@SARAH_MAJOR@|$SARAH_MAJOR|"               \
    -e "s|@SARAH_MINOR@|$SARAH_MINOR|"               \
    -e "s|@SARAH_PATCH@|$SARAH_PATCH|"               \
    -e "s|@SQLITELIBS@|$SQLITELIBS|"                 \
    -e "s|@SQLITEFLAGS@|$SQLITEFLAGS|"               \
    -e "s|@TSILLIBS@|$TSILLIBS|"                     \
    -e "s|@TSILFLAGS@|$TSILFLAGS|"                   \
    -e "s|@OPERATING_SYSTEM@|$operating_system|"     \
    -e "s|@KERNEL_VERSION@|$kernel_version|"         \
    -e "s|@DATE@|$DATE|"                             \
    -e "s|@DEFINE_ENABLE_COLOR_PRINTOUT@|$DEFINE_ENABLE_COLOR_PRINTOUT|" \
    -e "s|@DEFINE_ENABLE_DEBUG@|$DEFINE_ENABLE_DEBUG|"         \
    -e "s|@DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR@|$DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR|" \
    -e "s|@DEFINE_ENABLE_FFLITE@|$DEFINE_ENABLE_FFLITE|" \
    -e "s|@DEFINE_ENABLE_LAPACK@|$DEFINE_ENABLE_LAPACK|" \
    -e "s|@DEFINE_ENABLE_LIBRARYLINK@|$DEFINE_ENABLE_LIBRARYLINK|" \
    -e "s|@DEFINE_ENABLE_ILP64MKL_WORKAROUND@|$DEFINE_ENABLE_ILP64MKL_WORKAROUND|" \
    -e "s|@DEFINE_ENABLE_LOOPTOOLS@|$DEFINE_ENABLE_LOOPTOOLS|" \
    -e "s|@DEFINE_ENABLE_RANDOM@|$DEFINE_ENABLE_RANDOM|"       \
    -e "s|@DEFINE_ENABLE_SILENT@|$DEFINE_ENABLE_SILENT|"       \
    -e "s|@DEFINE_ENABLE_SQLITE@|$DEFINE_ENABLE_SQLITE|"       \
    -e "s|@DEFINE_ENABLE_THREADS@|$DEFINE_ENABLE_THREADS|"     \
    -e "s|@DEFINE_ENABLE_TSIL@|$DEFINE_ENABLE_TSIL|"           \
    -e "s|@DEFINE_ENABLE_VERBOSE@|$DEFINE_ENABLE_VERBOSE|"     \
    -e "s|@DEFINE_ENABLE_TWO_SCALE_SOLVER@|$DEFINE_ENABLE_TWO_SCALE_SOLVER|" \
    -e "s|@DEFINE_ENABLE_LATTICE_SOLVER@|$DEFINE_ENABLE_LATTICE_SOLVER|" \
    -e "s|@DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER@|$DEFINE_ENABLE_SEMI_ANALYTIC_SOLVER|" \
    -e "s|@DEFINE_ENABLE_ADDONS@|$DEFINE_ENABLE_ADDONS|"       \
    < $CONFIGHDR_TMPL > $CONFIGHDR

sed -e "s|@FLEXIBLESUSY_VERSION@|$FLEXIBLESUSY_VERSION|" \
    -e "s|@FLEXIBLESUSY_MAJOR@|$FLEXIBLESUSY_MAJOR|" \
    -e "s|@FLEXIBLESUSY_MINOR@|$FLEXIBLESUSY_MINOR|" \
    -e "s|@FLEXIBLESUSY_PATCH@|$FLEXIBLESUSY_PATCH|" \
    -e "s|@FLEXIBLESUSY_EXTRA@|$FLEXIBLESUSY_EXTRA|" \
    -e "s|@GIT_COMMIT@|$GIT_COMMIT|"   \
    -e "s|@PKGNAME@|$PROGRAM_NAME|"    \
    < $TEXVERSION_TMPL > $TEXVERSION

sed -e "s|@FLEXIBLESUSY_VERSION@|$FLEXIBLESUSY_VERSION|" \
    -e "s|@FLEXIBLESUSY_MAJOR@|$FLEXIBLESUSY_MAJOR|" \
    -e "s|@FLEXIBLESUSY_MINOR@|$FLEXIBLESUSY_MINOR|" \
    -e "s|@FLEXIBLESUSY_PATCH@|$FLEXIBLESUSY_PATCH|" \
    -e "s|@FLEXIBLESUSY_EXTRA@|$FLEXIBLESUSY_EXTRA|" \
    -e "s|@GIT_COMMIT@|$GIT_COMMIT|"   \
    -e "s|@PKGNAME@|$PROGRAM_NAME|"    \
    < $DOC_MAINPAGE_TMPL > $DOC_MAINPAGE

sed -e "s|@MATH@|$MATH|" \
    -e "s|@OPERATING_SYSTEM@|$operating_system|" \
    < $SARAH_DEP_GEN_TMPL > $SARAH_DEP_GEN

echo "$FLEXIBLESUSY_VERSION" > ${CONFIGDIR}/version
echo "$GIT_COMMIT" > ${CONFIGDIR}/git_commit
echo "{${required_sarah_major}, ${required_sarah_minor}, ${required_sarah_patch}}" > ${CONFIGDIR}/required_sarah_version.m

chmod a+x $FSCONFIG
chmod a+x $SARAH_DEP_GEN