@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/mklove/modules/configure.base

@@ -0,0 +1,2484 @@
+#!/bin/bash
+#
+#
+# mklove base configure module, implements the mklove configure framework
+#
+
+MKL_MODULES="base"
+MKL_CACHEVARS="CFLAGS LDFLAGS PKG_CONFIG_PATH"
+MKL_MKVARS=""
+MKL_DEFINES=""
+MKL_CHECKS=""
+MKL_LOAD_STACK=""
+
+MKL_IDNEXT=1
+
+# Default mklove directory to PWD/mklove
+[[ -z "$MKLOVE_DIR" ]] && MKLOVE_DIR="$PWD/mklove"
+
+MKL_OUTMK="$PWD/_mklout.mk"
+MKL_OUTH="$PWD/_mklout.h"
+MKL_OUTDBG="$PWD/config.log"
+
+MKL_GENERATORS="base:mkl_generate_late_vars"
+MKL_CLEANERS=""
+
+MKL_FAILS=""
+MKL_LATE_VARS=""
+
+MKL_OPTS_SET=""
+
+MKL_RED=""
+MKL_GREEN=""
+MKL_YELLOW=""
+MKL_BLUE=""
+MKL_CLR_RESET=""
+
+
+MKL_NO_DOWNLOAD=0
+MKL_INSTALL_DEPS=n
+MKL_SOURCE_DEPS_ONLY=n
+
+MKL_DESTDIR_ADDED=n
+
+if [[ -z "$MKL_REPO_URL" ]]; then
+    MKL_REPO_URL="http://github.com/edenhill/mklove/raw/master"
+fi
+
+
+
+###########################################################################
+#
+# Variable types:
+#   env      - Standard environment variables.
+#   var      - mklove runtime variable, cached or not.
+#   mkvar    - Makefile variables, also sets runvar
+#   define   - config.h variables/defines
+#
+###########################################################################
+
+# Low level variable assignment
+# Arguments:
+#  variable name
+#  variable value
+function mkl_var0_set {
+    export "$1"="$2"
+}
+
+# Sets a runtime variable (only used during configure)
+# If "cache" is provided these variables are cached to config.cache.
+# Arguments:
+#  variable name
+#  variable value
+#  [ "cache" ]
+function mkl_var_set {
+    mkl_var0_set "$1" "$2"
+    if [[ $3 == "cache" ]]; then
+        if ! mkl_in_list "$MKL_CACHEVARS" "$1" ; then
+            MKL_CACHEVARS="$MKL_CACHEVARS $1"
+        fi
+    fi
+}
+
+# Unsets a mkl variable
+# Arguments:
+#  variable name
+function mkl_var_unset {
+    unset $1
+}
+
+# Appends to a mkl variable (space delimited)
+# Arguments:
+#  variable name
+#  variable value
+function mkl_var_append {
+    if [[ -z ${!1} ]]; then
+        mkl_var_set "$1" "$2"
+    else
+        mkl_var0_set "$1" "${!1} $2"
+    fi
+}
+
+
+# Prepends to a mkl variable (space delimited)
+# Arguments:
+#  variable name
+#  variable value
+function mkl_var_prepend {
+    if [[ -z ${!1} ]]; then
+        mkl_var_set "$1" "$2"
+    else
+        mkl_var0_set "$1" "$2 ${!1}"
+    fi
+}
+
+# Shift the first word off a variable.
+# Arguments:
+#  variable name
+function mkl_var_shift {
+    local n="${!1}"
+    mkl_var0_set "$1" "${n#* }"
+    return 0
+}
+
+
+# Returns the contents of mkl variable
+# Arguments:
+#  variable name
+function mkl_var_get {
+    echo "${!1}"
+}
+
+
+
+
+# Set environment variable (runtime)
+# These variables are not cached nor written to any of the output files,
+# its just simply a helper wrapper for standard envs.
+# Arguments:
+#  varname
+#  varvalue
+function mkl_env_set {
+    mkl_var0_set "$1" "$2"
+}
+
+# Append to environment variable
+# Arguments:
+#  varname
+#  varvalue
+#  [ separator (" ") ]
+function mkl_env_append {
+    local sep=" "
+    if [[ -z ${!1} ]]; then
+        mkl_env_set "$1" "$2"
+    else
+        [ ! -z ${3} ] && sep="$3"
+        mkl_var0_set "$1" "${!1}${sep}$2"
+    fi
+
+}
+
+# Prepend to environment variable
+# Arguments:
+#  varname
+#  varvalue
+#  [ separator (" ") ]
+function mkl_env_prepend {
+    local sep=" "
+    if [[ -z ${!1} ]]; then
+        mkl_env_set "$1" "$2"
+    else
+        [ ! -z ${3} ] && sep="$3"
+        mkl_var0_set "$1" "$2${sep}${!1}"
+    fi
+
+}
+
+
+
+
+# Set a make variable (Makefile.config)
+# Arguments:
+#  config name
+#  variable name
+#  value
+function mkl_mkvar_set {
+    if [[ ! -z $2 ]]; then
+        mkl_env_set "$2" "$3"
+        mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2
+    fi
+}
+
+
+# Prepends to a make variable (Makefile.config)
+# Arguments:
+#  config name
+#  variable name
+#  value
+#  [ separator (" ") ]
+function mkl_mkvar_prepend {
+    if [[ ! -z $2 ]]; then
+        mkl_env_prepend "$2" "$3" "$4"
+        mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2
+    fi
+}
+
+
+# Appends to a make variable (Makefile.config)
+# Arguments:
+#  config name
+#  variable name
+#  value
+#  [ separator (" ") ]
+function mkl_mkvar_append {
+    if [[ ! -z $2 ]]; then
+        mkl_env_append "$2" "$3" "$4"
+        mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2
+    fi
+}
+
+
+# Prepends to a make variable (Makefile.config)
+# Arguments:
+#  config name
+#  variable name
+#  value
+#  [ separator (" ") ]
+function mkl_mkvar_prepend {
+    if [[ ! -z $2 ]]; then
+        mkl_env_prepend "$2" "$3" "$4"
+        mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2
+    fi
+}
+
+# Return mkvar variable value
+# Arguments:
+#  variable name
+function mkl_mkvar_get {
+    [[ -z ${!1} ]] && return 1
+    echo ${!1}
+    return 0
+}
+
+
+
+# Defines a config header define (config.h)
+# Arguments:
+#  config name
+#  define name
+#  define value (optional, default: 1)
+#   if value starts with code: then no "" are added
+function mkl_define_set {
+
+    if [[ -z $2 ]]; then
+        return 0
+    fi
+
+    local stmt=""
+    local defid=
+    if [[ $2 = *\(* ]]; then
+        # macro
+        defid="def_${2%%(*}"
+    else
+        # define
+        defid="def_$2"
+    fi
+
+    [[ -z $1 ]] || stmt="// $1\n"
+
+    local val="$3"
+    if [[ -z "$val" ]]; then
+        val="$(mkl_def $2 1)"
+    fi
+
+    # Define as code, string or integer?
+    if [[ $val == code:* ]]; then
+        # Code block, copy verbatim without quotes, strip code: prefix
+        val=${val#code:}
+    elif [[ ! ( "$val" =~ ^[0-9]+([lL]?[lL][dDuU]?)?$ || \
+        "$val" =~ ^0x[0-9a-fA-F]+([lL]?[lL][dDuU]?)?$ ) ]]; then
+        # String: quote
+        val="\"$val\""
+    fi
+    # else: unquoted integer/hex
+
+    stmt="${stmt}#define $2 $val"
+    mkl_env_set "$defid" "$stmt"
+    mkl_env_append MKL_DEFINES "$defid"
+}
+
+
+
+
+
+# Sets "all" configuration variables, that is:
+# for name set: Makefile variable, config.h define
+# Will convert value "y"|"n" to 1|0 for config.h
+# Arguments:
+#  config name
+#  variable name
+#  value
+function mkl_allvar_set {
+    mkl_mkvar_set "$1" "$2" "$3"
+    local val=$3
+    if [[ $3 = "y" ]]; then
+        val=1
+    elif [[ $3 = "n" ]]; then
+        val=0
+    fi
+    mkl_define_set "$1" "$2" "$val"
+}
+
+
+###########################################################################
+#
+# Dependency installation, et.al.
+#
+#
+###########################################################################
+
+# Returns the local dependency directory.
+function mkl_depdir {
+    local dir="$MKLOVE_DIR/deps"
+    [[ -d $dir ]] || mkdir -p "$dir"
+    if ! grep -q ^deps$ "$MKLOVE_DIR/.gitignore" 2>/dev/null ; then
+        echo "deps" >> "$MKLOVE_DIR/.gitignore"
+    fi
+
+    echo "$dir"
+}
+
+# Returns the package's installation directory / DESTDIR.
+function mkl_dep_destdir {
+    echo "$(mkl_depdir)/dest"
+}
+
+# Returns the package's source directory.
+function mkl_dep_srcdir {
+    echo "$(mkl_depdir)/src/$1"
+}
+
+
+# Get the static library file name(s) for a package.
+function mkl_lib_static_fnames {
+    local name=$1
+    mkl_meta_get $name "static" ""
+}
+
+
+# Returns true if previous ./configure ran a dep install for this package.
+function mkl_dep_install_cached {
+    local name=$1
+
+    if [[ -n $(mkl_var_get "MKL_STATUS_${1}_INSTALL") ]] ||
+           [[ -n $(mkl_var_get "MKL_STATUS_${1}_INSTALL_SRC") ]]; then
+        return 0 # true
+    else
+        return 1 # false
+    fi
+}
+
+# Install an external dependency using the platform's native
+# package manager.
+# Should only be called from mkl_dep_install
+#
+# Param 1: config name
+function mkl_dep_install_pkg {
+    local name=$1
+    local iname="${name}_INSTALL"
+    local retcode=1  # default to fail
+    local method="none"
+    local pkgs
+    local cmd
+
+    mkl_dbg "Attempting native install of dependency $name on $MKL_DISTRO with effective user $EUID"
+
+
+    # Try the platform specific installer first.
+    case ${MKL_DISTRO}-${EUID} in
+        debian-0|ubuntu-0)
+            method=apt
+            pkgs=$(mkl_meta_get $name deb)
+            cmd="apt install -y $pkgs"
+            ;;
+
+        centos-0|rhel-0|redhat-0|fedora-0)
+            method=yum
+            pkgs=$(mkl_meta_get $name rpm)
+            cmd="yum install -y $pkgs"
+            ;;
+
+        alpine-0)
+            method=apk
+            pkgs=$(mkl_meta_get $name apk)
+            cmd="apk add $pkgs"
+            ;;
+
+        osx-*)
+            method=brew
+            pkgs=$(mkl_meta_get $name brew)
+            cmd="brew install $pkgs"
+            ;;
+
+        *)
+            mkl_dbg "$name: No native installer set for $name on $MKL_DISTRO (euid $EUID)"
+            return 1
+            ;;
+    esac
+
+    if [[ -z $pkgs ]]; then
+        mkl_dbg "$name: No packages to install ($method)"
+        return 1
+    fi
+
+    mkl_check_begin --verb "installing dependencies ($cmd)" $iname "" no-cache "$name"
+    $cmd >>$MKL_OUTDBG 2>&1
+    retcode=$?
+
+    if [[ $retcode -eq 0 ]]; then
+        mkl_dbg "Native install of $name (using $method, $cmd) succeeded"
+        mkl_check_done "$iname" "" cont "using $method"
+        mkl_meta_set $name installed_with "$method"
+    elif [[ $method != "none" ]]; then
+        mkl_dbg "Native install of $name (using $method, $cmd) failed: retcode $retcode"
+        mkl_check_failed "$iname" "" cont "using $method"
+    fi
+
+    return $retcode
+}
+
+
+# Returns 0 (yes) if this dependency has a source builder, else 1 (no)
+function mkl_dep_has_builder {
+    local name=$1
+    local func="${name}_install_source"
+    mkl_func_exists $func
+}
+
+
+# Returns 0 (yes) if this dependency has a package installer, else 1 (no)
+function mkl_dep_has_installer {
+    local name=$1
+    if mkl_dep_has_builder "$name" || \
+            [[ -n $(mkl_meta_get $name deb) ]] || \
+            [[ -n $(mkl_meta_get $name rpm) ]] || \
+            [[ -n $(mkl_meta_get $name brew) ]] || \
+            [[ -n $(mkl_meta_get $name apk) ]]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+
+# Install an external dependency from source.
+#
+# The resulting libraries must be installed in $ddir/usr/lib (or lib64),
+# and include files in $ddir/usr/include.
+#
+# Any dependency installed from source will be linked statically
+# regardless of --enable-static, if the build produced static libraries.
+
+#
+# Param 1: config name
+function mkl_dep_install_source {
+    local name=$1
+    local iname="${name}_INSTALL_SRC"
+    local retcode=
+
+    local func="${name}_install_source"
+
+    if ! mkl_dep_has_builder $name ; then
+        mkl_dbg "No source builder for $name ($func) available"
+        return 1
+    fi
+
+    mkl_check_begin --verb "building dependency" $iname "" no-cache "$name"
+
+    # Create install directory / DESTDIR
+    local ddir=$(mkl_dep_destdir $name)
+    [[ -d $ddir ]] || mkdir -p "$ddir"
+
+    # Create and go to source directory
+    local sdir=$(mkl_dep_srcdir $name)
+    [[ -d $sdir ]] || mkdir -p "$sdir"
+    mkl_pushd "$sdir"
+
+    local ilog="${sdir}/_mkl_install.log"
+
+    # Build and install
+    mkl_dbg "Building $name from source in $sdir (func $func)"
+
+    libdir="/usr/lib" $func $name "$ddir" >$ilog 2>&1
+    retcode=$?
+
+    mkl_popd # $sdir
+
+    if [[ $retcode -eq 0 ]]; then
+        mkl_dbg "Source install of $name succeeded"
+        mkl_check_done "$iname" "" cont "ok" "from source"
+        mkl_meta_set $name installed_with "source"
+    else
+        mkl_dbg "Source install of $name failed"
+        mkl_check_failed "$iname" "" disable "source installer failed (see $ilog)"
+        mkl_err "$name source build failed, see $ilog for details. First 50 and last 50 lines:"
+        head -50 "$ilog"
+        echo " .... and last 50 lines ...."
+        tail -50 "$ilog"
+    fi
+
+    return $retcode
+}
+
+
+# Tries to resolve/find full paths to static libraries for a module,
+# using the provided scan dir path.
+# Any found libraries are set as STATIC_LIB_.. defines.
+#
+# Param 1: config name
+# Param 2: scandir
+#
+# Returns 0 if libraries were found, else 1.
+function mkl_resolve_static_libs {
+    local name="$1"
+    local scandir="$2"
+    local stlibfnames=$(mkl_lib_static_fnames $name)
+    local stlibvar="STATIC_LIB_${name}"
+
+    if [[ -z $stlibfnames || -n "${!stlibvar}" ]]; then
+        mkl_dbg "$name: not resolving static libraries (stlibfnames=$stlibfnames, $stlibvar=${!stlibvar})"
+        mkl_allvar_set "$name" "WITH_STATIC_LIB_$name" y
+        return 1
+    fi
+
+    local fname=
+    local stlibs=""
+    mkl_dbg "$name: resolving static libraries from $stlibfnames in $scandir"
+    for fname in $stlibfnames ; do
+        local stlib=$(find "${scandir}" -name "$fname" 2>/dev/null | head -1)
+        if [[ -n $stlib ]]; then
+            stlibs="${stlibs} $stlib"
+        fi
+    done
+
+    # Trim leading whitespaces
+    stlibs=${stlibs# }
+
+    if [[ -n $stlibs ]]; then
+        mkl_dbg "$name: $stlibvar: found static libs: $stlibs"
+        mkl_var_set $stlibvar "$stlibs" "cache"
+        mkl_allvar_set "$name" "WITH_STATIC_LIB_$name" y
+        return 0
+    else
+        mkl_dbg "$name: did not find any static libraries for $stlibfnames in ${scandir}"
+        return 1
+    fi
+}
+
+
+# Install an external dependecy
+#
+# Param 1: config name  (e.g zstd)
+function mkl_dep_install {
+    local name=$1
+    local retcode=
+
+    local ddir=$(mkl_dep_destdir $name)
+
+    if [[ $MKL_SOURCE_DEPS_ONLY != y ]] || ! mkl_dep_has_builder $name ; then
+        #
+        # Try native package manager first, or if no source builder
+        # is available for this dependency.
+        #
+        mkl_dep_install_pkg $name
+        retcode=$?
+
+        if [[ $retcode -eq 0 ]]; then
+            return $retcode
+        fi
+    fi
+
+    #
+    # Try source installer.
+    #
+    mkl_dep_install_source $name
+    retcode=$?
+
+    if [[ $retcode -ne 0 ]]; then
+        if [[ $MKL_SOURCE_DEPS_ONLY == y ]]; then
+            # Require dependencies, regardless of original action,
+            # if --source-deps-only is specified, to ensure
+            # that we do indeed link with the desired library.
+            mkl_fail "$name" "" fail "Failed to install dependency $name"
+        fi
+        return $retcode
+    fi
+
+    local ddir=$(mkl_dep_destdir $name)
+
+    # Find the static library(s), if any.
+    if ! mkl_resolve_static_libs "$name" "${ddir}/usr"; then
+        # No static libraries found, set up dynamic linker path
+        mkl_mkvar_prepend LDFLAGS LDFLAGS "-L${ddir}/usr/lib64 -L${ddir}/usr/lib"
+    fi
+
+    # Add the deps destdir to various build flags so that tools can pick
+    # up the artifacts (.pc files, includes, libs, etc) they need.
+    if [[ $MKL_DESTDIR_ADDED == n ]]; then
+	# Add environment variables so that later built dependencies
+	# can find this one.
+	mkl_env_prepend LDFLAGS "-L${ddir}/usr/lib64 -L${ddir}/usr/lib"
+	mkl_env_prepend CPPFLAGS "-I${ddir}/usr/include"
+        mkl_env_prepend PKG_CONFIG_PATH "${ddir}/usr/lib/pkgconfig" ":"
+        # And tell pkg-config to get static linker flags.
+	mkl_env_set PKG_CONFIG "${PKG_CONFIG} --static"
+	MKL_DESTDIR_ADDED=y
+    fi
+
+    # Append the package's install path to compiler and linker flags.
+    mkl_dbg "$name: Adding install-deps paths ($ddir) to compiler and linker flags"
+    mkl_mkvar_prepend CPPFLAGS CPPFLAGS "-I${ddir}/usr/include"
+
+    return $retcode
+}
+
+
+# Apply patch to a source dependency.
+#
+# Param 1: config name (e.g. libssl)
+# Param 2: patch number (optional, else all)
+#
+# Returns 0 on success or 1 on error.
+function mkl_patch {
+    local name=$1
+    local patchnr="$2"
+
+    if [[ -z $patchnr ]]; then
+        patchnr="????"
+    fi
+
+    local patchfile=
+    local cnt=0
+    for patchfile in $(echo ${MKLOVE_DIR}/modules/patches/${name}.${patchnr}-*.patch | sort); do
+        mkl_dbg "$1: applying patch $patchfile"
+        patch -p1 < $patchfile
+        local retcode=$?
+        if [[ $retcode != 0 ]]; then
+            mkl_err "mkl_patch: $1: failed to apply patch $patchfile: see source dep build log for details"
+            return 1
+        fi
+        cnt=$(($cnt + 1))
+    done
+
+    if [[ $cnt -lt 1 ]]; then
+        mkl_err "mkl_patch: $1: no patches matchign $patchnr found"
+        return 1
+    fi
+
+    return 0
+}
+
+
+###########################################################################
+#
+#
+# Check failure functionality
+#
+#
+###########################################################################
+
+
+# Summarize all fatal failures and then exits.
+function mkl_fail_summary {
+    echo "
+
+"
+
+    local pkg_cmd=""
+    local install_pkgs=""
+    mkl_err "###########################################################"
+    mkl_err "###                  Configure failed                   ###"
+    mkl_err "###########################################################"
+    mkl_err "### Accumulated failures:                               ###"
+    mkl_err "###########################################################"
+    local n
+    for n in $MKL_FAILS ; do
+        local conf=$(mkl_var_get MKL_FAIL__${n}__conf)
+        mkl_err  " $conf ($(mkl_var_get MKL_FAIL__${n}__define)) $(mkl_meta_get $conf name)"
+        if mkl_meta_exists $conf desc; then
+            mkl_err0 "      desc: $MKL_YELLOW$(mkl_meta_get $conf desc)$MKL_CLR_RESET"
+        fi
+        mkl_err0 "    module: $(mkl_var_get MKL_FAIL__${n}__module)"
+        mkl_err0 "    action: $(mkl_var_get MKL_FAIL__${n}__action)"
+        mkl_err0 "    reason:
+$(mkl_var_get MKL_FAIL__${n}__reason)
+"
+        # Dig up some metadata to assist the user
+        case $MKL_DISTRO in
+            debian|ubuntu)
+                local debs=$(mkl_meta_get $conf "deb")
+                pkg_cmd="sudo apt install -y"
+                if [[ ${#debs} > 0 ]]; then
+                    install_pkgs="$install_pkgs $debs"
+                fi
+                ;;
+            centos|rhel|redhat|fedora)
+                local rpms=$(mkl_meta_get $conf "rpm")
+                pkg_cmd="sudo yum install -y"
+                if [[ ${#rpms} > 0 ]]; then
+                    install_pkgs="$install_pkgs $rpms"
+                fi
+                ;;
+            alpine)
+                local apks=$(mkl_meta_get $conf "apk")
+                pkg_cmd="apk add "
+                if [[ ${#apks} > 0 ]]; then
+                    install_pkgs="$install_pkgs $apks"
+                fi
+                ;;
+            osx)
+                local pkgs=$(mkl_meta_get $conf "brew")
+                pkg_cmd="brew install"
+                if [[ ${#pkgs} > 0 ]]; then
+                    install_pkgs="$install_pkgs $pkgs"
+                fi
+                ;;
+        esac
+    done
+
+    if [[ ! -z $install_pkgs ]]; then
+        mkl_err "###########################################################"
+        mkl_err "### Installing the following packages might help:       ###"
+        mkl_err "###########################################################"
+        mkl_err0 "$pkg_cmd $install_pkgs"
+        mkl_err0 ""
+    fi
+    exit 1
+}
+
+
+# Checks if there were failures.
+# Returns 0 if there were no failures, else calls failure summary and exits.
+function mkl_check_fails {
+    if [[ ${#MKL_FAILS} = 0 ]]; then
+        return 0
+    fi
+    mkl_fail_summary
+}
+
+# A check has failed but we want to carry on (and we should!).
+# We fail it all later.
+# Arguments:
+#  config name
+#  define name
+#  action
+#  reason
+function mkl_fail {
+    local n="$(mkl_env_esc "$1")"
+    mkl_var_set "MKL_FAIL__${n}__conf" "$1"
+    mkl_var_set "MKL_FAIL__${n}__module" $MKL_MODULE
+    mkl_var_set "MKL_FAIL__${n}__define" $2
+    mkl_var_set "MKL_FAIL__${n}__action" "$3"
+    if [[ -z $(mkl_var_get "MKL_FAIL__${n}__reason") ]]; then
+        mkl_var_set "MKL_FAIL__${n}__reason" "$4"
+    else
+        mkl_var_append "MKL_FAIL__${n}__reason" "
+And also:
+$4"
+    fi
+    mkl_in_list "$MKL_FAILS" "$n" || mkl_var_append MKL_FAILS "$n"
+}
+
+
+# A check failed, handle it
+# Arguments:
+#  config name
+#  define name
+#  action (fail|disable|ignore|cont)
+#  reason
+function mkl_check_failed {
+    # Override action based on require directives, unless the action is
+    # set to cont (for fallthrough to sub-sequent tests).
+    local action="$3"
+    if [[ $3 != "cont" ]]; then
+        action=$(mkl_meta_get "MOD__$MKL_MODULE" "override_action" $3)
+    fi
+
+    # --fail-fatal option
+    [[ $MKL_FAILFATAL ]] && action="fail"
+
+    mkl_check_done "$1" "$2" "$action" "failed"
+    mkl_dbg "Check $1 ($2, action $action (originally $3)) failed: $4"
+
+
+    case $action in
+        fail)
+            # Check failed fatally, fail everything eventually
+            mkl_fail "$1" "$2" "$3" "$4"
+            return 1
+            ;;
+
+        disable)
+            # Check failed, disable
+            [[ ! -z $2 ]] && mkl_mkvar_set "$1" "$2" "n"
+            return 1
+            ;;
+        ignore)
+            # Check failed but we ignore the results and set it anyway.
+            [[ ! -z $2 ]] && mkl_define_set "$1" "$2" "1"
+            [[ ! -z $2 ]] && mkl_mkvar_set "$1" "$2" "y"
+            return 1
+            ;;
+        cont)
+            # Check failed but we ignore the results and do nothing.
+            return 0
+            ;;
+    esac
+}
+
+
+
+
+###########################################################################
+#
+#
+# Output generators
+#
+#
+###########################################################################
+
+# Generate late variables.
+# Late variables are those referenced in command line option defaults
+# but then never set by --option.
+function mkl_generate_late_vars {
+    local n
+    for n in $MKL_LATE_VARS ; do
+        local func=${n%:*}
+        local safeopt=${func#opt_}
+        local val=${n#*:}
+        if mkl_in_list "$MKL_OPTS_SET" "$safeopt" ; then
+            # Skip options set explicitly with --option
+            continue
+        fi
+        # Expand variable references "\$foo" by calling eval
+        # and pass it opt_... function.
+        $func "$(eval echo $val)"
+    done
+}
+
+
+# Generate MKL_DYNAMIC_LIBS and MKL_STATIC_LIBS for Makefile.config
+#
+# Params: $LIBS
+function mkl_generate_libs {
+    while [[ $# -gt 0 ]]; do
+        if [[ $1 == -l* ]]; then
+            mkl_mkvar_append "" MKL_DYNAMIC_LIBS $1
+        elif [[ $1 == *.a ]]; then
+            mkl_mkvar_append "" MKL_STATIC_LIBS $1
+        elif [[ $1 == -framework ]]; then
+            mkl_mkvar_append "" MKL_DYNAMIC_LIBS "$1 $2"
+            shift # two args
+        else
+            mkl_dbg "Ignoring arg $1 from LIBS while building STATIC and DYNAMIC lists"
+        fi
+        shift # remove arg
+    done
+}
+
+# Generate output files.
+# Must be called following a succesful configure run.
+function mkl_generate {
+
+    # Generate MKL_STATIC_LIBS and MKL_DYNAMIC_LIBS from LIBS
+    mkl_generate_libs $LIBS
+
+    local mf=
+    for mf in $MKL_GENERATORS ; do
+        MKL_MODULE=${mf%:*}
+        local func=${mf#*:}
+        $func || exit 1
+    done
+
+    # Generate a built-in options define based on WITH_..=y
+    local with_y=
+    for n in $MKL_MKVARS ; do
+        if [[ $n == WITH_* ]] && [[ $n != WITH_STATIC_LIB_* ]] && [[ ${!n} == y ]]; then
+            with_y="$with_y ${n#WITH_}"
+        fi
+    done
+    with_y="${with_y# }"
+
+    mkl_allvar_set "BUILT_WITH" "BUILT_WITH" "$with_y"
+
+    mkl_write_mk "# Automatically generated by $0 $*"
+    mkl_write_mk "# Config variables"
+    mkl_write_mk "#"
+    mkl_write_mk "# Generated by:"
+    mkl_write_mk "# $MKL_CONFIGURE_ARGS"
+    mkl_write_mk ""
+
+    # This variable is used by Makefile.base to avoid multiple inclusions.
+    mkl_write_mk "MKL_MAKEFILE_CONFIG=y"
+
+    # Export colors to Makefile.config
+    mkl_write_mk "MKL_RED=\t${MKL_RED}"
+    mkl_write_mk "MKL_GREEN=\t${MKL_GREEN}"
+    mkl_write_mk "MKL_YELLOW=\t${MKL_YELLOW}"
+    mkl_write_mk "MKL_BLUE=\t${MKL_BLUE}"
+    mkl_write_mk "MKL_CLR_RESET=\t${MKL_CLR_RESET}"
+
+    local n=
+    for n in $MKL_MKVARS ; do
+	# Some special variables should be prefixable by the caller, so
+	# define them in the makefile as appends.
+	local op="="
+	case $n in
+	    CFLAGS|CPPFLAGS|CXXFLAGS|LDFLAGS|LIBS)
+		op="+="
+		;;
+	esac
+        mkl_write_mk "$n$op\t${!n}"
+    done
+    mkl_write_mk "# End of config variables"
+
+    MKL_OUTMK_FINAL=Makefile.config
+    mv $MKL_OUTMK $MKL_OUTMK_FINAL
+
+    echo "Generated $MKL_OUTMK_FINAL"
+
+    # Generate config.h
+    mkl_write_h "// Automatically generated by $0 $*"
+    mkl_write_h "#ifndef _CONFIG_H_"
+    mkl_write_h "#define _CONFIG_H_"
+    for n in $MKL_DEFINES ; do
+        mkl_write_h "${!n}"
+    done
+    mkl_write_h "#endif /* _CONFIG_H_ */"
+
+    MKL_OUTH_FINAL=config.h
+    mv $MKL_OUTH $MKL_OUTH_FINAL
+
+    echo "Generated $MKL_OUTH_FINAL"
+}
+
+# Remove file noisily, if it exists
+function mkl_rm {
+    if [[ -f $fname ]]; then
+        echo "Removing $fname"
+        rm -f "$fname"
+    fi
+}
+
+# Remove files generated by configure
+function mkl_clean {
+    for fname in Makefile.config config.h config.cache config.log ; do
+        mkl_rm "$fname"
+    done
+
+    local mf=
+    for mf in $MKL_CLEANERS ; do
+        MKL_MODULE=${mf%:*}
+        local func=${mf#*:}
+        $func || exit 1
+    done
+
+}
+
+
+# Print summary of succesful configure run
+function mkl_summary {
+
+    echo "
+Configuration summary:"
+    local n=
+    for n in $MKL_MKVARS ; do
+        # Skip the boring booleans
+        if [[ $n == ENABLE_* || $n == WITH_* || $n == WITHOUT_* || $n == HAVE_* || $n == def_* ]]; then
+            continue
+        fi
+        printf "  %-24s %s\n" "$n" "${!n}"
+    done
+}
+
+
+
+# Write to mk file
+# Argument:
+#  string ..
+function mkl_write_mk {
+    echo -e "$*" >> $MKL_OUTMK
+}
+
+# Write to header file
+# Argument:
+#  string ..
+function mkl_write_h {
+    echo -e "$*" >> $MKL_OUTH
+}
+
+
+
+###########################################################################
+#
+#
+# Logging and debugging
+#
+#
+###########################################################################
+
+# Debug print
+# Only visible on terminal if MKL_DEBUG is set.
+# Always written to config.log
+# Argument:
+#  string ..
+function mkl_dbg {
+    if [[ ! -z $MKL_DEBUG ]]; then
+        echo -e "${MKL_BLUE}DBG:$$: $*${MKL_CLR_RESET}" 1>&2
+    fi
+    echo "DBG $$: $*" >> $MKL_OUTDBG
+}
+
+# Error print (with color)
+# Always printed to terminal and config.log
+# Argument:
+#  string ..
+function mkl_err {
+    echo -e "${MKL_RED}$*${MKL_CLR_RESET}" 1>&2
+    echo "$*" >> $MKL_OUTDBG
+}
+
+# Same as mkl_err but without coloring
+# Argument:
+#  string ..
+function mkl_err0 {
+    echo -e "$*" 1>&2
+    echo "$*" >> $MKL_OUTDBG
+}
+
+# Standard print
+# Always printed to terminal and config.log
+# Argument:
+#  string ..
+function mkl_info {
+    echo -e "$*" 1>&2
+    echo -e "$*" >> $MKL_OUTDBG
+}
+
+
+
+
+
+
+
+###########################################################################
+#
+#
+# Misc helpers
+#
+#
+###########################################################################
+
+# Returns the absolute path (but not necesarily canonical) of the first argument
+function mkl_abspath {
+    echo $1 | sed -e "s|^\([^/]\)|$PWD/\1|"
+}
+
+# Returns true (0) if function $1 exists, else false (1)
+function mkl_func_exists {
+    declare -f "$1" > /dev/null
+    return $?
+}
+
+# Rename function.
+# Returns 0 on success or 1 if old function (origname) was not defined.
+# Arguments:
+#   origname
+#   newname
+function mkl_func_rename {
+    if ! mkl_func_exists $1 ; then
+        return 1
+    fi
+    local orig=$(declare -f $1)
+    local new="$2${orig#$1}"
+    eval "$new"
+    unset -f "$1"
+    return 0
+}
+
+
+# Push module function for later call by mklove.
+# The function is renamed to an internal name.
+# Arguments:
+#  list variable name
+#  module name
+#  function name
+function mkl_func_push {
+    local newfunc="__mkl__f_${2}_$(( MKL_IDNEXT++ ))"
+    if mkl_func_rename "$3" "$newfunc" ; then
+        mkl_var_append "$1" "$2:$newfunc"
+    fi
+}
+
+
+
+# Returns value, or the default string if value is empty.
+# Arguments:
+#  value
+#  default
+function mkl_def {
+    if [[ ! -z $1 ]]; then
+        echo $1
+    else
+        echo $2
+    fi
+}
+
+
+# Render a string (e.g., evaluate its $varrefs)
+# Arguments:
+#  string
+function mkl_render {
+    if [[ $* == *\$* ]]; then
+        eval "echo $*"
+    else
+        echo "$*"
+    fi
+}
+
+# Escape a string so that it becomes suitable for being an env variable.
+# This is a destructive operation and the original string cannot be restored.
+function mkl_env_esc {
+    echo $* | LC_ALL=C sed -e 's/[^a-zA-Z0-9_]/_/g'
+}
+
+# Convert arguments to upper case
+function mkl_upper {
+    echo "$*" | tr '[:lower:]' '[:upper:]'
+}
+
+# Convert arguments to lower case
+function mkl_lower {
+    echo "$*" | tr '[:upper:]' '[:lower:]'
+}
+
+
+# Checks if element is in list
+# Arguments:
+#   list
+#   element
+function mkl_in_list {
+    local n
+    for n in $1 ; do
+        [[ $n == $2 ]] && return 0
+    done
+    return 1
+}
+
+
+# Silent versions of pushd and popd
+function mkl_pushd {
+    pushd "$1" >/dev/null
+}
+
+function mkl_popd {
+    popd >/dev/null
+}
+
+
+###########################################################################
+#
+#
+# Cache functionality
+#
+#
+###########################################################################
+
+
+# Write cache file
+function mkl_cache_write {
+    [[ ! -z "$MKL_NOCACHE" ]] && return 0
+    echo "# mklove configure cache file generated at $(date)" > config.cache
+    for n in $MKL_CACHEVARS ; do
+        echo "$n=${!n}" >> config.cache
+    done
+    echo "Generated config.cache"
+}
+
+
+# Read cache file
+function mkl_cache_read {
+    [[ ! -z "$MKL_NOCACHE" ]] && return 0
+    [ -f config.cache ] || return 1
+
+    echo "using cache file config.cache"
+
+    local ORIG_IFS=$IFS
+    IFS="$IFS="
+    while read -r n v ; do
+        [[ -z $n || $n = \#* || -z $v ]] && continue
+        # Don't let cache overwrite variables
+        [[ -n ${n+r} ]] || mkl_var_set $n $v cache
+    done < config.cache
+    IFS=$ORIG_IFS
+}
+
+
+###########################################################################
+#
+#
+# Config name meta data
+#
+#
+###########################################################################
+
+# Set metadata for config name
+# This metadata is used by mkl in various situations
+# Arguments:
+#   config name
+#   metadata key
+#   metadata value (appended)
+function mkl_meta_set {
+    local metaname="mkl__$1__$2"
+    eval "$metaname=\"\$$metaname $3\""
+}
+
+# Returns metadata for config name
+# Arguments:
+#   config name
+#   metadata key
+#   default (optional)
+function mkl_meta_get {
+    local metaname="mkl__$1__$2"
+    if [[ ! -z ${!metaname} ]]; then
+        echo ${!metaname}
+    else
+        echo "$3"
+    fi
+}
+
+# Checks if metadata exists
+# Arguments:
+#   config name
+#   metadata key
+function mkl_meta_exists {
+    local metaname="mkl__$1__$2"
+    if [[ ! -z ${!metaname} ]]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+
+
+
+
+###########################################################################
+#
+#
+# Check framework
+#
+#
+###########################################################################
+
+
+# Print that a check is beginning to run
+# Returns 0 if a cached result was used (do not continue with your tests),
+# else 1.
+#
+# If the check should not be cachable then specify argument 3 as "no-cache",
+# this is useful when a check not only checks but actually sets config
+# variables itself (which is not recommended, but desired sometimes).
+#
+# Arguments:
+#  [ --verb "verb.." ]  (replace "checking for")
+#  config name
+#  define name
+#  action  (fail,cont,disable or no-cache)
+#  [ display name ]
+function mkl_check_begin {
+    local verb="checking for"
+    if [[ $1 == "--verb" ]]; then
+        verb="$2"
+        shift
+        shift
+    fi
+
+    local name=$(mkl_meta_get $1 name "$4")
+    [[ -z $name ]] && name="$1"
+
+    echo -n "$verb $name..."
+    if [[ $3 != "no-cache" ]]; then
+        local status=$(mkl_var_get "MKL_STATUS_$1")
+        # Check cache (from previous run or this one).
+        # Only used cached value if the cached check succeeded:
+        # it is more likely that a failed check has been fixed than the other
+        # way around.
+        if [[ ! -z $status && ( $status = "ok" ) ]]; then
+            mkl_check_done "$1" "$2" "$3" $status "cached"
+            return 0
+        fi
+    fi
+    return 1
+}
+
+
+# Calls the manual_checks function for the given module.
+# Use this for modules that provide check hooks that require
+# certain call ordering, such as dependent library checks.
+#
+# Param 1: module name
+function mkl_check {
+    local modname=$1
+
+    local func="${modname}_manual_checks"
+    if ! mkl_func_exists "$func" ; then
+        mkl_fail "Check function for module $modname not found: missing mkl_require $modname ?"
+        return 1
+    fi
+
+    $func
+    return $?
+}
+
+
+# Print that a check is done
+# Arguments:
+#  config name
+#  define name
+#  action
+#  status (ok|failed)
+#  extra-info (optional)
+function mkl_check_done {
+    # Clean up configname to be a safe varname
+    local cname=${1//-/_}
+    mkl_var_set "MKL_STATUS_$cname" "$4" cache
+
+    mkl_dbg "Setting $1 ($cname) status to $4 (action $3)"
+
+    local extra=""
+    if [[ $4 = "failed" ]]; then
+        local clr=$MKL_YELLOW
+        extra=" ($3)"
+        case "$3" in
+            fail)
+                clr=$MKL_RED
+                ;;
+            cont)
+                extra=""
+                ;;
+        esac
+        echo -e " $clr$4$MKL_CLR_RESET${extra}"
+    else
+        [[ ! -z $2 ]] && mkl_define_set "$cname" "$2" "1"
+        [[ ! -z $2 ]] && mkl_mkvar_set  "$cname" "$2" "y"
+        [ ! -z "$5" ] && extra=" ($5)"
+        echo -e " $MKL_GREEN$4${MKL_CLR_RESET}$extra"
+    fi
+}
+
+
+# Perform configure check by compiling source snippet
+# Arguments:
+#  [--sub]             (run checker as a sub-check, not doing begin/fail/ok)
+#  [--ldflags="..." ]  (appended after "compiler arguments" below)
+#  config name
+#  define name
+#  action (fail|disable)
+#  compiler (CC|CXX)
+#  compiler arguments (optional "", example: "-lzookeeper")
+#  source snippet
+function mkl_compile_check {
+
+    local sub=0
+    if [[ $1 == --sub ]]; then
+        sub=1
+        shift
+    fi
+
+    local ldf=
+    if [[ $1 == --ldflags=* ]]; then
+        ldf=${1#*=}
+        shift
+    fi
+
+    if [[ $sub -eq 0 ]]; then
+        mkl_check_begin "$1" "$2" "$3" "$1 (by compile)" && return $?
+    fi
+
+    local cflags=
+
+    if [[ $4 = "CXX" ]]; then
+        local ext=cpp
+        cflags="$(mkl_mkvar_get CXXFLAGS)"
+    else
+        local ext=c
+        cflags="$(mkl_mkvar_get CFLAGS)"
+    fi
+
+    local srcfile=$(mktemp _mkltmpXXXXXX)
+    mv "$srcfile" "${srcfile}.$ext"
+    srcfile="$srcfile.$ext"
+    echo "$6" > $srcfile
+    echo "
+int main () { return 0; }
+" >> $srcfile
+
+    local cmd="${!4} $cflags $(mkl_mkvar_get CPPFLAGS) -Wall -Werror $srcfile -o ${srcfile}.o $ldf $(mkl_mkvar_get LDFLAGS) $5 $(mkl_mkvar_get LIBS)";
+    mkl_dbg "Compile check $1 ($2) (sub=$sub): $cmd"
+
+    local output
+    output=$($cmd 2>&1)
+
+    if [[ $? != 0 ]] ; then
+        mkl_dbg "compile check for $1 ($2) failed: $cmd: $output"
+        [[ $sub -eq 0 ]] &&  mkl_check_failed "$1" "$2" "$3" "compile check failed:
+CC: $4
+flags: $5
+$cmd:
+$output
+source: $6"
+        local ret=1
+    else
+        [[ $sub -eq 0 ]] && mkl_check_done "$1" "$2" "$3" "ok"
+        local ret=0
+    fi
+
+    # OSX XCode toolchain creates dSYM directories when -g is set,
+    # delete them specifically.
+    rm -rf "$srcfile" "${srcfile}.o" "$srcfile*dSYM"
+
+    return $ret
+}
+
+
+# Low-level: Try to link with a library.
+# Arguments:
+#  linker flags (e.g. "-lpthreads")
+function mkl_link_check0 {
+    local libs=$1
+    local srcfile=$(mktemp _mktmpXXXXXX)
+    echo "#include <stdio.h>
+int main () { FILE *fp = stderr; return fp ? 0 : 0; }" > ${srcfile}.c
+
+    local cmd="${CC} $(mkl_mkvar_get CFLAGS) $(mkl_mkvar_get LDFLAGS) ${srcfile}.c -o ${srcfile}_out $libs";
+    mkl_dbg "Link check for $1: $cmd"
+
+    local output
+    output=$($cmd 2>&1)
+    local retcode=$?
+
+    if [[ $retcode -ne 0 ]] ; then
+        mkl_dbg "Link check for $1 failed: $output"
+    fi
+
+    rm -f $srcfile*
+    return $retcode
+}
+
+
+# Try to link with a library.
+# Arguments:
+#  config name
+#  define name
+#  action (fail|disable)
+#  linker flags (e.g. "-lpthreads")
+function mkl_link_check {
+    mkl_check_begin "$1" "$2" "$3" "$1 (by linking)" && return $?
+
+    if mkl_link_check0 "$4" ; then
+        mkl_check_done "$1" "$2" "$3" "ok" "$4"
+        return 0
+    else
+        mkl_dbg "link check for $1 ($2) failed: $output"
+        mkl_check_failed "$1" "$2" "$3" "compile check failed:
+$output"
+        return 1
+    fi
+}
+
+
+
+# Tries to figure out if we can use a static library or not.
+#
+# WARNING: This function must not emit any stdout output other than the
+#          updated list of libs. Do not use any stdout-printing checker.
+#
+# Arguments:
+#  config name    (e.g., zstd)
+#  compiler flags (optional "", e.g: "-lzstd")
+# Returns/outputs:
+#  New list of compiler flags
+function mkl_lib_check_static {
+    local configname=$1
+    local libs=$2
+    local arfile_var=STATIC_LIB_${configname}
+    local stfnames=$(mkl_lib_static_fnames $configname)
+
+    mkl_dbg "$configname: Check for static library (libs $libs, arfile variable $arfile_var=${!arfile_var}, static filenames $stfnames)"
+
+    # If STATIC_LIB_<configname> specifies .a file(s) we use that instead.
+    if [[ -n ${!arfile_var} ]]; then
+        libs="${!arfile_var}"
+
+    elif [[ $WITH_STATIC_LINKING != y ]]; then
+        # Static linking not enabled
+        echo ""
+        return
+
+    elif [[ $HAS_LDFLAGS_STATIC == y ]] && [[ -n $stfnames ]]; then
+        local libname
+        local stlibs=
+        for libname in $stfnames; do
+            # Convert the static filename to a linker flag:
+            # libzstd.a -> -lzstd
+            libname=${libname#lib}
+            libname="-l${libname%.a}"
+            stlibs="${stlibs}${libname} "
+        done
+        libs="${LDFLAGS_STATIC} $stlibs ${LDFLAGS_DYNAMIC}"
+        mkl_dbg "$configname: after replacing libs: $libs"
+
+    elif [[ $libs == *-L* ]]; then
+        # Try to resolve full static paths using any -Lpaths in $libs
+        local lpath
+        for lpath in $libs; do
+            [[ $lpath == -L* ]] || continue
+
+            lpath="${lpath#-L}"
+            [[ -d $lpath ]] || continue
+
+            if mkl_resolve_static_libs "$configname" "$lpath"; then
+                break
+            fi
+        done
+
+        libs="${!arfile_var}"
+        mkl_dbg "$configname: after -L resolve, libs is $libs"
+
+    else
+        mkl_dbg "$configname: Neither $arfile_var=/path/to/libname.a specified nor static linker flags supported: static linking probably won't work"
+        libs=""
+    fi
+
+    if [[ -z $libs ]]; then
+        echo ""
+        return
+    fi
+
+    # Attempt to link a small program with these static libraries
+    mkl_dbg "$configname: verifying that linking \"$libs\" works"
+    if ! mkl_link_check0 "$libs" ; then
+        mkl_dbg "$configname: Could not use static libray flags: $libs"
+        echo ""
+        return
+    fi
+
+    mkl_allvar_set "$configname" "${configname}_STATIC" "y"
+
+    echo $libs
+}
+
+
+# Checks that the specified lib is available through a number of methods.
+# compiler flags are automatically appended to "LIBS" mkvar on success.
+#
+# If STATIC_LIB_<libname_without_-l> is set to the path of an <libname>.a file
+# it will be used instead of -l<libname>.
+#
+# <definename>_STATIC will be automatically defined (for both Makefile.config
+# and config.h) if the library is to be linked statically, or was installed
+# with a source dependency installer.
+#
+# Arguments:
+#  [--override-action=<action>]  (internal use, overrides action argument)
+#  [--no-static]  (do not attempt to link the library statically)
+#  [--libname=<lib>] (library name if different from config name, such as
+#                     when the libname includes a dash)
+#  config name (library name (for pkg-config))
+#  define name
+#  action (fail|disable|cont)
+#  compiler (CC|CXX)
+#  compiler flags (optional "", e.g: "-lyajl")
+#  source snippet
+function mkl_lib_check0 {
+
+    local override_action=
+    local nostaticopt=
+    local libnameopt=
+    local libname=
+
+    while [[ $1 == --* ]]; do
+        if [[ $1 == --override-action=* ]]; then
+            override_action=${1#*=}
+        elif [[ $1 == --no-static ]]; then
+            nostaticopt=$1
+        elif [[ $1 == --libname* ]]; then
+            libnameopt=$1
+            libname="${libnameopt#*=}"
+        else
+            mkl_err "mkl_lib_check: invalid option $1"
+            exit 1
+        fi
+        shift
+    done
+
+    if [[ -z $libname ]]; then
+        libname=$1
+    fi
+
+    local action=$3
+    if [[ -n $override_action ]]; then
+        action=$override_action
+    fi
+
+    # pkg-config result (0=ok)
+    local pkg_conf_failed=1
+    if [[ $WITH_PKGCONFIG == "y" ]]; then
+        # Let pkg-config populate CFLAGS, et.al.
+        # Return on success.
+        mkl_pkg_config_check $nostaticopt $libnameopt "$1" "$2" cont "$4" "$6" && return $?
+    fi
+
+    local libs="$5"
+    local is_static=0
+
+    if [[ -z $nostaticopt ]]; then
+        local stlibs=$(mkl_lib_check_static $1 "$libs")
+        if [[ -n $stlibs ]]; then
+            libs=$stlibs
+            is_static=1
+        fi
+    fi
+
+    if ! mkl_compile_check "$1" "$2" "$action" "$4" "$libs" "$6"; then
+        return 1
+    fi
+
+    if [[ -n $libs ]]; then
+        # Add libraries in reverse order to make sure inter-dependencies
+        # are resolved in the correct order.
+        # E.g., check for crypto and then ssl should result in -lssl -lcrypto
+        mkl_dbg "$1: from lib_check: LIBS: prepend $libs"
+        mkl_mkvar_prepend "$1" LIBS "$libs"
+        if [[ $is_static == 0 ]]; then
+            # Static libraries are automatically bundled with
+            # librdkafka-static.a so there is no need to add them as an
+            # external linkage dependency.
+            mkl_mkvar_prepend "$1" MKL_PKGCONFIG_LIBS_PRIVATE "$libs"
+        fi
+    fi
+
+    return 0
+}
+
+
+# Wrapper for mkl_lib_check0 which attempts dependency installation
+# if --install-deps is specified.
+#
+# See mkl_lib_check0 for arguments and details.
+function mkl_lib_check {
+
+    local arg=
+    local name=
+
+    # Find config name parameter (first non-option (--...))
+    for arg in $* ; do
+        if [[ $arg == --* ]]; then
+            continue
+        fi
+        name=$arg
+        break
+    done
+
+    if [[ $MKL_INSTALL_DEPS != y ]] || ! mkl_dep_has_installer "$name" ; then
+        mkl_lib_check0 "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8"
+        return $?
+    fi
+
+
+    # Automatic dependency installation mode:
+    # First pass is lib check with cont,
+    # if it fails, attempt dependency installation,
+    # and then make second with caller's fail-action.
+
+    local retcode=
+
+    # With --source-deps-only we want to make sure the dependency
+    # being used is in-fact from the dependency builder (if supported),
+    # rather than a system installed alternative, so skip the pre-check and
+    # go directly to dependency installation/build below.
+    if [[ $MKL_SOURCE_DEPS_ONLY != y ]] || ! mkl_dep_has_builder $name ; then
+        mkl_lib_check0 --override-action=cont "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8"
+        retcode=$?
+        if [[ $retcode -eq 0 ]]; then
+            # Successful on first pass
+            return $retcode
+        fi
+    else
+        mkl_dbg "$name: skipping dependency pre-check in favour of --source-deps-only"
+    fi
+
+    # Install dependency
+    if ! mkl_dep_install "$name" ; then
+        return 1
+    fi
+
+    # Second pass: check again, this time fail hard
+    mkl_lib_check0 --override-action=fail "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8"
+    return $?
+}
+
+
+
+# Check for library with pkg-config
+# Automatically sets CFLAGS and LIBS from pkg-config information.
+# Arguments:
+#  [--no-static]  (do not attempt to link the library statically)
+#  [--libname=<lib>] (library name if different from config name, such as
+#                     when the libname includes a dash)
+#  config name
+#  define name
+#  action (fail|disable|ignore|cont)
+#  compiler (CC|CXX)
+#  source snippet
+function mkl_pkg_config_check {
+
+    local nostaticopt=
+    if [[ $1 == --no-static ]]; then
+        nostaticopt=$1
+        shift
+    fi
+
+    local libname=$1
+    if [[ $1 == --libname* ]]; then
+        libname="${libnameopt#*=}"
+        shift
+    fi
+
+    local cname="${1}_PKGCONFIG"
+    mkl_check_begin "$cname" "$2" "no-cache" "$1 (by pkg-config)" && return $?
+
+    local cflags=
+    local cmd="${PKG_CONFIG} --short-errors --cflags $libname"
+    mkl_dbg "pkg-config check $libname for CFLAGS ($2): $cmd"
+
+    cflags=$($cmd 2>&1)
+    if [[ $? != 0 ]]; then
+        mkl_dbg "'$cmd' failed: $cflags"
+        # Clear define name ($2): caller may have additional checks
+        mkl_check_failed "$cname" "" "$3" "'$cmd' failed:
+$cflags"
+        return 1
+    fi
+
+    if [[ $(mkl_meta_get $1 installed_with) == "source" && \
+              $WITH_STATIC_LINKING == y && \
+              $MKL_SOURCE_DEPS_ONLY == y ]]; then
+        # If attempting static linking and we're using source-only
+        # dependencies, then there is no need for pkg-config since
+        # the source installer will have set the required flags.
+        mkl_check_failed "$cname" "" "ignore" "pkg-config ignored for static build"
+        return 1
+    fi
+
+    local libs=
+    cmd="${PKG_CONFIG} --short-errors --libs $libname"
+    mkl_dbg "pkg-config check $libname for LIBS ($2): $cmd"
+    libs=$($cmd 2>&1)
+    if [[ $? != 0 ]]; then
+        mkl_dbg "${PKG_CONFIG} --libs $libname failed: $libs"
+        # Clear define name ($2): caller may have additional checks
+        mkl_check_failed "$cname" "" "$3" "pkg-config --libs failed"
+        return 1
+    fi
+
+    mkl_dbg "$1: from pkg-config: CFLAGS '$CFLAGS', LIBS '$LIBS'"
+
+    local snippet="$5"
+    if [[ -n $snippet ]]; then
+        mkl_dbg "$1: performing compile check using pkg-config info"
+
+        if ! mkl_compile_check --sub "$1" "$2" "no-cache" "$4" "$cflags $libs" "$snippet"; then
+            mkl_check_failed "$cname" "" "$3" "compile check failed"
+            return 1
+        fi
+    fi
+
+    mkl_mkvar_append $1 "MKL_PKGCONFIG_REQUIRES_PRIVATE" "$libname"
+
+    mkl_mkvar_append $1 "CFLAGS" "$cflags"
+
+    if [[ -z $nostaticopt ]]; then
+        local stlibs=$(mkl_lib_check_static $1 "$libs")
+        if [[ -n $stlibs ]]; then
+            libs=$stlibs
+        else
+            # if we don't find a static library to bundle into the
+            # -static.a, we need to export a pkgconfig dependency
+            # so it can be resolved when linking downstream packages
+            mkl_mkvar_append $1 "MKL_PKGCONFIG_REQUIRES" "$libname"
+        fi
+    fi
+
+    mkl_dbg "$1: from pkg-config: LIBS: prepend $libs"
+    mkl_mkvar_prepend "$1" LIBS "$libs"
+
+    mkl_check_done "$1" "$2" "$3" "ok"
+
+    return 0
+}
+
+
+# Check that a command runs and exits succesfully.
+# Arguments:
+#  config name
+#  define name (optional, can be empty)
+#  action
+#  command
+function mkl_command_check {
+    mkl_check_begin "$1" "$2" "$3" "$1 (by command)" && return $?
+
+    local out=
+    out=$($4 2>&1)
+    if [[ $? != 0 ]]; then
+        mkl_dbg "$1: $2: $4 failed: $out"
+        mkl_check_failed "$1" "$2" "$3" "command '$4' failed:
+$out"
+        return 1
+    fi
+
+    mkl_check_done "$1" "$2" "$3" "ok"
+
+    return 0
+}
+
+
+# Check that a program is executable, but will not execute it.
+# Arguments:
+#  config name
+#  define name (optional, can be empty)
+#  action
+#  program name  (e.g, objdump)
+function mkl_prog_check {
+    mkl_check_begin --verb "checking executable" "$1" "$2" "$3" "$1" && return $?
+
+    local out=
+    out=$(command -v "$4" 2>&1)
+    if [[ $? != 0 ]]; then
+        mkl_dbg "$1: $2: $4 is not executable: $out"
+        mkl_check_failed "$1" "$2" "$3" "$4 is not executable"
+        return 1
+    fi
+
+    mkl_check_done "$1" "$2" "$3" "ok"
+
+    return 0
+}
+
+
+
+
+# Checks that the check for the given config name passed.
+# This does not behave like the other checks, if the given config name passed
+# its test then nothing is printed. Else the configure will fail.
+# Arguments:
+#  checked config name
+function mkl_config_check {
+    local status=$(mkl_var_get "MKL_STATUS_$1")
+    [[ $status = "ok" ]] && return 0
+    mkl_fail $1 "" "fail" "$MKL_MODULE requires $1"
+    return 1
+}
+
+
+# Checks that all provided config names are set.
+# Arguments:
+#  config name
+#  define name
+#  action
+#  check_config_name1
+#  check_config_name2..
+function mkl_config_check_all {
+    local cname=
+    local res="ok"
+    echo start this now for $1
+    for cname in ${@:4}; do
+        local st=$(mkl_var_get "MKL_STATUS_$cname")
+        [[ $status = "ok" ]] && continue
+        mkl_fail $1 $2 $3 "depends on $cname"
+        res="failed"
+    done
+
+    echo "try res $res"
+    mkl_check_done "$1" "$2" "$3" $res
+}
+
+
+# Check environment variable
+# Arguments:
+#  config name
+#  define name
+#  action
+#  environment variable
+function mkl_env_check {
+    mkl_check_begin "$1" "$2" "$3" "$1 (by env $4)" && return $?
+
+    if [[ -z ${!4} ]]; then
+        mkl_check_failed "$1" "$2" "$3" "environment variable $4 not set"
+        return 1
+    fi
+
+    mkl_check_done "$1" "$2" "$3" "ok" "${!4}"
+
+    return 0
+}
+
+
+# Run all checks
+function mkl_checks_run {
+    # Set up common variables
+    mkl_allvar_set "" MKL_APP_NAME $(mkl_meta_get description name)
+    mkl_allvar_set "" MKL_APP_DESC_ONELINE "$(mkl_meta_get description oneline)"
+
+    # Call checks functions in dependency order
+    local mf
+    for mf in $MKL_CHECKS ; do
+        MKL_MODULE=${mf%:*}
+        local func=${mf#*:}
+
+        if mkl_func_exists $func ; then
+            $func
+        else
+            mkl_err "Check function $func from $MKL_MODULE disappeared ($mf)"
+        fi
+        unset MKL_MODULE
+    done
+}
+
+
+# Check for color support in terminal.
+# If the terminal supports colors, the function will alter
+#  MKL_RED
+#  MKL_GREEN
+#  MKL_YELLOW
+#  MKL_BLUE
+#  MKL_CLR_RESET
+function mkl_check_terminal_color_support {
+    local use_color=false
+    local has_tput=false
+
+    if [[ -z ${TERM} ]]; then
+        # tput and dircolors require $TERM
+        mkl_dbg "\$TERM is not set! Cannot check for color support in terminal."
+        return 1
+    elif hash tput 2>/dev/null; then
+        has_tput=true
+        [[ $(tput colors 2>/dev/null) -ge 8 ]] && use_color=true
+        mkl_dbg "tput reports color support: ${use_color}"
+    elif hash dircolors 2>/dev/null; then
+        # Enable color support only on colorful terminals.
+        # dircolors --print-database uses its own built-in database
+        # instead of using /etc/DIR_COLORS. Try to use the external file
+        # first to take advantage of user additions.
+        local safe_term=${TERM//[^[:alnum:]]/?}
+        local match_lhs=""
+        [[ -f ~/.dir_colors   ]] && match_lhs="${match_lhs}$(<~/.dir_colors)"
+        [[ -f /etc/DIR_COLORS ]] && match_lhs="${match_lhs}$(</etc/DIR_COLORS)"
+        [[ -z ${match_lhs}    ]] && match_lhs=$(dircolors --print-database)
+        [[ $'\n'${match_lhs} == *$'\n'"TERM "${safe_term}* ]] && use_color=true
+        mkl_dbg "dircolors reports color support: ${use_color}"
+    fi
+
+    if ${use_color}; then
+        if ${has_tput}; then
+            # In theory, user could have set different escape sequences
+            # Because tput is available we can use it to query the right values ...
+            mkl_dbg "Using color escape sequences from tput"
+            MKL_RED=$(tput setaf 1)
+            MKL_GREEN=$(tput setaf 2)
+            MKL_YELLOW=$(tput setaf 3)
+            MKL_BLUE=$(tput setaf 4)
+            MKL_CLR_RESET=$(tput sgr0)
+        else
+            mkl_dbg "Using hard-code ANSI color escape sequences"
+            MKL_RED="\033[031m"
+            MKL_GREEN="\033[032m"
+            MKL_YELLOW="\033[033m"
+            MKL_BLUE="\033[034m"
+            MKL_CLR_RESET="\033[0m"
+        fi
+    else
+        mkl_dbg "Did not detect color support in \"$TERM\" terminal!"
+    fi
+
+    return 0
+}
+
+
+
+
+###########################################################################
+#
+#
+# Module functionality
+#
+#
+###########################################################################
+
+# Downloads module from repository.
+# Arguments:
+#  module name
+# Returns:
+#  module file name
+function mkl_module_download {
+    local modname="$1"
+    local url="$MKL_REPO_URL/modules/configure.$modname"
+    local tmpfile=""
+
+    fname="${MKLOVE_DIR}/modules/configure.$modname"
+
+    if [[ $url != http*://* ]]; then
+        # Local path, just copy file.
+        if [[ ! -f $url ]]; then
+            mkl_err "Module $modname not found at $url"
+            return 1
+        fi
+
+        if ! cp "$url" "$fname" ; then
+            mkl_err "Failed to copy $url to $fname"
+            return 1
+        fi
+
+        echo "$fname"
+        return 0
+    fi
+
+    # Download
+    mkl_info "${MKL_BLUE}downloading missing module $modname from $url${MKL_CLR_RESET}"
+
+    tmpfile=$(mktemp _mkltmpXXXXXX)
+    local out=
+    out=$(curl -fLs -o "$tmpfile" "$url" 2>&1)
+
+    if [[ $? -ne 0 ]]; then
+        rm -f "$tmpfile"
+        mkl_err "Failed to download $modname:"
+        mkl_err0 $out
+        return 1
+    fi
+
+    # Move downloaded file into place replacing the old file.
+    mv "$tmpfile" "$fname" || return 1
+
+    # "Return" filename
+    echo "$fname"
+
+    return 0
+}
+
+
+# Load module by name or filename
+# Arguments:
+#   "require"|"try"
+#   filename
+# [ module arguments ]
+function mkl_module_load {
+    local try=$1
+    shift
+    local fname=$1
+    shift
+    local modname=${fname#*configure.}
+    local bypath=1
+
+    # Check if already loaded
+    if mkl_in_list "$MKL_MODULES" "$modname"; then
+        return 0
+    fi
+
+    if [[ $fname = $modname ]]; then
+        # Module specified by name, find the file.
+        bypath=0
+        for fname in configure.$modname \
+            ${MKLOVE_DIR}/modules/configure.$modname ; do
+            [[ -s $fname ]] && break
+        done
+    fi
+
+    # Calling module
+    local cmod=$MKL_MODULE
+    [[ -z $cmod ]] && cmod="base"
+
+    if [[ ! -s $fname ]]; then
+        # Attempt to download module, if permitted
+        if [[ $MKL_NO_DOWNLOAD != 0 || $bypath == 1 ]]; then
+            mkl_err "Module $modname not found at $fname (required by $cmod) and downloads disabled"
+            if [[ $try = "require" ]]; then
+                mkl_fail "$modname" "none" "fail" \
+                    "Module $modname not found (required by $cmod) and downloads disabled"
+            fi
+            return 1
+        fi
+
+        fname=$(mkl_module_download "$modname")
+        if [[ $? -ne 0 ]]; then
+            mkl_err "Module $modname not found (required by $cmod)"
+            if [[ $try = "require" ]]; then
+                mkl_fail "$modname" "none" "fail" \
+                    "Module $modname not found (required by $cmod)"
+                return 1
+            fi
+        fi
+
+        # Now downloaded, try loading the module again.
+        mkl_module_load $try "$fname" "$@"
+        return $?
+    fi
+
+    # Set current module
+    local save_MKL_MODULE=$MKL_MODULE
+    MKL_MODULE=$modname
+
+    mkl_dbg "Loading module $modname (required by $cmod) from $fname"
+
+    # Source module file (positional arguments are available to module)
+    source $fname
+
+    # Restore current module (might be recursive)
+    MKL_MODULE=$save_MKL_MODULE
+
+    # Add module to list of modules
+    mkl_var_append MKL_MODULES $modname
+
+    # Rename module's special functions so we can call them separetely later.
+    mkl_func_rename "options" "${modname}_options"
+    mkl_func_rename "install_source" "${modname}_install_source"
+    mkl_func_rename "manual_checks" "${modname}_manual_checks"
+    mkl_func_push MKL_CHECKS "$modname" "checks"
+    mkl_func_push MKL_GENERATORS "$modname" "generate"
+    mkl_func_push MKL_CLEANERS "$modname" "clean"
+}
+
+
+# Require and load module
+# Must only be called from module file outside any function.
+# Arguments:
+#  [ --try ]    Dont fail if module doesn't exist
+#  module1
+#  [ "must" "pass" ]
+#  [ module arguments ... ]
+function mkl_require {
+    local try="require"
+    if [[ $1 = "--try" ]]; then
+        local try="try"
+        shift
+    fi
+
+    local mod=$1
+    shift
+    local override_action=
+
+    # Check for cyclic dependencies
+    if mkl_in_list "$MKL_LOAD_STACK" "$mod"; then
+        mkl_err "Cyclic dependency detected while loading $mod module:"
+        local cmod=
+        local lmod=$mod
+        for cmod in $MKL_LOAD_STACK ; do
+            mkl_err "  $lmod required by $cmod"
+            lmod=$cmod
+        done
+        mkl_fail base "" fail "Cyclic dependency detected while loading module $mod"
+        return 1
+    fi
+
+    mkl_var_prepend MKL_LOAD_STACK "$mod"
+
+
+    if [[ "$1 $2" == "must pass" ]]; then
+        shift
+        shift
+        override_action="fail"
+    fi
+
+    if [[ ! -z $override_action ]]; then
+        mkl_meta_set "MOD__$mod" "override_action" "$override_action"
+    fi
+
+
+    mkl_module_load $try $mod "$@"
+    local ret=$?
+
+    mkl_var_shift MKL_LOAD_STACK
+
+    return $ret
+}
+
+
+
+###########################################################################
+#
+#
+# Usage options
+#
+#
+###########################################################################
+
+
+MKL_USAGE="Usage: ./configure [OPTIONS...]
+
+ mklove configure script - mklove, not autoconf
+ Copyright (c) 2014-2023, Magnus Edenhill - https://github.com/edenhill/mklove
+"
+
+function mkl_usage {
+    echo "$MKL_USAGE"
+    local name=$(mkl_meta_get description name)
+
+    if [[ ! -z ${name} ]]; then
+	echo " $name - $(mkl_meta_get description oneline)
+ $(mkl_meta_get description copyright)
+"
+    fi
+
+    local og
+    for og in $MKL_USAGE_GROUPS ; do
+        og="MKL_USAGE_GROUP__$og"
+        echo "${!og}"
+    done
+
+    echo "Honoured environment variables:
+  CC, CPP, CXX, CFLAGS, CPPFLAGS, CXXFLAGS, LDFLAGS, LIBS,
+  LD, NM, OBJDUMP, STRIP, RANLIB, PKG_CONFIG, PKG_CONFIG_PATH,
+  STATIC_LIB_<libname>=.../libname.a
+
+"
+
+}
+
+
+
+# Add usage option informative text
+# Arguments:
+#  text
+function mkl_usage_info {
+    MKL_USAGE="$MKL_USAGE
+$1"
+}
+
+
+# Add option to usage output
+# Arguments:
+#  option group ("Standard", "Cross-Compilation", etc..)
+#  variable name
+#  option ("--foo", "--foo=*", "--foo=args_required")
+#  help
+#  default (optional)
+#  assignvalue (optional, default:"y")
+#  function block (optional)
+#
+# If option takes the form --foo=* then arguments are optional.
+function mkl_option {
+    local optgroup=$1
+    local varname=$2
+
+    # Fixed width between option name and help in usage output
+    local pad="                                   "
+    if [[ ${#3} -lt ${#pad} ]]; then
+        pad=${pad:0:$(expr ${#pad} - ${#3})}
+    else
+        pad=""
+    fi
+
+    # Add to usage output
+    local optgroup_safe=$(mkl_env_esc $optgroup)
+    if ! mkl_in_list "$MKL_USAGE_GROUPS" "$optgroup_safe" ; then
+        mkl_env_append MKL_USAGE_GROUPS "$optgroup_safe"
+        mkl_env_set "MKL_USAGE_GROUP__$optgroup_safe" "$optgroup options:
+"
+    fi
+
+    local defstr=""
+    [[ ! -z $5 ]] && defstr=" [$5]"
+    mkl_env_append "MKL_USAGE_GROUP__$optgroup_safe" "  $3 $pad $4$defstr
+"
+
+    local optname="${3#--}"
+    local safeopt=
+    local optval=""
+    if [[ $3 == *=* ]]; then
+        optname="${optname%=*}"
+        optval="${3#*=}"
+        if [[ $optval == '*' ]]; then
+            # Avoid globbing of --foo=* optional arguments
+            optval='\*'
+        fi
+    fi
+
+    safeopt=$(mkl_env_esc $optname)
+
+    mkl_meta_set "MKL_OPT_ARGS" "$safeopt" "$optval"
+
+    #
+    # Optional variable scoping by prefix: "env:", "mk:", "def:"
+    #
+    local setallvar="mkl_allvar_set ''"
+    local setmkvar="mkl_mkvar_set ''"
+
+    if [[ $varname = env:* ]]; then
+        # Set environment variable (during configure runtime only)
+        varname=${varname#*:}
+        setallvar=mkl_env_set
+        setmkvar=mkl_env_set
+    elif [[ $varname = mk:* ]]; then
+        # Set Makefile.config variable
+        varname=${varname#*:}
+        setallvar="mkl_mkvar_append ''"
+        setmkvar="mkl_mkvar_append ''"
+    elif [[ $varname = def:* ]]; then
+        # Set config.h define
+        varname=${varname#*:}
+        setallvar="mkl_define_set ''"
+        setmkvar="mkl_define_set ''"
+    fi
+
+
+    if [[ ! -z $7 ]]; then
+        # Function block specified.
+        eval "function opt_$safeopt { $7 }"
+    else
+    # Add default implementation of function simply setting the value.
+    # Application may override this by redefining the function after calling
+    # mkl_option.
+        if [[ $optval = "PATH" ]]; then
+        # PATH argument: make it an absolute path.
+        # Only set the make variable (not config.h)
+            eval "function opt_$safeopt { $setmkvar $varname \"\$(mkl_abspath \$(mkl_render \$1))\"; }"
+        else
+        # Standard argument: simply set the value
+            if [[ -z "$6" ]]; then
+                eval "function opt_$safeopt { $setallvar $varname \"\$1\"; }"
+            else
+                eval "function opt_$safeopt { $setallvar $varname \"$6\"; }"
+            fi
+        fi
+    fi
+
+    # If default value is provided and does not start with "$" (variable ref)
+    # then set it right away.
+    # $ variable refs are set after all checks have run during the
+    # generating step.
+    if [[ ${#5} != 0 ]] ; then
+        if [[ $5 = *\$* ]]; then
+            mkl_var_append "MKL_LATE_VARS" "opt_$safeopt:$5"
+        else
+            opt_$safeopt $5
+        fi
+    fi
+
+    if [[ ! -z $varname ]]; then
+        # Add variable to list
+        MKL_CONFVARS="$MKL_CONFVARS $varname"
+    fi
+
+}
+
+
+
+# Adds a toggle (--enable-X, --disable-X) option.
+# Arguments:
+#  option group   ("Standard", ..)
+#  variable name  (WITH_FOO)
+#  option         (--enable-foo, --enable-foo=*, or --enable-foo=req)
+#  help           ("foo.." ("Enable" and "Disable" will be prepended))
+#  default        (y or n)
+
+function mkl_toggle_option {
+
+    # Add option argument
+    mkl_option "$1" "$2" "$3" "$4" "$5"
+
+    # Add corresponding "--disable-foo" option for "--enable-foo".
+    local disname="${3/--enable/--disable}"
+    local dishelp="${4/Enable/Disable}"
+    mkl_option "$1" "$2" "$disname" "$dishelp" "" "n"
+}
+
+# Adds a toggle (--enable-X, --disable-X) option with builtin checker.
+# This is the library version.
+# Arguments:
+#  option group   ("Standard", ..)
+#  config name    (foo, must be same as pkg-config name)
+#  variable name  (WITH_FOO)
+#  action         (fail or disable)
+#  option         (--enable-foo)
+#  help           (defaults to "Enable <config name>")
+#  linker flags   (-lfoo)
+#  default        (y or n)
+
+function mkl_toggle_option_lib {
+
+    local help="$6"
+    [[ -z "$help" ]] && help="Enable $2"
+
+    # Add option argument
+    mkl_option "$1" "$3" "$5" "$help" "$8"
+
+    # Add corresponding "--disable-foo" option for "--enable-foo".
+    local disname="${5/--enable/--disable}"
+    local dishelp="${help/Enable/Disable}"
+    mkl_option "$1" "$3" "$disname" "$dishelp" "" "n"
+
+    # Create checks
+    eval "function _tmp_func { mkl_lib_check \"$2\" \"$3\" \"$4\" CC \"$7\"; }"
+    mkl_func_push MKL_CHECKS "$MKL_MODULE" _tmp_func
+}
+
+
+
+# Downloads, verifies checksum, and extracts an archive to
+# the current directory.
+#
+# Arguments:
+#  url       Archive URL
+#  shabits  The SHA algorithm bit count used to verify the checksum. E.g., "256".
+#  checksum  Expected checksum of archive (use "" to not perform check)
+function mkl_download_archive {
+    local url="$1"
+    local shabits="$2"
+    local exp_checksum="$3"
+
+    local tmpfile=$(mktemp _mkltmpXXXXXX)
+
+    # Try both wget and curl
+    if ! wget -nv -O "$tmpfile" "$url" ; then
+        if ! curl -fLsS -o "$tmpfile" "$url" ; then
+            rm -f "$tmpfile"
+            echo -e "ERROR: Download of $url failed" 1>&2
+            return 1
+        fi
+    fi
+
+    if [[ -n $exp_checksum ]]; then
+        # Verify checksum
+
+        local checksum_tool=""
+
+        # OSX has shasum by default, on Linux it is typically in
+        # some Perl package that may or may not be installed.
+        if $(which shasum >/dev/null 2>&1); then
+            checksum_tool="shasum -b -a ${shabits}"
+        else
+            # shaXsum is available in Linux coreutils
+            checksum_tool="sha${shabits}sum"
+        fi
+
+        local checksum=$($checksum_tool "$tmpfile" | cut -d' ' -f1)
+        if [[ $? -ne 0 ]]; then
+            rm -f "$tmpfile"
+            echo "ERROR: Failed to verify checksum of $url with $checksum_tool" 1>&2
+            return 1
+        fi
+
+        if [[ $checksum != $exp_checksum ]]; then
+            rm -f "$tmpfile"
+            echo "ERROR: $url: $checksum_tool: Checksum mismatch: expected $exp_checksum, calculated $checksum" 1>&2
+            return 1
+        fi
+
+        echo "### Checksum of $url verified ($checksum_tool):"
+        echo "###  Expected:   $exp_checksum"
+        echo "###  Calculated: $checksum"
+    fi
+
+    tar xzf "$tmpfile" --strip-components 1
+    if [[ $? -ne 0 ]]; then
+        rm -f "$tmpfile"
+        echo "ERROR: $url: failed to extract archive" 1>&2
+        return 1
+    fi
+
+
+    rm -f "$tmpfile"
+    return 0
+}