defineTest(qtToolchainError) {
    msg = \
        $$1 \
        "===================" \
        $$2 \
        "===================" \
        $$3
    error($$join(msg, $$escape_expand(\\n)))
}

defineTest(qtCompilerError) {
    !cross_compile: \
        what =
    else: host_build: \
        what = " host"
    else: \
        what = " target"
    qtToolchainError("Cannot run$$what compiler '$$1'. Output:", $$2, \
                     "Maybe you forgot to setup the environment?")
}

cross_compile:host_build: \
    target_prefix = QMAKE_HOST_CXX
else: \
    target_prefix = QMAKE_CXX

#
# Determine and cache the compiler version
#

defineReplace(qtVariablesFromMSVC) {
    ret = $$system("$$1 -nologo -E $$2 $$system_quote($$PWD/data/macros.cpp) 2>NUL", lines, ec)
    !equals(ec, 0): qtCompilerError($$1, $$ret)
    return($$ret)
}

defineReplace(qtVariablesFromGCC) {
    ret = $$system("$$1 -E $$system_quote($$PWD/data/macros.cpp) \
        2>$$QMAKE_SYSTEM_NULL_DEVICE", lines, ec)
    !equals(ec, 0): qtCompilerError($$1, $$ret)
    return($$ret)
}

isEmpty($${target_prefix}.COMPILER_MACROS) {
    msvc {
        clang_cl {
            # We need to obtain the cl.exe version first
            vars = $$qtVariablesFromMSVC(cl)
            for (v, vars) {
                isEmpty(v)|contains(v, $${LITERAL_HASH}.*): next()
                eval($$v)
            }
            isEmpty(QMAKE_MSC_FULL_VER): error("Could not determine the Visual Studio version")

            QMAKE_CFLAGS_MSVC_COMPAT = $$replace(QMAKE_MSC_FULL_VER, "(..)(..)(.*)", \
                                                 "-fms-compatibility-version=\\1.\\2.\\3")
            cache($${target_prefix}.QMAKE_CFLAGS_MSVC_COMPAT, set stash, QMAKE_CFLAGS_MSVC_COMPAT)
            $${target_prefix}.COMPILER_MACROS += QMAKE_CFLAGS_MSVC_COMPAT
            vars = $$qtVariablesFromMSVC($$QMAKE_CXX, $$QMAKE_CFLAGS_MSVC_COMPAT)
        } else {
            vars = $$qtVariablesFromMSVC($$QMAKE_CXX)
        }
    } else: gcc|ghs {
        vars = $$qtVariablesFromGCC($$QMAKE_CXX)
    }
    for (v, vars) {
        !contains(v, "[A-Z_]+ = .*"): next()
        # Set both <varname> for the outer scope ...
        eval($$v)
        v ~= s/ .*//
        isEmpty($$v): error("Compiler produced empty value for $${v}.")
        # ... and save QMAKE_(HOST_)?CXX.<varname> in the cache.
        cache($${target_prefix}.$$v, set stash, $$v)
        $${target_prefix}.COMPILER_MACROS += $$v
    }
    cache($${target_prefix}.COMPILER_MACROS, set stash)
} else {
    # load from the cache
    for (i, $${target_prefix}.COMPILER_MACROS): \
        $$i = $$eval($${target_prefix}.$$i)
}

# Populate QMAKE_COMPILER_DEFINES and some compatibility variables.
# The $$format_number() calls strip leading zeros to avoid misinterpretation as octal.
QMAKE_COMPILER_DEFINES += __cplusplus=$$QT_COMPILER_STDCXX
!isEmpty(QMAKE_MSC_VER): \
    QMAKE_COMPILER_DEFINES += _MSC_VER=$$QMAKE_MSC_VER _MSC_FULL_VER=$$QMAKE_MSC_FULL_VER
!isEmpty(QMAKE_ICC_VER): \
    QMAKE_COMPILER_DEFINES += __INTEL_COMPILER=$$QMAKE_ICC_VER __INTEL_COMPILER_UPDATE=$$QMAKE_ICC_UPDATE_VER
!isEmpty(QMAKE_APPLE_CC): \
    QMAKE_COMPILER_DEFINES += __APPLE_CC__=$$QMAKE_APPLE_CC
!isEmpty(QMAKE_APPLE_CLANG_MAJOR_VERSION): \
    QMAKE_COMPILER_DEFINES += __clang__ \
        __clang_major__=$$QMAKE_APPLE_CLANG_MAJOR_VERSION \
        __clang_minor__=$$QMAKE_APPLE_CLANG_MINOR_VERSION \
        __clang_patchlevel__=$$QMAKE_APPLE_CLANG_PATCH_VERSION
!isEmpty(QMAKE_CLANG_MAJOR_VERSION): \
    QMAKE_COMPILER_DEFINES += __clang__ \
        __clang_major__=$$QMAKE_CLANG_MAJOR_VERSION \
        __clang_minor__=$$QMAKE_CLANG_MINOR_VERSION \
        __clang_patchlevel__=$$QMAKE_CLANG_PATCH_VERSION
!isEmpty(QMAKE_GCC_MAJOR_VERSION): \
    QMAKE_COMPILER_DEFINES += \
        __GNUC__=$$QMAKE_GCC_MAJOR_VERSION \
        __GNUC_MINOR__=$$QMAKE_GCC_MINOR_VERSION \
        __GNUC_PATCHLEVEL__=$$QMAKE_GCC_PATCH_VERSION
!isEmpty(QMAKE_GHS_VERSION): \
    QMAKE_COMPILER_DEFINES += __ghs__ __GHS_VERSION_NUMBER=$$QMAKE_GHS_VERSION

QMAKE_CFLAGS += $$QMAKE_CFLAGS_MSVC_COMPAT
QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_MSVC_COMPAT

clang_cl|intel_icl {
    include(../common/msvc-based-version.conf)
} else: msvc {
    include(../common/msvc-version.conf)
}

#
# Determine and cache the default search paths
#

defineReplace(qtMakeExpand) {
    out = "$$1"
    for(ever) {
        m = $$replace(out, ".*\\$\\(EXPORT_([^)]+)\\).*", \\1)
        equals(m, $$out): \
            return($$out)
        out = $$replace(out, "\\$\\(EXPORT_$$m\\)", $$eval($$m))
    }
}

defineReplace(qtSplitPathList) {
    paths = $$split(1, $$QMAKE_DIRLIST_SEP)
    ret =
    for (p, paths): \
        ret += $$clean_path($$p)
    return($$ret)
}

defineReplace(qtNmakePathList) {
    paths =
    for (p, 1): \
        paths += $$shell_path($$p)
    paths ~= s,$${LITERAL_HASH},^$${LITERAL_HASH},g
    paths ~= s,\\$,\$\$,g
    return($$join(paths, $$QMAKE_DIRLIST_SEP))
}

msvc {
    arch = $$lower($$VCPROJ_ARCH)
    equals(arch, x64): \  # may be "win32" or undefined
        arch = amd64
    else: !equals(arch, arm):!equals(arch, arm64): \  # may be "win32" or undefined
        arch = x86
    # Consider only WinRT and ARM64 desktop builds to be cross-builds -
    # the host is assumed to be Intel and capable of running the target
    # executables (so building for x64 on x86 will break).
    winrt|equals(arch, arm64): \
        CONFIG += msvc_cross
}

isEmpty($${target_prefix}.INCDIRS) {
    #
    # Get default include and library paths from compiler
    #
    wasm {
        # wasm compiler does not work here, just use defaults
    } else: gcc {
        cmd_suffix = "<$$QMAKE_SYSTEM_NULL_DEVICE >$$QMAKE_SYSTEM_NULL_DEVICE"
        equals(QMAKE_HOST.os, Windows): \
            cmd_prefix = "set LC_ALL=C&"
        else: \
            cmd_prefix = "LC_ALL=C"

        cxx_flags = $$QMAKE_CXXFLAGS

        # Manually inject the sysroot for Apple Platforms because its resolution
        # normally does not happen until default_post.prf. This is especially
        # important for moc to gain the correct default include directory list.
        # While technically incorrect but without any likely practical effect,
        # UIKit simulator platforms will see the device SDK's sysroot in
        # QMAKE_DEFAULT_*DIRS, because they're handled in a single build pass.
        darwin {
            # Clang doesn't pick up the architecture from the sysroot, and will
            # default to the host architecture, so we need to manually set it.
            cxx_flags += -arch $$QMAKE_APPLE_DEVICE_ARCHS

            uikit:macx-xcode: \
                cxx_flags += -isysroot $$sdk_path_device.value
            else: \
                cxx_flags += -isysroot $$QMAKE_MAC_SDK_PATH
        }

        rim_qcc: \
            # Need the cc1plus and ld command lines to pick up the paths
            cxx_flags += $$QMAKE_LFLAGS_SHLIB -o $$QMAKE_SYSTEM_NULL_DEVICE -v
        else: darwin:clang: \
            # Need to link to pick up library paths
            cxx_flags += -g0 $$QMAKE_LFLAGS_SHLIB -o /dev/null -v -Wl,-v
        else: \
            # Just preprocess, might not pick up library paths
            cxx_flags += -E -v

        output = $$system("$$cmd_prefix $$QMAKE_CXX $$qtMakeExpand($$cxx_flags) -xc++ - 2>&1 $$cmd_suffix", lines, ec)
        !equals(ec, 0): qtCompilerError($$QMAKE_CXX, $$output)

        rim_qcc {
            for (line, output) {
                contains(line, "^[^ ]*cc1plus .*") {
                    take_next = false
                    for (parameter, $$list($$line)) {
                        $$take_next {
                            QMAKE_DEFAULT_INCDIRS += $$clean_path($$parameter)
                            take_next = false
                        } else: equals(parameter, "-isystem") {
                            take_next = true
                        }
                    }
                } else: contains(line, "^[^ ]*-ld .*") {
                    for (parameter, $$list($$line)) {
                        contains(parameter, "^-L.*") {
                            parameter ~= s/^-L//
                            QMAKE_DEFAULT_LIBDIRS += $$clean_path($$parameter)
                        }
                    }
                }
            }
        } else {
            add_includes = false
            add_libraries = false
            for (line, output) {
                line ~= s/^[ \\t]*//  # remove leading spaces
                contains(line, "LIBRARY_PATH=.*") {
                    line ~= s/^LIBRARY_PATH=//  # remove leading LIBRARY_PATH=
                    equals(QMAKE_HOST.os, Windows): \
                        paths = $$split(line, ;)
                    else: \
                        paths = $$split(line, $$QMAKE_DIRLIST_SEP)
                    for (path, paths): \
                        QMAKE_DEFAULT_LIBDIRS += $$clean_path($$path)
                } else: contains(line, "Library search paths:") {
                    add_libraries = true
                } else: contains(line, "$${LITERAL_HASH}include <.*") {  # #include <...> search starts here:
                    add_includes = true
                } else: contains(line, "End of search.*") {
                    add_includes = false
                } else: $$add_libraries {
                    # We assume all library search paths are absolute
                    !contains(line, "^/.*") {
                        add_libraries = false
                        next()
                    }
                    QMAKE_DEFAULT_LIBDIRS += $$clean_path($$line)
                } else: $$add_includes {
                    !contains(line, ".* \\(framework directory\\)"): \
                        QMAKE_DEFAULT_INCDIRS += $$clean_path($$line)
                }
            }
        }
        if(!darwin:clang)|intel_icc {
            # Clang on a non-Apple system (that is, a system without ld64 -- say, with GNU ld
            # or gold under Linux) will not print any library search path. Need to use another
            # invocation with different options (which in turn doesn't print include search
            # paths, so it can't just be used in place of the above code).
            # What's more, -print-search-dirs can't be used on clang on Apple because it
            # won't print all the library paths (only the clang-internal ones).
            output = $$system("$$cmd_prefix $$QMAKE_LINK $$QMAKE_LFLAGS -print-search-dirs", lines, ec)
            !equals(ec, 0): qtCompilerError($$QMAKE_LINK, $$output)

            for (line, output) {
                contains(line, "^libraries: .*") {
                    line ~= s,^libraries: ,,
                    equals(QMAKE_HOST.os, Windows) {
                        # clang (7.x) on Windows uses the wrong path list separator ...
                        line ~= s,:(?![/\\\\]),;,
                        paths = $$split(line, ;)
                    } else {
                        paths = $$split(line, $$QMAKE_DIRLIST_SEP)
                    }
                    for (path, paths): \
                        QMAKE_DEFAULT_LIBDIRS += $$clean_path($$replace(path, ^=, $$[SYSROOT]))
                }
            }
        }
        isEmpty(QMAKE_DEFAULT_LIBDIRS)|isEmpty(QMAKE_DEFAULT_INCDIRS): \
            !integrity: \
                error("failed to parse default search paths from compiler output")
        QMAKE_DEFAULT_LIBDIRS = $$unique(QMAKE_DEFAULT_LIBDIRS)
    } else: ghs {
        cmd = $$QMAKE_CXX $$QMAKE_CXXFLAGS -$${LITERAL_HASH} -o /tmp/fake_output /tmp/fake_input.cpp
        output = $$system("$$cmd", blob, ec)
        !equals(ec, 0): qtCompilerError($$QMAKE_CXX, $$output)
        output ~= s/\\\\\\n {8}//g
        output = $$split(output, $$escape_expand(\\n))
        for (line, output) {
            contains(line, "^[^ ]+/ecom[^ ]+ .* /tmp/fake_input\\.cpp") {
                for (parameter, $$list($$line)) {
                    contains(parameter, "^(-I|--include_no_mmd=|--sys_include=).*") {
                        parameter ~= s/^(-I|--include_no_mmd=|--sys_include=)//
                        QMAKE_DEFAULT_INCDIRS += $$clean_path($$parameter)
                    }
                }
            } else: contains(line, "^[^ ]+/elxr .*") {
                for (parameter, $$list($$line)) {
                    contains(parameter, "^-L.*") {
                        parameter ~= s/^-L//
                        QMAKE_DEFAULT_LIBDIRS += $$clean_path($$parameter)
                    }
                }
            }
        }
    } else: msvc_cross {
        # Use a batch file, because %VAR% in the system() call expands to
        # the pre-script-call value, and !VAR! cannot be enabled outside
        # a batch file without invoking another shell instance.
        cmd = $$system_quote($$system_path($$PWD/data/dumpvcvars.bat))

        hostArch = $$QMAKE_HOST.arch
        equals(hostArch, x86_64): \
            hostArch = amd64
        !equals(arch, $$hostArch): \
            arch = $${hostArch}_$$arch

        isEmpty(MSVC_VER): \
            error("Mkspec does not specify MSVC_VER. Cannot continue.")
        versionAtLeast(MSVC_VER, 15.0) {
            dir = $$(VSINSTALLDIR)
            isEmpty(dir): \
                dir = $$read_registry(HKLM, \
                    "Software\\Microsoft\\VisualStudio\\SxS\\VS7\\$$MSVC_VER", 32)
            isEmpty(dir): \
                error("Failed to find the Visual Studio installation directory.")
            cmd += $$system_quote($$dir\\VC\\Auxiliary\\Build\\vcvarsall.bat) $$arch
        } else {
            dir = $$(VCINSTALLDIR)
            isEmpty(dir): \
                dir = $$read_registry(HKLM, \
                    "Software\\Microsoft\\VisualStudio\\$$MSVC_VER\\Setup\\VC\\ProductDir", 32)
            isEmpty(dir): \
                error("Failed to find the Visual C installation directory.")
            cmd += $$system_quote($$dir\\vcvarsall.bat) $$arch
        }
        winrt: cmd += store

        isEmpty(WINSDK_VER): \
            error("Mkspec does not specify WINSDK_VER. Cannot continue.")
        # We prefer the environment variable, because that may work around
        # a broken registry entry after uninstalling a newer SDK.
        # However, we do that only if the major+minor SDK version matches
        # the one requested by the mkspec, as we might be building for a
        # newer target than the host.
        winsdk_ver = $$(WindowsSDKVersion)
        !isEmpty(winsdk_ver) {
            winsdk_ver ~= s,\\\\$,,  # Work around SDK breakage.
            !equals(WINSDK_VER, $$replace(winsdk_ver, ^(\\d+\\.\\d+).*$, \\1)): \
                winsdk_ver =
        }
        !isEmpty(winsdk_ver) {
            cmd += $$winsdk_ver
        } else {
            winsdk_ver = $$read_registry(HKLM, \
                "Software\\Microsoft\\Microsoft SDKs\\Windows\\v$$WINSDK_VER\\ProductVersion", 32)
            isEmpty(winsdk_ver): \
                error("Windows SDK $$WINSDK_VER requested by mkspec is not installed. Cannot continue.")
            cmd += $${winsdk_ver}.0
        }

        output = $$system("$$cmd 2>&1", lines, ec)
        !equals(ec, 0): \
            qtToolchainError("SDK setup script failed. Output:", $$output, \
                             "Command was: $$cmd")
        lines = $$output
        for(ever) {
            isEmpty(lines): \
                break()
            line = $$take_first(lines)
            equals(line, "=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="): \
                break()
        }
        !count(lines, 3): \
            qtToolchainError("SDK setup script returned unexpected output:", $$output, \
                             "Command was: $$cmd")

        # These contain only paths for the target.
        QMAKE_DEFAULT_INCDIRS = $$qtSplitPathList($$member(lines, 0))
        QMAKE_DEFAULT_LIBDIRS = $$qtSplitPathList($$member(lines, 1))
        # PATH is inherently for the host, and paths that are not shadowed
        # by vcvarsall.bat are assumed to contain only tools that work for
        # both host and target builds.
        QMAKE_DEFAULT_PATH = $$qtSplitPathList($$member(lines, 2))
        # We de-duplicate, because the script just prepends to the paths for
        # the host, some of which are identical to the ones for the target.
        QMAKE_DEFAULT_PATH = $$unique(QMAKE_DEFAULT_PATH)
    } else: msvc {
        LIB = $$getenv("LIB")
        QMAKE_DEFAULT_LIBDIRS = $$split(LIB, $$QMAKE_DIRLIST_SEP)
        INCLUDE = $$getenv("INCLUDE")
        QMAKE_DEFAULT_INCDIRS = $$split(INCLUDE, $$QMAKE_DIRLIST_SEP)
    }

    unix:if(!cross_compile|host_build) {
        isEmpty(QMAKE_DEFAULT_INCDIRS): QMAKE_DEFAULT_INCDIRS = /usr/include /usr/local/include
        isEmpty(QMAKE_DEFAULT_LIBDIRS): QMAKE_DEFAULT_LIBDIRS = /lib /usr/lib
    }

    # cache() complains about undefined variables and doesn't persist empty ones.
    !isEmpty(QMAKE_DEFAULT_INCDIRS): \
        cache($${target_prefix}.INCDIRS, set stash, QMAKE_DEFAULT_INCDIRS)
    !isEmpty(QMAKE_DEFAULT_LIBDIRS): \
        cache($${target_prefix}.LIBDIRS, set stash, QMAKE_DEFAULT_LIBDIRS)
    !isEmpty(QMAKE_DEFAULT_PATH): \
        cache($${target_prefix}.PATH, set stash, QMAKE_DEFAULT_PATH)
} else {
    QMAKE_DEFAULT_INCDIRS = $$eval($${target_prefix}.INCDIRS)
    QMAKE_DEFAULT_LIBDIRS = $$eval($${target_prefix}.LIBDIRS)
    QMAKE_DEFAULT_PATH = $$eval($${target_prefix}.PATH)
}

msvc_cross {
    qmake_inc_exp.name = INCLUDE
    qmake_inc_exp.value = $$qtNmakePathList($$QMAKE_DEFAULT_INCDIRS)
    qmake_lib_exp.name = LIB
    qmake_lib_exp.value = $$qtNmakePathList($$QMAKE_DEFAULT_LIBDIRS)
    qmake_path_exp.name = PATH
    qmake_path_exp.value = $$qtNmakePathList($$QMAKE_DEFAULT_PATH)
    QMAKE_EXPORTED_VARIABLES += qmake_inc_exp qmake_lib_exp qmake_path_exp
}

unset(target_prefix)
