configure

#!/bin/sh

# configure script for FlexibleSUSY
# Author: Alexander Voigt

PROGRAM_NAME=FlexibleSUSY
FLEXIBLESUSY_MAJOR=2
FLEXIBLESUSY_MINOR=6
FLEXIBLESUSY_PATCH=0
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="unknown"
HIMALAYA_VERSION="unknown"

# 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 and include directories
default_lib_paths="$LD_LIBRARY_PATH:/usr/lib:/usr/local/lib"
default_inc_paths="$CPATH:$CPLUS_INCLUDE_PATH:/usr/include:/usr/local/include"

# configure log file
logfile="$BASEDIR/config.log"
statusfile="$BASEDIR/config.status"
sarahconfig="$BASEDIR/config.sarah"
feynartsconfig="$BASEDIR/config.feynarts"
formcalcconfig="$BASEDIR/config.formcalc"
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
SARAH_MODEL_DIR=""

# target config header
CONFIGHDR=${CONFIGDIR}/config.h
CONFIGHDR_TMPL=${CONFIGDIR}/config.h.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_gm2calc            \
   enable_himalaya           \
   enable_librarylink        \
   enable_looptools          \
   enable_mass_error_check   \
   enable_shared_libs        \
   enable_silent             \
   enable_sqlite             \
   enable_static             \
   enable_threads            \
   enable_tsil               \
   enable_verbose            \
   enable_feynarts           \
   enable_formcalc           \
"

# 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_gm2calc="automatic"
enable_himalaya="automatic"
enable_librarylink="automatic"
enable_looptools="no"
enable_collier="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"
enable_feynarts="automatic"
enable_formcalc="automatic"

# corresponding preprocessor define statements
DEFINE_ENABLE_COLORS="#undef ENABLE_COLORS"
DEFINE_ENABLE_DEBUG="#undef ENABLE_DEBUG"
DEFINE_ENABLE_CHECK_EIGENVALUE_ERROR="#undef CHECK_EIGENVALUE_ERROR"
DEFINE_ENABLE_FFLITE="#undef ENABLE_FFLITE"
DEFINE_ENABLE_GM2CALC="#undef ENABLE_GM2CALC"
DEFINE_ENABLE_HIMALAYA="#undef ENABLE_HIMALAYA"
DEFINE_ENABLE_LIBRARYLINK="#undef ENABLE_LIBRARYLINK"
DEFINE_ENABLE_LOOPTOOLS="#undef ENABLE_LOOPTOOLS"
DEFINE_ENABLE_COLLIER="#undef ENABLE_COLLIER"
DEFINE_ENABLE_ODEINT="#undef ENABLE_ODEINT"
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"
looptools_lib_dir=""
looptools_inc_dir=""
collier_lib_dir=""
collier_inc_dir=""
GSLFLAGS=""
CPPFLAGS=""
CXXFLAGS="-std=c++14 -O2 -fPIC"
FFLAGS="-O2 -fPIC"
FLIBS=""
FMOD=""
FSTD=''
FUTILIBS=''
BOOSTTESTLIBS=""
BOOSTTHREADLIBS=""
THREADLIBS=""
CXX="g++"
EIGENFLAGS=""
FC="gfortran"
GSLLIBS=""
INSTALL_DIR=""
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=""
COLLIERFLAGS=""
COLLIERLIBS=""
LDFLAGS="$SHARED_LDFLAGS"
LDLIBS="$SHARED_LDLIBS"
LLFLAGS=""
LLLIBS=""
himalaya_lib_dir=""
himalaya_inc_dir=""
sqlite_lib_dir=""
sqlite_inc_dir=""
tsil_lib_dir=""
tsil_inc_dir=""
# available RG solvers
SOLVERS="two_scale semi_analytic"
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=""

#loop libraries that will be enabled additionally
LOOP_LIBRARIES=""

# 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="5.0.0"
required_clang_compiler_version="3.8.1"
required_icpc_compiler_version="17.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="11"
required_sarah_patch="0"
required_sarah_version="${required_sarah_major}.${required_sarah_minor}.${required_sarah_patch}"
SARAH_VERSION="unknown"
SARAH_MAJOR="0"
SARAH_MINOR="0"
SARAH_PATCH="0"

# required FeynArts version
required_feynarts_version="3.9.0"
FEYNARTS_VERSION="unknown"

# required FormCalc version
required_formcalc_version="9.5.0"
FORMCALC_VERSION="unknown"

# 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).  Use -n
    # as first parameter to prevent a newline at the end of the
    # message.
    if test $# -lt 1 ; then
        echo "message: Too few arguments"
        return 1
    fi
    if test "x$1" = "x-n"; then
        shift
        printf "%s" "$*"
        logmsg "-n" "$*"
    else
        echo "$*"
        logmsg "$*"
    fi
}

#_____________________________________________________________________
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]')"
    exists_in_path getconf && chip="${chip}$(getconf LONG_BIT)"
    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"
}

#_____________________________________________________________________
make_unique() {
    # removes duplicate words from the string $1 (preserves order)
    local str="$1"
    local res=""

    for s in ${str}; do
        contains "${res}" "${s}" && continue
        res="${res} ${s}"
    done

    echo "${res}" | sed -e 's/^ *//' -e 's/ *$//'
}

#_____________________________________________________________________
string_trim() {
    echo "$1" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'
}

#_____________________________________________________________________
check_library() {
    # This function will try to locate a library [$1] in the directory
    # given in $2 or in a default path [$3].
    #
    # 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
    elif test $# -gt 3 ; then
        echo "check_library: Too many arguments.  Default path should be colon-separated."
        return 1
    fi

    # Save arguments in local names
    lib="$1"
    libdirl="$2"
    libdirs="$3"
    # 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 .tbd ; do
            libs="$libs $i$ext"
        done
    done

    found_dir=""
    found_lib=""

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

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

    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 [$3].
    #
    # 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
    elif test $# -gt 3 ; then
        echo "check_header: Too many arguments.  The default paths should be colon-separated."
        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=""

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

    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
}

#_____________________________________________________________________
is_posix_platform() {
    case "$operating_system" in
        *BSD*)     return 0 ;;
        Darwin)    return 0 ;;
        DragonFly) return 0 ;;
        GNU*)      return 0 ;;
        Linux)     return 0 ;;
    esac
    return 1
}

#_____________________________________________________________________
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="${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

    MODELS=$(make_unique "${MODELS}")

    # 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_optional_modules() {
    if test -z "${OPTIONAL_MODULES}"; then
        logmsg "No optional modules specified"
        return 0
    fi

    checking_msg "optional modules"
    local optional_modules="$(echo $OPTIONAL_MODULES | tr ',' ' ')"
    OPTIONAL_MODULES=""
    for a in ${optional_modules}; do
        if test -d "$BASEDIR/$a" ; then
            OPTIONAL_MODULES="$OPTIONAL_MODULES $a"
            continue
        else
            result "not ok"
            message "Error: module directory \"$BASEDIR/$a\" does not exist!"
            message "Please create the directory and put a module.mk file in it."
            exit 1
        fi
    done

    # check for Makefile module
    for m in ${OPTIONAL_MODULES}; 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 module_names="$(echo ${OPTIONAL_MODULES} | sed -e 's|addons/||g' -e 's/^ *//' -e 's/ *$//')"

    result "ok (${module_names})"
    logmsg "   Optional modules: ${OPTIONAL_MODULES}"
}

#_____________________________________________________________________
check_librarylink_incl() {
    local default_llincdir="\
${MATH_INSTDIR}/SystemFiles/IncludeFiles/C:\
${MATH_INSTDIR}/SystemFiles/Links/MathLink/DeveloperKit/${MATH_SYSTEMID}/CompilerAdditions:\
${MATH_INSTDIR}/SystemFiles/Links/MathLink/DeveloperKit/CompilerAdditions:\
${MATH_INSTDIR}/AddOns/MathLink/DeveloperKit/$sysid/CompilerAdditions"

    check_header "WolframLibrary.h" "$default_llincdir" \
                 "$default_inc_paths"
    local wlib_hdr="$found_hdr"
    local wlib_dir="$found_dir"

    if test "x$wlib_hdr" = "x" ; then
        message "Error: WolframLibrary.h must be installed to enable LibraryLink"
        message "   Please install the MathLink development components, or reconfigure"
        message "   with \`--disable-librarylink' to disable LibraryLink"
        exit 1
    fi

    check_header "mathlink.h" "$default_llincdir" \
                 "$default_inc_paths"
    local mathlink_hdr="$found_hdr"
    local mathlink_dir="$found_dir"

    if test "x$mathlink_hdr" = "x" ; then
        message "Error: mathlink.h must be installed to enable LibraryLink"
        message "   Please install the MathLink development components, or reconfigure"
        message "   with \`--disable-librarylink' to disable LibraryLink"
        exit 1
    fi

    if contains_not "$LLFLAGS" "-I$wlib_dir" ; then
        LLFLAGS="${LLFLAGS} -I$wlib_dir"
    fi
    if contains_not "$LLFLAGS" "-I$mathlink_dir" ; then
        LLFLAGS="${LLFLAGS} -I$mathlink_dir"
    fi
}

#_____________________________________________________________________
check_librarylink_interface_version() {
    found_llinterface_version=""

    try_compile_run_cpp_program "#include <iostream>
#include <mathlink.h>
int main() {
   int mathlink_interface_version = MLINTERFACE;
   std::cout << mathlink_interface_version << '\n';
   return 0;
}" "$CXX" "${LLFLAGS}" && [ $cpp_exit = 0 ] || {
        message "Warning: could not determine MathLink interface version because"
        message "   compilation or execution of the MathLink test program failed."
        found_llinterface_version="unknown"
    }

    if test "x$found_llinterface_version" != "xunknown" ; then
        found_llinterface_version="$cpp_output"
    fi

    if test "x$found_llinterface_version" = "x" ; then
        message "Warning: failed to determine MathLink interface version from"
        message "   MathLink test program."
        found_llinterface_version="unknown"
    fi
}

#_____________________________________________________________________
check_librarylink_libs() {
    # do not overwrite user supplied flags
    if test "x$LLLIBS" = "x" ; then
        # checks for any explicit linker flags required for LibraryLink
        local default_lllibdirs="\
${MATH_INSTDIR}/SystemFiles/Links/MathLink/DeveloperKit/${MATH_SYSTEMID}/CompilerAdditions:\
${MATH_INSTDIR}/SystemFiles/Links/MathLink/DeveloperKit/CompilerAdditions"
        local mathlink_lib_flags=""

        case "$operating_system" in
            Darwin)
                check_librarylink_interface_version

                local mlinterface_version="$found_llinterface_version"
                local mathlink_search_libs=""

                if test "x$mlinterface_version" != "xunknown" ; then
                    mathlink_search_libs="libMLi$mlinterface_version"
                else
                    mathlink_search_libs="libMLi4 libMLi3"
                fi

                for ll in $mathlink_search_libs ; do
                    check_library "$ll" "$default_lllibdirs" "$default_lib_paths"
                    if test "x$found_lib" != "x" ; then
                        break
                    fi
                done

                if test "x$found_lib" = "x" ; then
                    message "Error: MathLink libraries must be installed to enable LibraryLink"
                    message "   You can use --with-lllibs= to specify the required"
                    message "   flags for linking MathLink libraries, or reconfigure"
                    message "   with \`--disable-librarylink' to disable LibraryLink"
                    exit 1
                fi

                local mathlink_lib=-l$(echo "$found_lib" | sed 's/^lib\(.*\)\..*$/\1/')
                mathlink_lib_flags="-L${found_dir} ${mathlink_lib} -lc++ -framework Foundation"
                ;;
        esac
        LLLIBS="$mathlink_lib_flags"
    fi
}

#_____________________________________________________________________
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

    if [ "x$enable_librarylink" = "xyes" ] ; then
        check_librarylink_incl
        check_librarylink_libs
	[ "x$machine_word_size" = "x32" ] && CPPFLAGS="$CPPFLAGS -DMINT_32"
    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 ""

    IFS=":"
    for p in $PATH; do
        unset IFS
        logmsg "PATH: \"${p}\""
    done
    unset IFS
    logmsg ""

    IFS=":"
    for p in $LD_LIBRARY_PATH; do
        unset IFS
        logmsg "LD_LIBRARY_PATH: \"${p}\""
    done
    unset IFS
    logmsg ""

    IFS=":"
    for p in $CPATH; do
        unset IFS
        logmsg "CPATH: \"${p}\""
    done
    unset IFS
    logmsg ""

    IFS=":"
    for p in $CPLUS_INCLUDE_PATH; do
        unset IFS
        logmsg "CPLUS_INCLUDE_PATH: \"${p}\""
    done
    unset IFS
    logmsg ""

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

#_____________________________________________________________________
reset_default_static_linker_cmd() {
   local os_=$( (uname -s) 2>/dev/null || echo unknown)
   case "$os_" in
      Linux)
         STATIC_LIB_CMD="ar cruU";;
   esac
}

#_____________________________________________________________________
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() {
    [ -z "$boost_inc_dir" ] && \
    [ -z "$boost_lib_dir" ] && \
    type pkg-config > /dev/null && \
    [ -f boost_unit_test_framework.pc ] && \
    {
        message -n "Checking boost library using local boost_unit_test_framework.pc ... "
        BOOSTFLAGS=$(PKG_CONFIG_PATH=. pkg-config boost_unit_test_framework --cflags)
        BOOSTTESTLIBS=$(PKG_CONFIG_PATH=. pkg-config boost_unit_test_framework --libs)
        message "ok"
        return
    }

    [ -z "$boost_inc_dir" ] && \
    [ -z "$boost_lib_dir" ] && \
    type pkg-config > /dev/null && \
    [ -f boost.pc ] && \
    {
        message -n "Checking boost library using local boost.pc ... "
        BOOSTFLAGS=$(PKG_CONFIG_PATH=. pkg-config boost --cflags)
        BOOSTTESTLIBS=$(PKG_CONFIG_PATH=. pkg-config boost --libs)
        message "ok"
        return
    }

    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
    check_boost_test_incl
    check_boost_test_libs
}

#_____________________________________________________________________
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"

            if test "x${enable_threads}" = "xyes" ; then
                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."
                exit 1
            fi

            enable_threads="no"
        fi
    fi
}

#_____________________________________________________________________
check_thread_libs() {
    is_posix_platform || return

    # additional search paths by the compiler
    local cc_lib_search_paths=""
    case "$cxx_compiler_type" in
	gnu|clang)
	    cc_lib_search_paths=$(${CXX} -print-search-dirs | sed -n -e '/libraries:/s/libraries: *=//p')
	    cc_lib_search_paths=$cc_lib_search_paths$(${CXX} -Xlinker -v 2>&1 | sed -n '/Library search paths:/,/Framework search paths:/p' | sed '/Library search paths:/d; /Framework search paths:/d' | sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/ /g' | tr -s '[:blank:]' ':')
	    ;;
    esac

    check_library "libpthread" "$pthread_lib_dir" "$default_lib_paths:$cc_lib_search_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
}

#_____________________________________________________________________
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_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() {
    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() {
    local eigen_name=""

    [ -f eigen.pc ] && eigen_name="eigen"
    [ -f eigen3.pc ] && eigen_name="eigen3"

    [ -z "$eigen_inc_dir" ] && \
    type pkg-config > /dev/null && \
    [ -n ${eigen_name} ] && \
    [ -f ${eigen_name}.pc ] && \
    {
        message -n "Checking for Eigen library using local ${eigen_name}.pc ... "
        EIGENFLAGS=$(PKG_CONFIG_PATH=. pkg-config ${eigen_name} --cflags)
        message "ok"
        return
    }

    # Eigen headers are usually in the `eigen3` subdirectory of the include paths.
    eigen_inc_paths=""
    IFS=":"
    for inc_path in $default_inc_paths; do
        unset IFS
        eigen_inc_paths="$eigen_inc_paths:$inc_path/eigen3:$inc_path"
    done
    unset IFS
    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}"

    version_at_least "$eigen_version" "3.3.0" || {
        message "Warning: You are using Eigen ${eigen_version}."
        message "   Compilation errors can occur with this Eigen version in models with"
        message "   complex parameters. We recommend to upgrade to Eigen 3.3.0 at least."
    }
}

#_____________________________________________________________________
check_eigen() {
    check_eigen_incl
    check_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_fmod() {
   case "${FC}" in
      gfortran*)
         FMOD='-J'
         ;;
      ifort*)
         FMOD='-module'
         ;;
   esac
}

#_____________________________________________________________________
check_fstd() {
   case "${FC}" in
      gfortran*)
         FSTD='-std=f2008'
         ;;
      ifort*)
         FSTD='-std08'
         ;;
   esac
}

#_____________________________________________________________________
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')
            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 -lifport -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_gm2calc_version() {
    checking_msg "GM2Calc version"

    try_compile_run_cpp_program "#include <iostream>
#include \"gm2calc/gm2_version.h\"
int main() {
   std::cout << GM2CALC_VERSION << '\n';
   return 0;
}" "$CXX" "${GM2CALCFLAGS}" && [ $cpp_exit = 0 ] || {
        result "unknown"
        message "Warning: could not determine GM2Calc version because"
        message "   compilation or execution of the GM2Calc test program failed."
	return 1
    }

    local GM2CALC_VERSION="$cpp_output"

    result "ok (version ${GM2CALC_VERSION})"
    logmsg "   GM2Calc version found: ${GM2CALC_VERSION}"

    version_at_least "$GM2CALC_VERSION" "1.7.0" || {
        message "Warning: An old version of GM2Calc has been detected ($GM2CALC_VERSION)."
        message "   Please consider upgrading to version 1.7.0 (or higher)."
    }
}

#_____________________________________________________________________
check_gm2calc_incl() {
    check_header "gm2calc/gm2_version.h" "$gm2calc_inc_dir"
    if test "x$found_hdr" = "x" ; then
        if test "x$enable_gm2calc" = "xyes" ; then
            message "Error: GM2Calc's gm2_version.h must be installed if you want"
            message "   to use GM2Calc, see https://github.com/GM2Calc/GM2Calc"
            message "   You can use the --with-gm2calc-incdir= option to specify the"
            message "   location of version.hpp and the other headers."
            exit 1
        else
            return 1
        fi
    else
        # assume that the compiler will look in the default paths
        if [ -n "$gm2calc_inc_dir" ]; then
            GM2CALCFLAGS="-I$gm2calc_inc_dir"
        fi

        check_gm2calc_version
    fi
    return 0
}

#_____________________________________________________________________
check_gm2calc_libs() {
    check_library "libgm2calc" "$gm2calc_lib_dir" "$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        if test "x$enable_gm2calc" = "xyes" ; then
            message "Error: The GM2Calc library must be installed if you want"
            message "   to use GM2Calc, see https://github.com/GM2Calc/GM2Calc"
            message "   You can use the --with-gm2calc-libdir= option to specify the"
            message "   location of the GM2Calc library."
            exit 1
        else
            return 1
        fi
    else
        local GM2CALCLIBS_="-lgm2calc"
        if [ -z "$gm2calc_lib_dir" ]; then
            # assume that the linker will look in the default paths
            GM2CALCLIBS="$GM2CALCLIBS_"
        else
            GM2CALCLIBS="-L$gm2calc_lib_dir -Wl,-rpath,$gm2calc_lib_dir $GM2CALCLIBS_"
        fi
    fi
    return 0
}

#_____________________________________________________________________
check_gm2calc() {
    if test "x$enable_gm2calc" != "xno" ; then
        local gm2calc_name=""

        [ -f GM2Calc.pc ] && gm2calc_name="GM2Calc"
        [ -f gm2calc.pc ] && gm2calc_name="gm2calc"

        [ -z "$gm2calc_inc_dir" ] && \
        [ -z "$gm2calc_lib_dir" ] && \
        type pkg-config > /dev/null && \
        [ -n ${gm2calc_name} ] && \
        [ -f ${gm2calc_name}.pc ] && \
        {
            message -n "Checking GM2Calc using local ${gm2calc_name}.pc ... "
            GM2CALCFLAGS=$(PKG_CONFIG_PATH=. pkg-config ${gm2calc_name} --cflags)
            GM2CALCLIBS=$(PKG_CONFIG_PATH=. pkg-config ${gm2calc_name} --libs)
            GM2CALC_VERSION=$(PKG_CONFIG_PATH=. pkg-config ${gm2calc_name} --modversion)
            enable_gm2calc=yes
            message "ok (version ${GM2CALC_VERSION})"
            version_at_least "$GM2CALC_VERSION" "1.7.0" || {
                message "Warning: An old version of GM2Calc has been detected ($GM2CALC_VERSION)."
                message "   Please consider upgrading to version 1.7.0 (or higher)."
            }
            return
        }

        if check_gm2calc_incl && check_gm2calc_libs ; then
            enable_gm2calc=yes
        else
            enable_gm2calc=no
        fi
    fi
}

#_____________________________________________________________________
check_himalaya_version() {
    checking_msg "Himalaya version"

    try_compile_run_cpp_program "#include <iostream>
#include \"himalaya/version.hpp\"
int main() {
   std::cout << Himalaya_VERSION_MAJOR << '.' << Himalaya_VERSION_MINOR << '.' << Himalaya_VERSION_RELEASE << '\n';
   return 0;
}" "$CXX" "${HIMALAYAFLAGS}" && [ $cpp_exit = 0 ] || {
        result "unknown"
        message "Warning: could not determine Himalaya version because"
        message "   compilation or execution of the Himalaya test program failed."
	return 1
    }

    local HIMALAYA_VERSION="$cpp_output"

    result "ok (version ${HIMALAYA_VERSION})"
    logmsg "   Himalaya version found: ${HIMALAYA_VERSION}"

    version_at_least "$HIMALAYA_VERSION" "2.0.0" || {
        message "Warning: An old version of Himalaya has been detected ($HIMALAYA_VERSION)."
        message "   Please consider upgrading to version 2.0.0 (or higher)."
    }
}

#_____________________________________________________________________
check_himalaya_incl() {
    check_header "himalaya/version.hpp" "$himalaya_inc_dir"
    if test "x$found_hdr" = "x" ; then
        if test "x$enable_himalaya" = "xyes" ; then
            message "Error: Himalaya's version.hpp must be installed if you want"
            message "   to use Himalaya, see https://github.com/Himalaya-Library"
            message "   You can use the --with-himalaya-incdir= option to specify the"
            message "   location of version.hpp and the other headers."
            exit 1
        else
            return 1
        fi
    else
        # assume that the compiler will look in the default paths
        if [ -n "$himalaya_inc_dir" ]; then
            HIMALAYAFLAGS="-I$himalaya_inc_dir"
        fi

        check_himalaya_version
    fi
    return 0
}

#_____________________________________________________________________
check_himalaya_libs() {
    check_library "libHimalaya" "$himalaya_lib_dir" \
	"$default_lib_paths"
    if test "x$found_lib" = "x" ; then
        if test "x$enable_himalaya" = "xyes" ; then
            message "Error: The Himalaya library must be installed if you want"
            message "   to use Himalaya, see https://github.com/Himalaya-Library"
            message "   You can use the --with-himalaya-libdir= option to specify the"
            message "   location of the Himalaya library."
            exit 1
        else
            return 1
        fi
    else
        local HIMALAYALIBS_="-lHimalaya -lDSZ"
        if [ -z "$himalaya_lib_dir" ]; then
            # assume that the linker will look in the default paths
            HIMALAYALIBS="$HIMALAYALIBS_"
        else
            HIMALAYALIBS="-L$himalaya_lib_dir -Wl,-rpath,$himalaya_lib_dir $HIMALAYALIBS_"
        fi
    fi
    return 0
}

#_____________________________________________________________________
check_himalaya() {
    if test "x$enable_himalaya" != "xno" ; then
        local himalaya_name=""

        [ -f Himalaya.pc ] && himalaya_name="Himalaya"
        [ -f himalaya.pc ] && himalaya_name="himalaya"

        [ -z "$himalaya_inc_dir" ] && \
        [ -z "$himalaya_lib_dir" ] && \
        type pkg-config > /dev/null && \
        [ -n ${himalaya_name} ] && \
        [ -f ${himalaya_name}.pc ] && \
        {
            message -n "Checking Himalaya using local ${himalaya_name}.pc ... "
            HIMALAYAFLAGS=$(PKG_CONFIG_PATH=. pkg-config ${himalaya_name} --cflags)
            HIMALAYALIBS=$(PKG_CONFIG_PATH=. pkg-config ${himalaya_name} --libs)
            HIMALAYA_VERSION=$(PKG_CONFIG_PATH=. pkg-config ${himalaya_name} --modversion)
            enable_himalaya=yes
            message "ok"
            return
        }

        if check_himalaya_incl && check_himalaya_libs ; then
            enable_himalaya=yes
        else
            enable_himalaya=no
        fi
    fi
}

#_____________________________________________________________________
check_required_libs() {
    if [ "$enable_meta" = yes -a -n "${MATH}" ] ; then
        message "Checking model files for required third party libraries"

        for m in ${MODELS}; do
            local model_name=$(echo ${m} | sed -e 's|models/||')
            local model_file="models/${model_name}/FlexibleSUSY.m"

            [ -e "${model_file}" ] || continue

            # early continue to skip expensive Mathematica kernel
            # calls, if possible
            grep 'UseSMYukawa2Loop\|aMuonGM2Calc\|aMuonGM2CalcUncertainty\|UseHiggs3LoopMSSM\|FSHimalayaMh23L' "${model_file}" > /dev/null 2>&1 || continue

            mma_symbol_is "${model_file}" "${MATH}" "UseSMYukawa2Loop" "True" && {
                message "   TSIL is required to build $model_name"
                enable_tsil=yes
            }

            mma_symbol_is "${model_file}" "${MATH}" "aMuonGM2Calc" "True" && {
                message "   GM2Calc is required to build $model_name";
                enable_gm2calc=yes
            }

            mma_symbol_is "${model_file}" "${MATH}" "aMuonGM2CalcUncertainty" "True" && {
                message "   GM2Calc is required to build $model_name";
                enable_gm2calc=yes
            }

            mma_symbol_is "${model_file}" "${MATH}" "UseHiggs3LoopMSSM" "True" && {
                message "   Himalaya is required to build $model_name";
                enable_himalaya=yes
            }

            cat <<EOF | "${MATH}" > /dev/null 2>&1
Get["${model_file}"]

If[FreeQ[HighScaleInput, FSHimalayaMh23L] &&
   FreeQ[SUSYScaleInput, FSHimalayaMh23L] &&
   FreeQ[LowScaleInput , FSHimalayaMh23L],
   Quit[1],
   Quit[0]
]
EOF

            [ "x$?" = "x0" ] && {
                message "   Himalaya is required to build $model_name";
                enable_himalaya=yes
            }

        done
    fi
}

#_____________________________________________________________________
check_looptools_libs() {
   if [ -z "$looptools_lib_dir" ]; then
      message "Warning: --with-looptools-libdir= has not been set, but"
      message "         LoopTools has been enabled via --enable-looptools or"
      message "         by --with-loop-libraries=looptools."
   fi

   check_library "libooptools" "$looptools_lib_dir" "$default_lib_paths"
   if [ "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"
      message "       the 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 -Wl,-rpath,$looptools_lib_dir $LOOPTOOLSLIBS_"
      fi

      # check dependency on libquadmath by searching for cabsq in liblooptools
      check_symbol "cabsq" "$found_lib" "$found_dir"
      if test -n "$found_lib" ; then
         LOOPTOOLSLIBS="$LOOPTOOLSLIBS -lquadmath"
      fi
   fi
   case "$operating_system" in
      Darwin)
         local gcc_=$(${CXX} -print-search-dirs | sed -n -e '/libraries:/s/libraries: *=//p')
         check_library "libgcc" "$gcc_" "$default_lib_paths"
         if test "x$found_lib" = "x" ; then
            message "Error: libgcc not found in $gcc_ $default_lib_paths"
            message "       but required by LoopTools."
               exit 1
            else
               LOOPTOOLSLIBS="$LOOPTOOLSLIBS -L$found_dir -lgcc"
         fi;;
   esac
}

#_____________________________________________________________________
check_looptools_incl() {
# defines LOOPTOOLSFLAGS variable
   if [ -z "$looptools_inc_dir" ]; then
      message "Warning: --with-looptools-incdir= has not been set, but"
      message "         LoopTools has been enabled via --enable-looptools or"
      message "         by --with-loop-libraries=looptools."
   fi

   check_header "clooptools.h" "$looptools_inc_dir" "$default_inc_paths"
   if [ "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"
      message "       the location of the clooptools.h header."
      exit 1
   else
      if [ -n "$looptools_inc_dir" ]; then
         LOOPTOOLSFLAGS="-I$looptools_inc_dir"
      fi
   fi
}

#_____________________________________________________________________
check_looptools() {
    local looptools_name=""

    [ -f LoopTools.pc ] && looptools_name="LoopTools"
    [ -f looptools.pc ] && looptools_name="looptools"

   [ -z "$looptools_inc_dir" ] && \
   [ -z "$looptools_lib_dir" ] && \
   type pkg-config > /dev/null && \
   [ -n ${looptools_name} ] && \
   [ -f ${looptools_name}.pc ] && \
   {
      message -n "Checking LoopTools using local ${looptools_name}.pc ... "
      LOOPTOOLSFLAGS=$(PKG_CONFIG_PATH=. pkg-config ${looptools_name} --cflags)
      LOOPTOOLSLIBS=$(PKG_CONFIG_PATH=. pkg-config ${looptools_name} --libs)
      enable_looptools=yes
      message "ok"
      return
   }

   check_looptools_incl
   check_looptools_libs
}

#_____________________________________________________________________
check_collier_libs() {
# defines COLLIERLIBS variable
   if [ -z "$collier_lib_dir" ]; then
      message "Warning: --with-collier-libdir= has not been set, but COLLIER"
      message "         has been enabled via --with-loop-libraries=."
   fi

   check_library "libcollier" "$collier_lib_dir" "$default_lib_paths"
   if [ "x$found_lib" = "x" ]; then
      message "Error: libcollier must be present if you want"
      message "       to use COLLIER, see https://collier.hepforge.org/"
      message "       You can use the --with-collier-libdir= option to specify"
      message "       the location of the libcollier library."
      exit 1
   else
      local COLLIERLIBS_="-lcollier"
      if [ -z "$collier_lib_dir" ]; then
         # assume that the linker will look in the default paths
         COLLIERLIBS=" $COLLIERLIBS_ "
      else
         COLLIERLIBS="$ABSBASEDIR/src/loop_libraries/libcollier_wrapper.a -L$collier_lib_dir -Wl,-rpath,$collier_lib_dir $COLLIERLIBS_"
      fi
   fi
}

#_____________________________________________________________________
check_collier_incl() {
# defines COLLIERFLAGS variable
   if [ -z "$collier_inc_dir" ] ; then
      message "Warning: --with-collier-incdir= has not been set, but COLLIER"
      message "         has been enabled by --with-loop-libraries=collier."
   fi

   check_header "collier.mod" "$collier_inc_dir" "$default_inc_paths"
   if [ "x$found_hdr" = "x" ]; then
      message "Error: at least collier.mod must be present if you want"
      message "       to use COLLIER, see https://collier.hepforge.org/"
      message "       You can use the --with-collier-incdir= option to specify"
      message "       the location of the collier.mod file."
      exit 1
   else
      if [ -n "$collier_inc_dir" ]; then
         COLLIERFLAGS="-I$collier_inc_dir"
      fi
   fi
}

#_____________________________________________________________________
check_collier() {
    local collier_name=""

    [ -f COLLIER.pc ] && collier_name="COLLIER"
    [ -f collier.pc ] && collier_name="collier"

   [ -z "$collier_inc_dir" ] && \
   [ -z "$collier_lib_dir" ] && \
   type pkg-config > /dev/null && \
   [ -n ${collier_name} ] && \
   [ -f ${collier_name}.pc ] && \
   {
      message -n "Checking COLLIER using local ${collier_name}.pc ... "
      COLLIERFLAGS=$(PKG_CONFIG_PATH=. pkg-config ${collier_name} --cflags)
      COLLIERLIBS="$ABSBASEDIR/src/loop_libraries/libcollier_wrapper.a $(PKG_CONFIG_PATH=. pkg-config ${collier_name} --libs)"
      enable_collier=yes
      message "ok"
      return
   }

   check_collier_incl
   check_collier_libs
}

#_____________________________________________________________________
check_looplibrary() {
   # applying "or" logic to old options
   # "no" by default, only --enable-looptools could make it "yes"
   if [ "$enable_looptools" = "yes" ]; then
      logmsg "Enabling LoopTools because of --enable-looptools flag."
   fi
   # "no" by default, only --enable-fflite could make it "yes"
   if [ "$enable_fflite" = "yes" ]; then
      logmsg "Enabling fflite because of --enable-fflite flag."
   fi

   LOOP_LIBRARIES="$(echo $LOOP_LIBRARIES | tr ',' ' ')"

   if contains "$LOOP_LIBRARIES" "looptools"; then enable_looptools="yes"; fi
   if contains "$LOOP_LIBRARIES" "collier"; then enable_collier="yes"; fi
   if contains "$LOOP_LIBRARIES" "fflite"; then enable_fflite="yes"; fi

   # interference of libraries can be destructive
   if [ "$enable_fflite" = "yes" ] && [ "$enable_looptools" = "yes" ]; then
      message "Error: Do not use fflite and LoopTools at the same time."
      exit 1
   fi
   if [ "$enable_fflite" = "yes" ] && [ "$enable_collier" = "yes" ]; then
      message "Error: Do not use fflite and COLLIER at the same time."
      exit 1
   fi

   local info_=""
   if [ "$enable_collier" = "yes" ]; then info_="COLLIER"
      if [ "$enable_looptools" = "yes" ]; then info_="$info_ and LoopTools are"
      else info_="$info_ is"
      fi
   elif [ "$enable_looptools" = "yes" ]; then info_="LoopTools is"
   fi
   if [ "$enable_collier" = "yes" ] || [ "$enable_looptools" = "yes" ]; then
      message "Note: $info_ thread-unsafe since there the renormalization"
      message "      scale is set via a global variable. This might"
      message "      lead to a race condition if different RGE solvers run in"
      message "      multiple threads. For such an application, consider usage of"
      message "      fflite. For now, multi-threading is disabled."
      enable_threads=no
   fi

   # now rules for libraries themselves
   if [ "$enable_collier" = "yes" ]; then
      check_collier
      LOOPFUNCFLAGS="$LOOPFUNCFLAGS $COLLIERFLAGS"
      LOOPFUNCLIBS="$LOOPFUNCLIBS $COLLIERLIBS"
   fi
   if [ "$enable_fflite" = "yes" ]; then
      LOOPFUNCLIBS="fflite/libfflite${MODULE_LIBEXT}"
   fi
   if [ "$enable_looptools" = "yes" ]; then
      check_looptools
      LOOPFUNCFLAGS="$LOOPFUNCFLAGS $LOOPTOOLSFLAGS"
      LOOPFUNCLIBS="$LOOPFUNCLIBS $LOOPTOOLSLIBS"
   fi

   # if any is present then the fortran_utils will be compiled
   if [ "$enable_collier" = "yes" ] || \
      [ "$enable_fflite" = "yes" ] || \
      [ "$enable_looptools" = "yes" ]; then
      FUTILIBS="$ABSBASEDIR/src/libfortran_utils.a"
   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_odeint() {
    check_header "boost/numeric/odeint.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/algebra/algebra_dispatcher.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/algebra/vector_space_algebra.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/external/eigen/eigen_resize.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/integrate/integrate_adaptive.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/stepper/generation.hpp" "$boost_inc_dir" \
                 "$default_inc_paths" && \
    check_header "boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp" "$boost_inc_dir" \
                 "$default_inc_paths"

    if test "x$found_hdr" = "x" ; then
        DEFINE_ENABLE_ODEINT="#undef ENABLE_ODEINT"
        logmsg "Disabling usage of odeint: ${DEFINE_ENABLE_ODEINT}"
    else
        DEFINE_ENABLE_ODEINT="#define ENABLE_ODEINT 1"
        logmsg "Enabling usage of odeint: ${DEFINE_ENABLE_ODEINT}"
    fi
}

#_____________________________________________________________________
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 -Wl,-rpath,$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_size() {
    local tsil_dir=$([ -n "$tsil_inc_dir" ] && echo "$tsil_inc_dir" || echo "$tsil_lib_dir")

    if [ -f "${tsil_dir}/Makefile" ] ; then
        local tsil_makefile="${tsil_dir}/Makefile"
        local tsil_size=$({ echo "first: ; @echo \$(TSIL_SIZE)"
                            cat "$tsil_makefile"
                          } | make -f - first
              )
        [ -n "$tsil_size" ] && CPPFLAGS="$CPPFLAGS $tsil_size"
    else
        message "Warning: Could not determine TSIL floating point type TSIL_SIZE."
        message "   TSIL's default will be assumed."
    fi

    return 0
}

#_____________________________________________________________________
check_tsil() {
    [ "x$enable_tsil" = "xno" ] && return

    local tsil_name=""

    [ -f TSIL.pc ] && tsil_name="TSIL"
    [ -f tsil.pc ] && tsil_name="tsil"

    [ -z "$tsil_inc_dir" ] && \
    [ -z "$tsil_lib_dir" ] && \
    type pkg-config > /dev/null && \
    [ -n ${tsil_name} ] && \
    [ -f ${tsil_name}.pc ] && \
    {
        message -n "Checking TSIL using local ${tsil_name}.pc ... "
        TSILFLAGS=$(PKG_CONFIG_PATH=. pkg-config ${tsil_name} --cflags)
        TSILLIBS=$(PKG_CONFIG_PATH=. pkg-config ${tsil_name} --libs)
        enable_tsil=yes
        message "ok"
        return
    }

    if check_tsil_incl && check_tsil_libs && check_tsil_size ; then
        enable_tsil=yes
    else
        if [ "x$enable_tsil" = xyes ] ; then
            message "Error: TSIL not found."
            exit 1
        fi
        enable_tsil=no
    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_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.  It is usually installed in "
        case "$operating_system" in
            Linux)  message "   /usr/local/Wolfram/Mathematica/" ;;
            Darwin) message "   /Applications/Mathematica.app/"  ;;
            CYGWIN_NT*) message "   /cygdrive/c/Program Files/Wolfram Research/Mathematica/" ;;
        esac
        message "   Alternatively, you can disable the meta code by using --disable-meta ."
        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 = 2;
  ];
Quit[error];
EOF

    checking_msg "Mathematica version >= ${required_mathematica_version}"
    echo "Get[\"${_math_info_check_progr}\"]" | "$MATH" > /dev/null 2>&1 &&
	_ok=true
    local _exit_status="$?"
    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
	if [ "$_exit_status" = 2 ]; then
	    result "not ok (version ${MATH_VERSION} for ${MATH_SYSTEMID} in ${MATH_INSTDIR})"
	else
	    result "not ok"
	fi
	MATH=""
	[ "${enable_meta}" = "yes" -o "$enable_librarylink" = "yes" ] || return

        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

    SARAH_MODEL_DIR=$(cat <<EOF | ("$MATH" 2> /dev/stdout 1> /dev/null)
If[Needs["SARAH\`"] === \$Failed || !ValueQ[\$sarahModelDir],
   Quit[1];
  ];
WriteString["stderr", \$sarahModelDir];
EOF
             )

    if [ -z "$SARAH_MODEL_DIR" ] ; then
        message "Error: Could not determine the SARAH model directory."
        message "   Please check that Mathematica and SARAH are installed correctly."
        message "   To do that, you may run \`${MATH}' and then copy and paste:\n"
        message "\
If[Needs[\"SARAH\`\"] === \$Failed,
   Print[\"SARAH could not be loaded.\"]; Quit[1],
   Print[\"SARAH successfully loaded.\"]; Quit[0]
  ];"
        exit 1
    fi
}

#_____________________________________________________________________
check_feynarts() {
    if test "x$enable_feynarts" = "xno"; then return; fi

    checking_msg "FeynArts installation"
    rm -f ${feynartsconfig}
    "$MATH" <<EOF > /dev/null
Needs["FeynArts\`"];
If[!MemberQ[\$Packages, "FeynArts\`"], Quit[1]];
If[Head[FeynArts\`\$FeynArts] === List,
    Export["${feynartsconfig}", StringJoin @@ Riffle[ToString /@ FeynArts\`\$FeynArts, "."], "String"],
    Export["${feynartsconfig}", FeynArts\`\$FeynArts, "String"]
  ];
Quit[0];
EOF
    local _feynarts_is_available="$?"
    if test "x${_feynarts_is_available}" = "x0" ; then
        if test -r "${feynartsconfig}" ; then
            FEYNARTS_VERSION=$(cat "${feynartsconfig}")

            if version_at_least $FEYNARTS_VERSION "${required_feynarts_version}"; then
                enable_feynarts="yes"
                result "ok (version ${FEYNARTS_VERSION})"
            elif test "x$enable_feynarts" = "xautomatic"; then
                enable_feynarts="no"
                result "ok (version ${FEYNARTS_VERSION} too old -- support disabled)"
            else
                result "not ok"
                message "Error: FeynArts version ${FEYNARTS_VERSION} no longer supported!"
                message "   Please use version ${required_feynarts_version} or higher."
                exit 1
            fi
        elif test "x$enable_feynarts" = "xautomatic"; then
            result "ok (unknown version -- support disabled)"
            enable_feynarts="no"
        else
            result "not ok"
            message "Error: Cannot not check FeynArts version."
            exit 1
        fi
    elif test "x$enable_feynarts" = "xautomatic"; then
        result "ok (not installed)"
        enable_feynarts="no"
    else
		    result "not ok"
        message "Error: FeynArts is not installed correctly."
        message "   Please make sure Needs[\"FeynArts\`\"] works correctly."
        exit 1
    fi
}

#_____________________________________________________________________
check_formcalc() {
    if test "x$enable_formcalc" = "xno"; then return; fi

    checking_msg "FormCalc installation"
    rm -f ${formcalcconfig}
    "$MATH" <<EOF > /dev/null
Needs["FormCalc\`"];
If[!MemberQ[\$Packages, "FormCalc\`"], Quit[1]];
If[Head[FormCalc\`\$FormCalc] === List,
    Export["${formcalcconfig}", StringJoin @@ Riffle[ToString /@ FormCalc\`\$FormCalc, "."], "String"],
    Export["${formcalcconfig}", FormCalc\`\$FormCalc, "String"]
  ];
Quit[0];
EOF
    local _formcalc_is_available="$?"
    if test "x${_formcalc_is_available}" = "x0" ; then
        if test -r "${formcalcconfig}" ; then
            FORMCALC_VERSION=$(cat "${formcalcconfig}")

            if version_at_least $FORMCALC_VERSION "${required_formcalc_version}"; then
                result "ok (version ${FORMCALC_VERSION})"
            elif test "x$enable_formcalc" = "xautomatic"; then
                enable_formcalc="no"
                result "ok (version ${FORMCALC_VERSION} too old -- support disabled)"
            else
                result "not ok"
                message "Error: FormCalc version ${FORMCALC_VERSION} no longer supported!"
                message "   Please use version ${required_formcalc_version} or higher."
                exit 1
            fi
        elif test "x$enable_formcalc" = "xautomatic"; then
            result "ok (unknown version -- support disabled)"
            enable_formcalc="no"
        else
            result "not ok"
            message "Error: Cannot check FormCalc version."
            exit 1
        fi
    elif test "x$enable_formcalc" = "xautomatic"; then
        result "ok (not installed)"
        enable_formcalc="no"
    else
		    result "not ok"
        message "Error: FormCalc is not installed correctly."
        message "   Please make sure Needs[\"FormCalc\`\"] works correctly."
        exit 1
    fi

    if test "x$enable_formcalc" != "xno"; then
        checking_msg "working FormCalc"

        if test "x$enable_feynarts" != "xyes"; then
            if test "x$enable_formcalc" = "xautomatic"; then
                enable_formcalc="no"
                result "no (disabled because FeynArts support is disabled)"
            else
                enable_formcalc="yes"
                result "yes (cannot perform test calculation because FeynArts support is disabled)"
            fi
        else
            "$MATH" <<EOF > /dev/null
Needs["FeynArts\`"];
Needs["FormCalc\`"];
SetDirectory[CreateDirectory[]];

topologies = FeynArts\`CreateTopologies[1, 1 -> 1];
diagrams = FeynArts\`InsertFields[topologies,
  {FeynArts\`S[1]} -> {FeynArts\`S[1]},
  FeynArts\`InsertionLevel -> FeynArts\`Particles,
  FeynArts\`Model -> "SM"
];
faFeynAmp = FeynArts\`CreateFeynAmp[diagrams];
fcFeynAmp = FormCalc\`CalcFeynAmp[faFeynAmp];

If[MatchQ[Head[fcFeynAmp], Amp[{{FeynArts\`S[1], __}} -> {{FeynArts\`S[1], __}}]],
  Quit[0]];
Quit[1];
EOF
            local _formcalc_is_working="$?"
            if test "x${_formcalc_is_working}" = "x0" ; then
                enable_formcalc="yes"
                result "yes (performed test calculation of S[1] -> S[1] in the SM)"
            elif test "x$enable_formcalc" = "xautomatic"; then
                enable_formcalc="no"
                result "no (test calculation of S[1] -> S[1] failed -- support disabled)"
            else
                result "no (unable to calculate S[1] -> S[1] in the SM)"
                message "Error: FormCalc is not working properly."
                exit 1
            fi
        fi
		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
}

#_____________________________________________________________________
mma_symbol_is() {
    local model_file="$1"
    local math_cmd="$2"
    local symbol="$3"
    local value="$4"

    [ -e "${model_file}" ] || {
        >&2 echo "Error: file \"${model_file}\" does not exist!"
        return 1
    }

    command -v "${math_cmd}" >/dev/null 2>&1 || {
        >&2 echo "Error: Mathematica kernel \"${math_cmd}\" is not executable!"
        return 1
    }

    [ -z "${symbol}" ] && {
        >&2 echo "Error: no symbol given!"
        return 1
    }

    [ -z "${value}" ] && {
        >&2 echo "Error: no value given!"
        return 1
    }

    echo "Get[\"${model_file}\"]; Quit[Boole[!(${symbol} === ${value})]]" | "${math_cmd}" > /dev/null 2>&1

    return $?
}

#_____________________________________________________________________
get_model_specific_corrections() {
    local model_file="$1"
    local math_cmd="${2:-math}"

    # always build SM, because it is needed for the effective couplings module
    local ho="SM"

    [ -e "${model_file}" ] || {
        >&2 echo "Error: file \"${model_file}\" does not exist!"
        echo "${ho}"
        return 1
    }

    command -v "${math_cmd}" >/dev/null 2>&1 || {
        >&2 echo "Error: Mathematica kernel \"${math_cmd}\" is not executable!"
        >&2 echo "   Please specify the Mathematica kernel as 2nd argument!"
        echo "${ho}"
        return 1
    }

    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs2LoopSM" "True"    && ho="${ho} SM"
    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs3LoopSM" "True"    && ho="${ho} SM"
    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs4LoopSM" "True"    && ho="${ho} SM"
    mma_symbol_is "$model_file" "$math_cmd" "UseSMAlphaS3Loop" "True"   && ho="${ho} SM"
    mma_symbol_is "$model_file" "$math_cmd" "UseSMAlphaS4Loop" "True"   && ho="${ho} SM"
    mma_symbol_is "$model_file" "$math_cmd" "FlexibleEFTHiggs" "True"   && ho="${ho} SM"
    mma_symbol_is "$model_file" "$math_cmd" "UseSMYukawa2Loop" "True"   && ho="${ho} SM_thresholds"

    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs2LoopMSSM" "True"  && ho="${ho} MSSM_higgs"
    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs3LoopMSSM" "True"  && ho="${ho} MSSM_higgs"
    mma_symbol_is "$model_file" "$math_cmd" "UseMSSMAlphaS2Loop" "True" && ho="${ho} MSSM_thresholds"
    mma_symbol_is "$model_file" "$math_cmd" "UseMSSMYukawa2Loop" "True" && ho="${ho} MSSM_thresholds"

    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs2LoopNMSSM" "True" && ho="${ho} MSSM_higgs NMSSM_higgs"

    mma_symbol_is "$model_file" "$math_cmd" "UseHiggs3LoopSplit" "True" && ho="${ho} SplitMSSM"

    ho=$(make_unique "${ho}")
    ho=$(string_trim "${ho}")
    echo "${ho}"
}

#_____________________________________________________________________
update_module_mk() {
    local name="$1"
    local mkfile="$2"
    local model_file="$3"
    local math_cmd="${4:-math}"

    [ -e "$model_file" ] || return
    { find "$mkfile" -newer "$model_file" | grep ^; } > /dev/null 2>&1 &&
	return

    message -n "   Updating model-specific modules in $mkfile ... "
    local ho="$(get_model_specific_corrections "$model_file" "$math_cmd")"
    sed -i -e "s|^\(MOD${name}_MOD[[:space:]]*:=\).*$|\1 $ho|" "$mkfile"
    message "($ho)"
    logmsg "   Depends on model-specific modules: ${ho}"
}

#_____________________________________________________________________
update_model_makefiles() {
    # If Mathematica is disabled, dependences on model-specific
    # modules should have been already resolved.
    [ "$enable_meta" != yes -o -z "${MATH}" ] && return

    message "Checking model makefiles"

    for m in ${MODELS}; do
        local model_name=$(echo ${m} | sed -e 's|models/||')
        local model_file="${m}/FlexibleSUSY.m"
	local mkfile="$m/module.mk"

	update_module_mk "$model_name" "$mkfile" "$model_file" "$MATH"
    done
}

#_____________________________________________________________________
enable_defines() {
    if test "x$enable_colors" = "xyes" ; then
        DEFINE_ENABLE_COLORS="#define ENABLE_COLORS 1"
        message "Enabling colored output"
        logmsg "   ${DEFINE_ENABLE_COLORS}"
    else
        DEFINE_ENABLE_COLORS="#undef ENABLE_COLORS"
        logmsg "Disabling colored output"
        logmsg "   ${DEFINE_ENABLE_COLORS}"
    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_gm2calc" = "xyes" ; then
        DEFINE_ENABLE_GM2CALC="#define ENABLE_GM2CALC 1"
        message "Enabling GM2Calc"
    else
        DEFINE_ENABLE_GM2CALC="#undef ENABLE_GM2CALC"
        message "Disabling GM2Calc"
    fi
    logmsg "   ${DEFINE_ENABLE_GM2CALC}"

    if test "x$enable_himalaya" = "xyes" ; then
        DEFINE_ENABLE_HIMALAYA="#define ENABLE_HIMALAYA 1"
        message "Enabling Himalaya"
    else
        DEFINE_ENABLE_HIMALAYA="#undef ENABLE_HIMALAYA"
        message "Disabling Himalaya"
    fi
    logmsg "   ${DEFINE_ENABLE_HIMALAYA}"

    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_looptools" = "xyes" ; then
        DEFINE_ENABLE_LOOPTOOLS="#define ENABLE_LOOPTOOLS 1"
        message "Enabling usage of LoopTools"
        logmsg "   ${DEFINE_ENABLE_LOOPTOOLS}"
    else
        enable_looptools="no"
        DEFINE_ENABLE_LOOPTOOLS="#undef ENABLE_LOOPTOOLS"
        logmsg "Disabling usage of LoopTools"
        logmsg "   ${DEFINE_ENABLE_LOOPTOOLS}"
    fi
    logmsg "   ${DEFINE_ENABLE_LOOPTOOLS}"

    if test "x$enable_collier" = "xyes" ; then
        DEFINE_ENABLE_COLLIER="#define ENABLE_COLLIER 1"
        message "Enabling usage of COLLIER"
        logmsg "   ${DEFINE_ENABLE_COLLIER}"
    else
        enable_collier="no"
        DEFINE_ENABLE_COLLIER="#undef ENABLE_COLLIER"
        logmsg "Disabling usage of COLLIER"
        logmsg "   ${DEFINE_ENABLE_COLLIER}"
    fi
    logmsg "   ${DEFINE_ENABLE_COLLIER}"

    if test "x$enable_silent" = "xyes" ; then
        DEFINE_ENABLE_SILENT="#define ENABLE_SILENT 1"
        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
}

#_____________________________________________________________________
add_metaflags() {
   local tlib_='FSLoopLibraries = { FSSOFTSUSY'
   local lib_="$tlib_"
   test $enable_looptools = 'yes' && lib_="${lib_}, FSLoopTools"
   test $enable_fflite = 'yes' && lib_="${lib_}, FSFFlite"
   test $enable_collier = 'yes' && lib_="${lib_}, FSCOLLIER"
   lib_="${lib_} };"

   local tfa_='FSFeynArtsAvailable = '
   local fa_="${tfa_}$(test $enable_feynarts = 'yes' && echo 'True' || echo 'False');"

   local tfc_='FSFormCalcAvailable = '
   local fc_="${tfc_}$(test $enable_formcalc = 'yes' && echo 'True' || echo 'False');"

   local c_=''
   local fs_=''
   for m in ${MODELS}; do
      fs_="${m}/FlexibleSUSY.m"

      [ ! -e "$fs_" ] && continue

      c_=$(grep "$tlib_" $fs_)
      if [ "$c_" != "$lib_" ]; then
         [ "$c_" != '' ] && sed -i "s/${tlib_}.*/${lib_}/g" $fs_ || echo "$lib_" >> $fs_
      fi

      c_=$(grep "$tfa_" $fs_)
      if [ "$c_" != "$fa_" ]; then
         [ "$c_" != '' ] && sed -i "s/${tfa_}.*/${fa_}/g" $fs_ || echo "$fa_" >> $fs_
      fi

      c_=$(grep "$tfc_" $fs_)
      if [ "$c_" != "$fc_" ]; then
         [ "$c_" != '' ] && sed -i "s/${tfc_}.*/${fc_}/g" $fs_ || echo "$fc_" >> $fs_
      fi

   done
}

#_____________________________________________________________________
replace_markers() {
	sed -e "s|@FLEXIBLESUSY_VERSION@|$FLEXIBLESUSY_VERSION|" \
   -e "s|@OPERATING_SYSTEM@|$operating_system|"     \
	-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|@SOLVERS@|$SOLVERS|"   \
	-e "s|@BOOSTTESTLIBS@|$BOOSTTESTLIBS|"     \
	-e "s|@BOOSTTHREADLIBS@|$BOOSTTHREADLIBS|"     \
	-e "s|@BOOSTFLAGS@|$BOOSTFLAGS|"   \
	-e "s|@THREADLIBS@|$THREADLIBS|"   \
	-e "s|@ENABLE_COLLIER@|$enable_collier|" \
	-e "s|@COLLIERFLAGS@|$COLLIERFLAGS|" \
	-e "s|@COLLIERLIBS@|$COLLIERLIBS|" \
	-e "s|@CPPFLAGS@|$CPPFLAGS|"       \
	-e "s|@CXXFLAGS@|$CXXFLAGS|"       \
	-e "s|@CXX@|$CXX|"                 \
	-e "s|@FC@|$FC|"                   \
	-e "s|@FFLAGS@|$FFLAGS|"           \
	-e "s|@FLIBS@|$FLIBS|"             \
	-e "s|@FUTILIBS@|$FUTILIBS|"       \
   -e "s|@FMOD@|$FMOD|"               \
   -e "s|@FSTD@|$FSTD|"   \
	-e "s|@FSCONFIG@|$FSCONFIG|"       \
	-e "s|@EIGENFLAGS@|$EIGENFLAGS|"   \
	-e "s|@GSLLIBS@|$GSLLIBS|"         \
	-e "s|@GSLFLAGS@|$GSLFLAGS|"       \
		-e "s|@LDFLAGS@|$LDFLAGS|"         \
		-e "s|@LDLIBS@|$LDLIBS|"           \
		-e "s|@LLFLAGS@|$LLFLAGS|"         \
		-e "s|@LLLIBS@|$LLLIBS|"           \
	-e "s|@ENABLE_COLORS@|$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_GM2CALC@|$enable_gm2calc|" \
	-e "s|@ENABLE_HIMALAYA@|$enable_himalaya|" \
	-e "s|@ENABLE_LIBRARYLINK@|$enable_librarylink|" \
	-e "s|@ENABLE_FEYNARTS@|$enable_feynarts|"        \
	-e "s|@ENABLE_FORMCALC@|$enable_formcalc|"        \
	-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|@GM2CALCLIBS@|$GM2CALCLIBS|"        \
        -e "s|@GM2CALCFLAGS@|$GM2CALCFLAGS|"      \
        -e "s|@HIMALAYALIBS@|$HIMALAYALIBS|"      \
        -e "s|@HIMALAYAFLAGS@|$HIMALAYAFLAGS|"    \
	-e "s|@LOOPFUNCLIBS@|$LOOPFUNCLIBS|"      \
	-e "s|@LOOPFUNCFLAGS@|$LOOPFUNCFLAGS|"    \
	-e "s|@ENABLE_LOOPTOOLS@|$enable_looptools|" \
	-e "s|@LOOPTOOLSLIBS@|$LOOPTOOLSLIBS|"    \
	-e "s|@LOOPTOOLSFLAGS@|$LOOPTOOLSFLAGS|"  \
	-e "s|@OPTIONAL_MODULES@|$OPTIONAL_MODULES|" \
	-e "s|@SARAH_DEP_GEN@|$SARAH_DEP_GEN|"    \
	-e "s|@SARAH_MODEL_DIR@|$SARAH_MODEL_DIR|" \
        -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)
  fflite            Use fflite to compute the loop functions (default: $enable_fflite)
  gm2calc           Enable GM2Calc (default: $enable_gm2calc)
  himalaya          Enable Himalaya (default: $enable_himalaya)
  librarylink       Build LibraryLink library for Mathematica interface (default: $enable_librarylink)
  looptools         Use LoopTools to compute the loop functions (default: $enable_looptools)
  mass-error-check  Check mass eigenvalue precision (default: $enable_mass_error_check)
EOF
# BEGIN: NOT EXPORTED ##########################################
cat <<EOF
  meta              Create model classes (default: $enable_meta)
EOF
# END:   NOT EXPORTED ##########################################
cat <<EOF
  shared-libs       Create shared libraries (default: $enable_shared_libs)
  silent            Suppress all command line output (default: $enable_silent)
  sqlite            Enable SQLite (default: $enable_sqlite)
  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)
  feynarts          Enable usage of FeynArts (default: automatic)
  formcalc          Enable usage of FormCalc (default: automatic)

Package directories, compilation settings and model selection

  --with-addons=            Comma separated list of addons to be build
                            (default: $ADDONS)
  --with-boost-libdir=      Path to search for BOOST libraries
  --with-boost-incdir=      Path to search for BOOST headers
  --with-cppflags           C preprocessor flags (default: $CPPFLAGS)
  --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-gm2calc-libdir=    Path to search for GM2Calc library
  --with-gm2calc-incdir=    Path to search for GM2Calc header
  --with-gsl-config=        Path to gsl-config (default: $gsl_config)
  --with-himalaya-libdir=   Path to search for Himalaya library
  --with-himalaya-incdir=   Path to search for Himalaya header
  --with-install-dir=       Path to source code installation directory
  --with-llflags=           Preprocessor flags for compiling with LibraryLink (default: $LLFLAGS)
  --with-lllibs=            Linker flags for linking LibraryLink libraries (default: $LLLIBS)
  --with-loop-libraries=    Comma separated list of loop libraries to be enabled
                            (for example \`collier', \`looptools', \`fflite')
  --with-looptools-libdir=  Path to search for LoopTools libraries
  --with-looptools-incdir=  Path to search for LoopTools headers
  --with-collier-libdir=    Path to search for COLLIER libraries
  --with-collier-incdir=    Path to search for COLLIER modules
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 "$*"
reset_default_static_linker_cmd

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-boost-libdir=*)   boost_lib_dir=$optarg ;;
            --with-boost-incdir=*)   boost_inc_dir=$optarg ;;
            --with-cppflags=*)       CPPFLAGS=$optarg ;;
            --with-cxx=*)            CXX=$optarg ;;
            --with-cxxflags=*)       CXXFLAGS=$optarg ;;
            --with-collier-libdir=*) collier_lib_dir=$optarg ;;
            --with-collier-incdir=*) collier_inc_dir=$optarg ;;
            --with-eigen-incdir=*)   eigen_inc_dir=$optarg ;;
            --with-fc=*)             FC=$optarg ;;
            --with-fflags=*)         FFLAGS=$optarg ;;
            --with-flibs=*)          FLIBS=$optarg ;;
            --with-gm2calc-incdir=*) gm2calc_inc_dir=$optarg ;;
            --with-gm2calc-libdir=*) gm2calc_lib_dir=$optarg ;;
            --with-gsl-config=*)     gsl_config=$optarg ;;
            --with-himalaya-incdir=*) himalaya_inc_dir=$optarg ;;
            --with-himalaya-libdir=*) himalaya_lib_dir=$optarg ;;
            --with-install-dir=*)    INSTALL_DIR=$optarg ;;
            --with-llflags=*)        LLFLAGS=$optarg ;;
            --with-lllibs=*)         LLLIBS=$optarg ;;
            --with-loop-libraries=*) LOOP_LIBRARIES=$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 for Mathematica if meta code generation is enabled or we
# compile with LibraryLink
if [ "$enable_meta" = yes -o \( "$enable_compile" = yes -a "$enable_librarylink" != no \) ]; then
    check_math_cmd
    check_mathematica_info
else
    MATH=""
fi

if test "x${enable_meta}" = "xyes"; then
    check_sarah
    case "$operating_system" in
	CYGWIN_NT*) check_cygpath ;;
    esac
    check_feynarts
    check_formcalc
else
    enable_feynarts=no
    enable_formcalc=no
fi

check_models
check_addons
check_optional_modules
# BEGIN: NOT EXPORTED ##########################################
update_model_makefiles
# END:   NOT EXPORTED ##########################################

if test "x${enable_compile}" = "xyes"; then
    check_required_libs
    check_multiarch
    check_cxx
    check_cxx_compiler_type
    check_cxx_compiler_version
    check_cxx_compiler_features
    check_cxxflags
    check_fc
    check_fflags
    check_fmod
    check_fstd
    check_linking
    check_librarylink
    check_boost
    check_eigen
    check_fortran_libs
    check_gsl_config
    check_gm2calc
    check_himalaya
    if use_solver "lattice"; then
        check_boost_thread_incl
        check_boost_thread_libs
    fi
    check_looplibrary
    check_odeint
    check_sqlite
    check_tsil
    check_static_lib_cmd
    check_shared_lib_cmd
    check_random_number_generator
    check_std_threads
    check_thread_libs
fi

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|@HIMALAYA_VERSION@|$HIMALAYA_VERSION|"     \
    -e "s|@PKGNAME@|$PROGRAM_NAME|"                  \
    -e "s|@BOOSTTESTLIBS@|$BOOSTTESTLIBS|"           \
    -e "s|@BOOSTTHREADLIBS@|$BOOSTTHREADLIBS|"       \
    -e "s|@BOOSTFLAGS@|$BOOSTFLAGS|"                 \
    -e "s|@THREADLIBS@|$THREADLIBS|"                 \
    -e "s|@COLLIERFLAGS@|$COLLIERFLAGS|"             \
    -e "s|@COLLIERLIBS@|$COLLIERLIBS|"               \
    -e "s|@CPPFLAGS@|$CPPFLAGS|"                     \
    -e "s|@CXX@|$CXX|"                               \
    -e "s|@CXXFLAGS@|$CXXFLAGS|"                     \
    -e "s|@EIGENFLAGS@|$EIGENFLAGS|"                 \
    -e "s|@FC@|$FC|"                                 \
    -e "s|@FFLAGS@|$FFLAGS|"                         \
    -e "s|@FLIBS@|$FLIBS|"                           \
    -e "s|@FMOD@|$FMOD|"                             \
    -e "s|@FSTD@|$FSTD|"                             \
    -e "s|@FUTILIBS@|$FUTILIBS|"                     \
    -e "s|@GSLLIBS@|$GSLLIBS|"                       \
    -e "s|@GSLFLAGS@|$GSLFLAGS|"                     \
    -e "s|@GM2CALCLIBS@|$GM2CALCLIBS|"               \
    -e "s|@GM2CALCFLAGS@|$GM2CALCFLAGS|"             \
    -e "s|@HIMALAYALIBS@|$HIMALAYALIBS|"             \
    -e "s|@HIMALAYAFLAGS@|$HIMALAYAFLAGS|"           \
    -e "s|@LDFLAGS@|$LDFLAGS|"                       \
    -e "s|@LDLIBS@|$LDLIBS|"                         \
    -e "s|@LLFLAGS@|$LLFLAGS|"                       \
    -e "s|@LLLIBS@|$LLLIBS|"                         \
    -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_COLORS@|$DEFINE_ENABLE_COLORS|" \
    -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_GM2CALC@|$DEFINE_ENABLE_GM2CALC|" \
    -e "s|@DEFINE_ENABLE_HIMALAYA@|$DEFINE_ENABLE_HIMALAYA|" \
    -e "s|@DEFINE_ENABLE_LIBRARYLINK@|$DEFINE_ENABLE_LIBRARYLINK|" \
    -e "s|@DEFINE_ENABLE_LOOPTOOLS@|$DEFINE_ENABLE_LOOPTOOLS|" \
    -e "s|@DEFINE_ENABLE_COLLIER@|$DEFINE_ENABLE_COLLIER|" \
    -e "s|@DEFINE_ENABLE_RANDOM@|$DEFINE_ENABLE_RANDOM|"       \
    -e "s|@DEFINE_ENABLE_SILENT@|$DEFINE_ENABLE_SILENT|"       \
    -e "s|@DEFINE_ENABLE_ODEINT@|$DEFINE_ENABLE_ODEINT|"       \
    -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|"       \
    -e 's|@n@|\
|g' \
    < $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|"    \
    < $DOC_MAINPAGE_TMPL > $DOC_MAINPAGE

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

if test "x${enable_meta}" = "xyes"; then
    add_metaflags
fi

rm -f ${CONFIGDIR}/version
echo "$FLEXIBLESUSY_VERSION" > ${CONFIGDIR}/flexiblesusy-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