qt5base-lts/configure.pri

# this must be done outside any function
QT_SOURCE_TREE = $$PWD
QT_BUILD_TREE = $$shadowed($$PWD)

# custom command line handling

defineTest(qtConfCommandline_qmakeArgs) {
    contains(1, QMAKE_[A-Z0-9_]+ *[-+]?=.*) {
        config.input.qmakeArgs += $$1
        export(config.input.qmakeArgs)
        return(true)
    }
    return(false)
}

defineTest(qtConfCommandline_cxxstd) {
    arg = $${1}
    val = $${2}
    isEmpty(val): val = $$qtConfGetNextCommandlineArg()
    !contains(val, "^-.*"):!isEmpty(val) {
        contains(val, "(c\+\+)?11") {
            qtConfCommandlineSetInput("c++14", "no")
            qtConfCommandlineSetInput("c++1z", "no")
            qtConfCommandlineSetInput("c++2a", "no")
        } else: contains(val, "(c\+\+)?(14|1y)") {
            qtConfCommandlineSetInput("c++14", "yes")
            qtConfCommandlineSetInput("c++1z", "no")
            qtConfCommandlineSetInput("c++2a", "no")
        } else: contains(val, "(c\+\+)?(17|1z)") {
            qtConfCommandlineSetInput("c++14", "yes")
            qtConfCommandlineSetInput("c++1z", "yes")
            qtConfCommandlineSetInput("c++2a", "no")
        } else: contains(val, "(c\+\+)?(2a)") {
            qtConfCommandlineSetInput("c++14", "yes")
            qtConfCommandlineSetInput("c++1z", "yes")
            qtConfCommandlineSetInput("c++2a", "yes")
        } else {
            qtConfAddError("Invalid argument $$val to command line parameter $$arg")
        }
    } else {
        qtConfAddError("Missing argument to command line parameter $$arg")
    }
}

defineTest(qtConfCommandline_sanitize) {
    arg = $${1}
    val = $${2}
    isEmpty(val): val = $$qtConfGetNextCommandlineArg()
    !contains(val, "^-.*"):!isEmpty(val) {
        equals(val, "address") {
            qtConfCommandlineSetInput("sanitize_address", "yes")
        } else: equals(val, "thread") {
            qtConfCommandlineSetInput("sanitize_thread", "yes")
        } else: equals(val, "memory") {
            qtConfCommandlineSetInput("sanitize_memory", "yes")
        } else: equals(val, "fuzzer-no-link") {
            qtConfCommandlineSetInput("sanitize_fuzzer_no_link", "yes")
        } else: equals(val, "undefined") {
            qtConfCommandlineSetInput("sanitize_undefined", "yes")
        } else {
            qtConfAddError("Invalid argument $$val to command line parameter $$arg")
        }
    } else {
        qtConfAddError("Missing argument to command line parameter $$arg")
    }
}

defineTest(qtConfCommandline_coverage) {
    arg = $${1}
    val = $${2}
    isEmpty(val): val = $$qtConfGetNextCommandlineArg()
    !contains(val, "^-.*"):!isEmpty(val) {
        equals(val, "trace-pc-guard") {
            qtConfCommandlineSetInput("coverage_trace_pc_guard", "yes")
        } else: equals(val, "source-based") {
            qtConfCommandlineSetInput("coverage_source_based", "yes")
        } else: {
            qtConfAddError("Invalid argument $$val to command line parameter $$arg")
        }
    } else {
        qtConfAddError("Missing argument to command line parameter $$arg")
    }
}

# callbacks

defineReplace(qtConfFunc_crossCompile) {
    !isEmpty(config.input.xplatform): return(true)
    !isEmpty(config.input.device-option): return(true)
    !isEmpty(config.input.sysroot): return(true)
    spec = $$[QMAKE_SPEC]
    !equals(spec, $$[QMAKE_XSPEC]): return(true)
    return(false)
}

defineReplace(qtConfFunc_licenseCheck) {
    exists($$QT_SOURCE_TREE/LICENSE.LGPL3)|exists($$QT_SOURCE_TREE/LICENSE.GPL2)|exists($$QT_SOURCE_TREE/LICENSE.GPL3): \
        hasOpenSource = true
    else: \
        hasOpenSource = false
    exists($$QT_SOURCE_TREE/LICENSE.QT-LICENSE-AGREEMENT): \
        hasCommercial = true
    else: \
        hasCommercial = false

    commercial = $$config.input.commercial
    isEmpty(commercial) {
        $$hasOpenSource {
            $$hasCommercial {
                logn()
                logn("Selecting Qt Edition.")
                logn()
                logn("Type 'c' if you want to use the Commercial Edition.")
                logn("Type 'o' if you want to use the Open Source Edition.")
                logn()
                for(ever) {
                    val = $$lower($$prompt("Which edition of Qt do you want to use? ", false))
                    equals(val, c) {
                        commercial = yes
                        QMAKE_SAVED_ARGS += -commercial
                    } else: equals(val, o) {
                        commercial = no
                        QMAKE_SAVED_ARGS += -opensource
                    } else {
                        next()
                    }
                    export(QMAKE_SAVED_ARGS)
                    break()
                }
            } else {
                commercial = no
            }
        } else {
            !$$hasCommercial: \
                qtConfFatalError("No license files. Cannot proceed. Try re-installing Qt.")
            commercial = yes
        }
    }

    equals(commercial, no) {
        !$$hasOpenSource: \
            qtConfFatalError("This is the Qt Commercial Edition." \
                             "Cannot proceed with -opensource.")

        logn()
        logn("This is the Qt Open Source Edition.")

        EditionString = "Open Source"
        config.input.qt_edition = OpenSource
        export(config.input.qt_edition)
    } else {
        !$$hasCommercial: \
            qtConfFatalError("This is the Qt Open Source Edition." \
                             "Cannot proceed with -commercial.")

        !exists($$QT_SOURCE_TREE/.release-timestamp) {
            #  Build from git

            logn()
            logn("This is the Qt Commercial Edition.")

            EditionString = "Commercial"
            config.input.qt_edition = Commercial
            export(config.input.qt_edition)
        } else {
            # Build from a released source package

            equals(QMAKE_HOST.os, Linux) {
                !equals(QMAKE_HOST.arch, x86_64): \
                    Licheck = licheck32
                else: \
                    Licheck = licheck64
            } else: equals(QMAKE_HOST.os, Darwin) {
                Licheck = licheck_mac
            } else: equals(QMAKE_HOST.os, Windows) {
                Licheck = licheck.exe
            } else {
                qtConfFatalError("Host operating system not supported by this edition of Qt.")
            }

            !qtRunLoggedCommand("$$system_quote($$QT_SOURCE_TREE/bin/$$Licheck) \
                                    $$system_quote($$eval(config.input.confirm-license)) \
                                    $$system_quote($$QT_SOURCE_TREE) $$system_quote($$QT_BUILD_TREE) \
                                    $$[QMAKE_SPEC] $$[QMAKE_XSPEC]", \
                                LicheckOutput, false): \
                return(false)
            logn()
            for (o, LicheckOutput) {
                contains(o, "\\w+=.*"): \
                    eval($$o)
                else: \
                    logn($$o)
            }
            config.input.qt_edition = $$Edition
            config.input.qt_licheck = $$Licheck
            config.input.qt_release_date = $$ReleaseDate
            export(config.input.qt_edition)
            export(config.input.qt_licheck)
            export(config.input.qt_release_date)
            return(true)
        }
    }

    !isEmpty(config.input.confirm-license) {
        logn()
        logn("You have already accepted the terms of the $$EditionString license.")
        return(true)
    }

    affix = the
    equals(commercial, no) {
        theLicense = "GNU Lesser General Public License (LGPL) version 3"
        showWhat = "Type 'L' to view the GNU Lesser General Public License version 3 (LGPLv3)."
        gpl2Ok = false
        gpl3Ok = false
        wasm {
            gpl3Ok = true
            theLicense = "GNU General Public License (GPL) version 3"
            showWhat = "Type 'G' to view the GNU General Public License version 3 (GPLv3)."
        } else: $$qtConfEvaluate("features.android-style-assets") {
            notTheLicense = "Note: GPL version 2 is not available due to using Android style assets."
        } else {
            theLicense += "or the GNU General Public License (GPL) version 2"
            showWhat += "Type 'G' to view the GNU General Public License version 2 (GPLv2)."
            gpl2Ok = true
            affix = either
        }
    } else {
        theLicense = $$cat($$QT_SOURCE_TREE/LICENSE.QT-LICENSE-AGREEMENT, lines)
        theLicense = $$first(theLicense)
        showWhat = "Type '?' to view the $${theLicense}."
    }
    msg = \
        " " \
        "You are licensed to use this software under the terms of" \
        "the "$$theLicense"." \
        $$notTheLicense \
        " " \
        $$showWhat \
        "Type 'y' to accept this license offer." \
        "Type 'n' to decline this license offer." \
        " "

    for(ever) {
        logn($$join(msg, $$escape_expand(\\n)))
        for(ever) {
            val = $$lower($$prompt("Do you accept the terms of $$affix license? ", false))
            equals(val, y)|equals(val, yes) {
                logn()
                QMAKE_SAVED_ARGS += -confirm-license
                export(QMAKE_SAVED_ARGS)
                return(true)
            } else: equals(val, n)|equals(val, no) {
                return(false)
            } else: equals(commercial, yes):equals(val, ?) {
                licenseFile = $$QT_SOURCE_TREE/LICENSE.QT-LICENSE-AGREEMENT
            } else: equals(commercial, no):equals(val, l) {
                licenseFile = $$QT_SOURCE_TREE/LICENSE.LGPL3
            } else: equals(commercial, no):equals(val, g):$$gpl2Ok {
                licenseFile = $$QT_SOURCE_TREE/LICENSE.GPL2
            } else: equals(commercial, no):equals(val, g):$$gpl3Ok {
                licenseFile = $$QT_SOURCE_TREE/LICENSE.GPL3
            } else {
                next()
            }
            break()
        }
        system("more $$system_quote($$system_path($$licenseFile))")
        logn()
        logn()
    }
}

# custom tests

# this is meant for linux device specs only
defineTest(qtConfTest_machineTuple) {
    qtRunLoggedCommand("$$QMAKE_CXX -dumpmachine", $${1}.tuple)|return(false)
    $${1}.cache += tuple
    export($${1}.cache)
    return(true)
}

defineTest(qtConfTest_verifySpec) {
    qtConfTest_compile($$1): return(true)
    qtConfFatalError("Cannot compile a minimal program. The toolchain or QMakeSpec is broken.", log)
}

defineTest(qtConfTest_architecture) {
    !qtConfTest_compile($${1}): \
        error("Could not determine $$eval($${1}.label). See config.log for details.")

    test = $$eval($${1}.test)
    output = $$eval($${1}.output)
    test_out_dir = $$OUT_PWD/$$basename(QMAKE_CONFIG_TESTS_DIR)/$$test
    test_out_file = $$test_out_dir/$$cat($$test_out_dir/$${output}.target.txt)
    exists($$test_out_file): \
        content = $$cat($$test_out_file, blob)
    else: \
        error("$$eval($${1}.label) detection binary not found.")
    content = $$cat($$test_out_file, blob)

    arch_magic = ".*==Qt=magic=Qt== Architecture:([^\\0]*).*"
    subarch_magic = ".*==Qt=magic=Qt== Sub-architecture:([^\\0]*).*"
    buildabi_magic = ".*==Qt=magic=Qt== Build-ABI:([^\\0]*).*"

    !contains(content, $$arch_magic)|!contains(content, $$subarch_magic)|!contains(content, $$buildabi_magic): \
        error("$$eval($${1}.label) detection binary does not contain expected data.")

    $${1}.arch = $$replace(content, $$arch_magic, "\\1")
    $${1}.subarch = $$replace(content, $$subarch_magic, "\\1")
    $${1}.subarch = $$split($${1}.subarch, " ")
    $${1}.buildabi = $$replace(content, $$buildabi_magic, "\\1")
    export($${1}.arch)
    export($${1}.subarch)
    export($${1}.buildabi)
    qtLog("Detected architecture: $$eval($${1}.arch) ($$eval($${1}.subarch))")

    $${1}.cache += arch subarch buildabi
    export($${1}.cache)
    return(true)
}

defineTest(qtConfTest_gnumake) {
    make = $$qtConfFindInPath("gmake")
    isEmpty(make): make = $$qtConfFindInPath("make")
    !isEmpty(make) {
        qtRunLoggedCommand("$$make -v", version)|return(false)
        contains(version, "^GNU Make.*"): return(true)
    }
    return(false)
}

defineTest(qtConfTest_detectPkgConfig) {
    pkgConfig = $$getenv("PKG_CONFIG")
    !isEmpty(pkgConfig): {
        qtLog("Found pkg-config from environment variable: $$pkgConfig")
    } else {
        pkgConfig = $$QMAKE_PKG_CONFIG

        !isEmpty(pkgConfig) {
            qtLog("Found pkg-config from mkspec: $$pkgConfig")
        } else {
            pkgConfig = $$qtConfFindInPath("pkg-config")

            isEmpty(pkgConfig): \
                return(false)

            qtLog("Found pkg-config from path: $$pkgConfig")
        }
    }

    $$qtConfEvaluate("features.cross_compile") {
        # cross compiling, check that pkg-config is set up sanely
        sysroot = $$config.input.sysroot

        pkgConfigLibdir = $$getenv("PKG_CONFIG_LIBDIR")
        isEmpty(pkgConfigLibdir) {
            isEmpty(sysroot) {
                qtConfAddWarning("Cross compiling without sysroot. Disabling pkg-config")
                return(false)
            }
            !exists("$$sysroot/usr/lib/pkgconfig") {
                qtConfAddWarning( \
                    "Disabling pkg-config since PKG_CONFIG_LIBDIR is not set and" \
                    "the host's .pc files would be used (even if you set PKG_CONFIG_PATH)." \
                    "Set this variable to the directory that contains target .pc files" \
                    "for pkg-config to function correctly when cross-compiling or" \
                    "use -pkg-config to override this test.")
                return(false)
            }

            pkgConfigLibdir = $$sysroot/usr/lib/pkgconfig:$$sysroot/usr/share/pkgconfig
            machineTuple = $$eval($${currentConfig}.tests.machineTuple.tuple)
            !isEmpty(machineTuple): \
                pkgConfigLibdir = "$$pkgConfigLibdir:$$sysroot/usr/lib/$$machineTuple/pkgconfig"

            qtConfAddNote("PKG_CONFIG_LIBDIR automatically set to $$pkgConfigLibdir")
        }
        pkgConfigSysrootDir = $$getenv("PKG_CONFIG_SYSROOT_DIR")
        isEmpty(pkgConfigSysrootDir) {
            isEmpty(sysroot) {
                qtConfAddWarning( \
                    "Disabling pkg-config since PKG_CONFIG_SYSROOT_DIR is not set." \
                    "Set this variable to your sysroot for pkg-config to function correctly when" \
                    "cross-compiling or use -pkg-config to override this test.")
                return(false)
            }

            pkgConfigSysrootDir = $$sysroot
            qtConfAddNote("PKG_CONFIG_SYSROOT_DIR automatically set to $$pkgConfigSysrootDir")
        }
        $${1}.pkgConfigLibdir = $$pkgConfigLibdir
        export($${1}.pkgConfigLibdir)
        $${1}.pkgConfigSysrootDir = $$pkgConfigSysrootDir
        export($${1}.pkgConfigSysrootDir)
        $${1}.cache += pkgConfigLibdir pkgConfigSysrootDir
    }
    $${1}.pkgConfig = $$pkgConfig
    export($${1}.pkgConfig)
    $${1}.cache += pkgConfig
    export($${1}.cache)

    return(true)
}

defineTest(qtConfTest_buildParts) {
    parts = $$config.input.make
    isEmpty(parts) {
        parts = libs examples

        $$qtConfEvaluate("features.developer-build"): \
            parts += tests
        !$$qtConfEvaluate("features.cross_compile"): \
            parts += tools
    }

    parts -= $$config.input.nomake

    # always add libs, as it's required to build Qt
    parts *= libs

    $${1}.value = $$parts
    export($${1}.value)
    $${1}.cache = -
    export($${1}.cache)
    return(true)
}

defineTest(qtConfTest_x86Simd) {
    simd = $$section(1, ".", -1)    # last component
    $${1}.args = CONFIG+=add_cflags DEFINES+=NO_ATTRIBUTE SIMD=$$simd
    $${1}.test = x86_simd
    qtConfTest_compile($${1})
}

defineTest(qtConfTest_x86SimdAlways) {
    configs =
    fpfx = $${currentConfig}.features
    tpfx = $${currentConfig}.tests

    # Make a list of all passing features whose tests have type=x86Simd
    for (f, $${tpfx}._KEYS_) {
        !equals($${tpfx}.$${f}.type, "x86Simd"): \
            next()
        qtConfCheckFeature($$f)
        equals($${fpfx}.$${f}.available, true): configs += $$f
    }
    $${1}.literal_args = SIMD=$$join(configs, " ")
    qtConfTest_compile($${1})
}

# custom outputs

# this reloads the qmakespec as completely as reasonably possible.
defineTest(reloadSpec) {
    bypassNesting() {
        for (f, QMAKE_INTERNAL_INCLUDED_FILES) {
            contains(f, .*/mkspecs/.*):\
                    !contains(f, .*/(qt_build_config|qt_parts|qt_configure|configure_base)\\.prf): \
                discard_from($$f)
        }
        # nobody's going to try to re-load the features above,
        # so don't bother with being selective.
        QMAKE_INTERNAL_INCLUDED_FEATURES = \
            # loading it gets simulated below.
            $$[QT_HOST_DATA/src]/mkspecs/features/device_config.prf \
            # must be delayed until qdevice.pri is ready.
            $$[QT_HOST_DATA/src]/mkspecs/features/mac/toolchain.prf \
            $$[QT_HOST_DATA/src]/mkspecs/features/toolchain.prf

        saved_variables = CONFIG QMAKE_CXXFLAGS
        for (name, saved_variables): \
            _SAVED_$$name = $$eval($$name)
        load(spec_pre)
        # qdevice.pri gets written too late (and we can't write it early
        # enough, as it's populated in stages, with later ones depending
        # on earlier ones). so inject its variables manually.
        for (l, $${currentConfig}.output.devicePro): \
            eval($$l)
        include($$QMAKESPEC/qmake.conf)
        load(spec_post)
        for (name, saved_variables): \
            $$name += $$eval(_SAVED_$$name)
        load(default_pre)

        # ensure pristine environment for configuration. again.
        discard_from($$[QT_HOST_DATA/get]/mkspecs/qconfig.pri)
        discard_from($$[QT_HOST_DATA/get]/mkspecs/qmodule.pri)
    }
}

defineTest(qtConfOutput_prepareSpec) {
    device = $$eval(config.input.device)
    !isEmpty(device) {
        devices = $$files($$[QT_HOST_DATA/src]/mkspecs/devices/*$$device*)
        isEmpty(devices): \
            qtConfFatalError("No device matching '$$device'.")
        !count(devices, 1) {
            err = "Multiple matches for device '$$device'. Candidates are:"
            for (d, devices): \
                err += "    $$basename(d)"
            qtConfFatalError($$err)
        }
        XSPEC = $$relative_path($$devices, $$[QT_HOST_DATA/src]/mkspecs)
    }
    xspec = $$eval(config.input.xplatform)
    !isEmpty(xspec) {
        !exists($$[QT_HOST_DATA/src]/mkspecs/$$xspec/qmake.conf): \
            qtConfFatalError("Invalid target platform '$$xspec'.")
        XSPEC = $$xspec
    }
    isEmpty(XSPEC): \
        XSPEC = $$[QMAKE_SPEC]
    export(XSPEC)
    QMAKESPEC = $$[QT_HOST_DATA/src]/mkspecs/$$XSPEC
    export(QMAKESPEC)

    notes = $$cat($$OUT_PWD/.config.notes, lines)
    !isEmpty(notes): \
        qtConfAddNote("Also available for $$notes")

    # deviceOptions() below contains conditionals coming form the spec,
    # so this cannot be delayed for a batch reload.
    reloadSpec()
}

defineTest(qtConfOutput_prepareOptions) {
    $${currentConfig}.output.devicePro += \
        $$replace(config.input.device-option, "^([^=]+) *= *(.*)$", "\\1 = \\2")
    darwin:!isEmpty(config.input.sdk) {
        $${currentConfig}.output.devicePro += \
            "QMAKE_MAC_SDK = $$val_escape(config.input.sdk)"
    }
    android {
        sdk_root = $$eval(config.input.android-sdk)
        isEmpty(sdk_root): \
            sdk_root = $$getenv(ANDROID_SDK_ROOT)
        isEmpty(sdk_root) {
            for(ever) {
                equals(QMAKE_HOST.os, Linux): \
                    sdk_root = $$(HOME)/Android/Sdk
                else: equals(QMAKE_HOST.os, Darwin): \
                    sdk_root = $$(HOME)/Library/Android/sdk
                else: \
                    break()
                !exists($$sdk_root): \
                    sdk_root =
                break()
            }
        }
        isEmpty(sdk_root): \
            qtConfFatalError("Cannot find Android SDK." \
                             "Please use -android-sdk option to specify one.")

        ndk_root = $$eval(config.input.android-ndk)
        isEmpty(ndk_root): \
            ndk_root = $$getenv(ANDROID_NDK_ROOT)
        isEmpty(ndk_root) {
            for(ever) {
                exists($$sdk_root/ndk-bundle) {
                    ndk_root = $$sdk_root/ndk-bundle
                    break()
                }
                equals(QMAKE_HOST.os, Linux): \
                    ndk_root = $$(HOME)/Android/Sdk/ndk-bundle
                else: equals(QMAKE_HOST.os, Darwin): \
                    ndk_root = $$(HOME)/Library/Android/sdk/ndk-bundle
                else: \
                    break()
                !exists($$ndk_root): \
                    ndk_root =
                break()
            }
        }
        isEmpty(ndk_root): \
            qtConfFatalError("Cannot find Android NDK." \
                             "Please use -android-ndk option to specify one.")

        ndk_tc_pfx = $$ndk_root/toolchains/llvm/prebuilt
        ndk_host = $$eval(config.input.android-ndk-host)
        isEmpty(ndk_host): \
            ndk_host = $$getenv(ANDROID_NDK_HOST)
        isEmpty(ndk_host) {
            equals(QMAKE_HOST.os, Linux) {
                ndk_host_64 = linux-x86_64
                ndk_host_32 = linux-x86
            } else: equals(QMAKE_HOST.os, Darwin) {
                ndk_host_64 = darwin-x86_64
                ndk_host_32 = darwin-x86
            } else: equals(QMAKE_HOST.os, Windows) {
                ndk_host_64 = windows-x86_64
                ndk_host_32 = windows
            } else {
                qtConfFatalError("Host operating system not supported by Android.")
            }
            !exists($$ndk_tc_pfx/$$ndk_host_64/*): ndk_host_64 =
            !exists($$ndk_tc_pfx/$$ndk_host_32/*): ndk_host_32 =
            equals(QMAKE_HOST.arch, x86_64):!isEmpty(ndk_host_64) {
                ndk_host = $$ndk_host_64
            } else: equals(QMAKE_HOST.arch, x86):!isEmpty(ndk_host_32) {
                ndk_host = $$ndk_host_32
            } else {
                !isEmpty(ndk_host_64): \
                    ndk_host = $$ndk_host_64
                else: !isEmpty(ndk_host_32): \
                    ndk_host = $$ndk_host_32
                else: \
                    qtConfFatalError("Cannot detect the Android host." \
                                     "Please use -android-ndk-host option to specify one.")
                qtConfAddNote("Available Android host does not match host architecture.")
            }
        } else {
            !exists($$ndk_tc_pfx/$$ndk_host/*) {
                err = "Specified Android NDK host '$$ndk_host' is invalid. Expected files in the following directory to exist:"
                err += '$${ndk_tc_pfx}/$${ndk_host}/'
                qtConfFatalError($$err)
            }
        }

        android_abis = $$eval(config.input.android-abis)
        isEmpty(android_abis): \
            android_abis = $$eval(config.input.android-arch)
        isEmpty(android_abis): \
            android_abis = armeabi-v7a,arm64-v8a,x86,x86_64
        platform = $$eval(config.input.android-ndk-platform)
        isEmpty(platform): \
            platform = android-23

        $${currentConfig}.output.devicePro += \
            "DEFAULT_ANDROID_SDK_ROOT = $$val_escape(sdk_root)" \
            "DEFAULT_ANDROID_NDK_ROOT = $$val_escape(ndk_root)" \
            "DEFAULT_ANDROID_PLATFORM = $$platform" \
            "DEFAULT_ANDROID_NDK_HOST = $$ndk_host" \
            "DEFAULT_ANDROID_ABIS = $$split(android_abis, ',')"
    }

    export($${currentConfig}.output.devicePro)

    # if any settings were made, the spec will be reloaded later
    # to make them take effect.
}

defineTest(qtConfOutput_machineTuple) {
    $${currentConfig}.output.devicePro += \
        "GCC_MACHINE_DUMP = $$eval($${currentConfig}.tests.machineTuple.tuple)"
    export($${currentConfig}.output.devicePro)

    # for completeness, one could reload the spec here,
    # but no downstream users actually need that.
}

defineTest(qtConfOutput_commitOptions) {
    # qdevice.pri needs to be written early, because the compile tests require it.
    write_file($$QT_BUILD_TREE/mkspecs/qdevice.pri, $${currentConfig}.output.devicePro)|error()
}

# type (empty or 'host'), option name, default value
defineTest(processQtPath) {
    out_var = config.rel_input.$${2}
    path = $$eval(config.input.$${2})
    isEmpty(path) {
        $$out_var = $$3
    } else {
        path = $$absolute_path($$path, $$OUT_PWD)
        rel = $$relative_path($$path, $$eval(config.input.$${1}prefix))
        isEmpty(rel) {
            $$out_var = .
        } else: contains(rel, \.\..*) {
            !equals(2, sysconfdir) {
                PREFIX_COMPLAINTS += "-$$2 is not a subdirectory of -$${1}prefix."
                export(PREFIX_COMPLAINTS)
                !$$eval(have_$${1}prefix) {
                    PREFIX_REMINDER = true
                    export(PREFIX_REMINDER)
                }
            }
            $$out_var = $$path
        } else {
            $$out_var = $$rel
        }
    }
    export($$out_var)
}

defineTest(addConfStr) {
    QT_CONFIGURE_STR_OFFSETS += "    $$QT_CONFIGURE_STR_OFF,"
    QT_CONFIGURE_STRS += "    \"$$1\\0\""
    QT_CONFIGURE_STR_OFF = $$num_add($$QT_CONFIGURE_STR_OFF, $$str_size($$1), 1)
    export(QT_CONFIGURE_STR_OFFSETS)
    export(QT_CONFIGURE_STRS)
    export(QT_CONFIGURE_STR_OFF)
}

defineReplace(printInstallPath) {
    val = $$eval(config.rel_input.$$2)
    equals(val, $$3): return()
    return("$$1=$$val")
}

defineReplace(printInstallPaths) {
    ret = \
        $$printInstallPath(Documentation, docdir, doc) \
        $$printInstallPath(Headers, headerdir, include) \
        $$printInstallPath(Libraries, libdir, lib) \
        $$printInstallPath(LibraryExecutables, libexecdir, $$DEFAULT_LIBEXEC) \
        $$printInstallPath(Binaries, bindir, bin) \
        $$printInstallPath(Plugins, plugindir, plugins) \
        $$printInstallPath(Qml2Imports, qmldir, qml) \
        $$printInstallPath(ArchData, archdatadir, .) \
        $$printInstallPath(Data, datadir, .) \
        $$printInstallPath(Translations, translationdir, translations) \
        $$printInstallPath(Examples, examplesdir, examples) \
        $$printInstallPath(Tests, testsdir, tests)
    return($$ret)
}

defineReplace(printHostPaths) {
    ret = \
        "HostPrefix=$$config.input.hostprefix" \
        $$printInstallPath(HostBinaries, hostbindir, bin) \
        $$printInstallPath(HostLibraries, hostlibdir, lib) \
        $$printInstallPath(HostData, hostdatadir, .) \
        "Sysroot=$$config.input.sysroot" \
        "SysrootifyPrefix=$$qmake_sysrootify" \
        "TargetSpec=$$XSPEC" \
        "HostSpec=$$[QMAKE_SPEC]"
    return($$ret)
}

defineTest(qtConfOutput_preparePaths) {
    isEmpty(config.input.prefix) {
        $$qtConfEvaluate("features.developer-build") {
            config.input.prefix = $$QT_BUILD_TREE  # In Development, we use sandboxed builds by default
        } else {
            win32: \
                config.input.prefix = C:/Qt/Qt-$$[QT_VERSION]
            else: \
                config.input.prefix = /usr/local/Qt-$$[QT_VERSION]
        }
        have_prefix = false
    } else {
        equals(XSPEC, $$[QMAKE_SPEC]) {
            # Only make the user-specified prefix absolute if we're not cross-compiling.
            config.input.prefix = $$absolute_path($$config.input.prefix, $$OUT_PWD)
        } else {
            # But we still must normalize path separators.
            config.input.prefix = $$replace(config.input.prefix, \\\\, /)
        }
        have_prefix = true
    }

    isEmpty(config.input.extprefix) {
        config.input.extprefix = $$config.input.prefix
        !isEmpty(config.input.sysroot): \
            qmake_sysrootify = true
        else: \
            qmake_sysrootify = false
    } else {
        config.input.extprefix = $$absolute_path($$config.input.extprefix, $$OUT_PWD)
        qmake_sysrootify = false
    }

    isEmpty(config.input.hostprefix) {
        $$qmake_sysrootify: \
            config.input.hostprefix = $$config.input.sysroot$$config.input.extprefix
        else: \
            config.input.hostprefix = $$config.input.extprefix
        have_hostprefix = false
    } else {
        isEqual(config.input.hostprefix, yes): \
            config.input.hostprefix = $$QT_BUILD_TREE
        else: \
            config.input.hostprefix = $$absolute_path($$config.input.hostprefix, $$OUT_PWD)
        have_hostprefix = true
    }

    equals(config.input.prefix, $$config.input.extprefix): \
        qmake_crossbuild = false
    else: \
        qmake_crossbuild = true

    PREFIX_COMPLAINTS =
    PREFIX_REMINDER = false
    win32: \
        DEFAULT_LIBEXEC = bin
    else: \
        DEFAULT_LIBEXEC = libexec
    darwin: \
        DEFAULT_SYSCONFDIR = /Library/Preferences/Qt
    else: \
        DEFAULT_SYSCONFDIR = etc/xdg

    processQtPath("", headerdir, include)
    processQtPath("", libdir, lib)
    processQtPath("", bindir, bin)
    processQtPath("", datadir, .)
    !equals(config.rel_input.datadir, .): \
        data_pfx = $$config.rel_input.datadir/
    processQtPath("", docdir, $${data_pfx}doc)
    processQtPath("", translationdir, $${data_pfx}translations)
    processQtPath("", examplesdir, $${data_pfx}examples)
    processQtPath("", testsdir, tests)
    processQtPath("", archdatadir, .)
    !equals(config.rel_input.archdatadir, .): \
        archdata_pfx = $$config.rel_input.archdatadir/
    processQtPath("", libexecdir, $${archdata_pfx}$$DEFAULT_LIBEXEC)
    processQtPath("", plugindir, $${archdata_pfx}plugins)
    processQtPath("", qmldir, $${archdata_pfx}qml)
    processQtPath("", sysconfdir, $$DEFAULT_SYSCONFDIR)
    $$have_hostprefix {
        processQtPath(host, hostbindir, bin)
        processQtPath(host, hostlibdir, lib)
        processQtPath(host, hostdatadir, .)
    } else {
        processQtPath(host, hostbindir, $$config.rel_input.bindir)
        processQtPath(host, hostlibdir, $$config.rel_input.libdir)
        processQtPath(host, hostdatadir, $$config.rel_input.archdatadir)
    }

    win32:$$qtConfEvaluate("features.shared") {
        # Windows DLLs are in the bin dir.
        libloc_absolute_path = $$absolute_path($$config.rel_input.bindir, $$config.input.prefix)
    } else {
        libloc_absolute_path = $$absolute_path($$config.rel_input.libdir, $$config.input.prefix)
    }
    config.input.liblocation_to_prefix = $$relative_path($$config.input.prefix, $$libloc_absolute_path)
    config.qtbase.features.shared.available =
    export(config.qtbase.features.shared.available)

    hostbindir_absolute_path = $$absolute_path($$config.rel_input.hostbindir, $$config.input.hostprefix)
    config.input.hostbindir_to_hostprefix = $$relative_path($$config.input.hostprefix, $$hostbindir_absolute_path)
    config.input.hostbindir_to_extprefix = $$relative_path($$config.input.extprefix, $$hostbindir_absolute_path)

    !isEmpty(PREFIX_COMPLAINTS) {
        PREFIX_COMPLAINTS = "$$join(PREFIX_COMPLAINTS, "$$escape_expand(\\n)Note: ")"
        $$PREFIX_REMINDER: \
            PREFIX_COMPLAINTS += "Maybe you forgot to specify -prefix/-hostprefix?"
        qtConfAddNote($$PREFIX_COMPLAINTS)
    }

    # populate qconfig.cpp (for qtcore)

    QT_CONFIGURE_STR_OFF = 0
    QT_CONFIGURE_STR_OFFSETS =
    QT_CONFIGURE_STRS =

    addConfStr($$config.rel_input.docdir)
    addConfStr($$config.rel_input.headerdir)
    addConfStr($$config.rel_input.libdir)
    addConfStr($$config.rel_input.libexecdir)
    addConfStr($$config.rel_input.bindir)
    addConfStr($$config.rel_input.plugindir)
    addConfStr($$config.rel_input.qmldir)
    addConfStr($$config.rel_input.archdatadir)
    addConfStr($$config.rel_input.datadir)
    addConfStr($$config.rel_input.translationdir)
    addConfStr($$config.rel_input.examplesdir)
    addConfStr($$config.rel_input.testsdir)

    QT_CONFIGURE_STR_OFFSETS_ALL = $$QT_CONFIGURE_STR_OFFSETS
    QT_CONFIGURE_STRS_ALL = $$QT_CONFIGURE_STRS
    QT_CONFIGURE_STR_OFFSETS =
    QT_CONFIGURE_STRS =

    addConfStr($$config.input.sysroot)
    addConfStr($$qmake_sysrootify)
    addConfStr($$config.rel_input.hostbindir)
    addConfStr($$config.rel_input.hostlibdir)
    addConfStr($$config.rel_input.hostdatadir)
    addConfStr($$XSPEC)
    addConfStr($$[QMAKE_SPEC])

    $${currentConfig}.output.qconfigSource = \
        "/* Installation Info */" \
        "static const char qt_configure_prefix_path_str  [12+256] = \"qt_prfxpath=$$config.input.prefix\";" \
        "$${LITERAL_HASH}ifdef QT_BUILD_QMAKE" \
        "static const char qt_configure_ext_prefix_path_str   [12+256] = \"qt_epfxpath=$$config.input.extprefix\";" \
        "static const char qt_configure_host_prefix_path_str  [12+256] = \"qt_hpfxpath=$$config.input.hostprefix\";" \
        "$${LITERAL_HASH}endif" \
        "" \
        "static const short qt_configure_str_offsets[] = {" \
        $$QT_CONFIGURE_STR_OFFSETS_ALL \
        "$${LITERAL_HASH}ifdef QT_BUILD_QMAKE" \
        $$QT_CONFIGURE_STR_OFFSETS \
        "$${LITERAL_HASH}endif" \
        "};" \
        "static const char qt_configure_strs[] =" \
        $$QT_CONFIGURE_STRS_ALL \
        "$${LITERAL_HASH}ifdef QT_BUILD_QMAKE" \
        $$QT_CONFIGURE_STRS \
        "$${LITERAL_HASH}endif" \
        ";" \
        "" \
        "$${LITERAL_HASH}define QT_CONFIGURE_SETTINGS_PATH \"$$config.rel_input.sysconfdir\"" \
        "$${LITERAL_HASH}define QT_CONFIGURE_LIBLOCATION_TO_PREFIX_PATH \"$$config.input.liblocation_to_prefix\"" \
        "$${LITERAL_HASH}define QT_CONFIGURE_HOSTBINDIR_TO_EXTPREFIX_PATH \"$$config.input.hostbindir_to_extprefix\"" \
        "$${LITERAL_HASH}define QT_CONFIGURE_HOSTBINDIR_TO_HOSTPREFIX_PATH \"$$config.input.hostbindir_to_hostprefix\"" \
        "" \
        "$${LITERAL_HASH}ifdef QT_BUILD_QMAKE" \
        "$${LITERAL_HASH} define QT_CONFIGURE_SYSROOTIFY_PREFIX $$qmake_sysrootify" \
        "$${LITERAL_HASH} define QT_CONFIGURE_CROSSBUILD $$qmake_crossbuild" \
        "$${LITERAL_HASH}endif" \
        "" \
        "$${LITERAL_HASH}define QT_CONFIGURE_PREFIX_PATH qt_configure_prefix_path_str + 12" \
        "$${LITERAL_HASH}ifdef QT_BUILD_QMAKE" \
        "$${LITERAL_HASH} define QT_CONFIGURE_EXT_PREFIX_PATH qt_configure_ext_prefix_path_str + 12" \
        "$${LITERAL_HASH} define QT_CONFIGURE_HOST_PREFIX_PATH qt_configure_host_prefix_path_str + 12" \
        "$${LITERAL_HASH}endif"
    export($${currentConfig}.output.qconfigSource)

    # create bin/qt.conf. this doesn't use the regular file output
    # mechanism, as the file is relied upon by configure tests.

    cont = \
        "[EffectivePaths]" \
        "Prefix=.." \
        "[DevicePaths]" \
        "Prefix=$$config.input.prefix" \
        $$printInstallPaths() \
        "[Paths]" \
        "Prefix=$$config.input.extprefix" \
        $$printInstallPaths() \
        $$printHostPaths()
    !equals(QT_SOURCE_TREE, $$QT_BUILD_TREE): \
        cont += \
            "[EffectiveSourcePaths]" \
            "Prefix=$$[QT_INSTALL_PREFIX/src]"
    write_file($$QT_BUILD_TREE/bin/qt.conf, cont)|error()
    reload_properties()

    # if a sysroot was configured, the spec will be reloaded later,
    # as some specs contain $$[SYSROOT] references.
}

defineTest(qtConfOutput_reloadSpec) {
    !isEmpty($${currentConfig}.output.devicePro)| \
            !isEmpty(config.input.sysroot): \
        reloadSpec()

    # toolchain.prf uses this.
    dummy = $$qtConfEvaluate("features.cross_compile")

    bypassNesting() {
        QMAKE_INTERNAL_INCLUDED_FEATURES -= \
            $$[QT_HOST_DATA/src]/mkspecs/features/mac/toolchain.prf \
            $$[QT_HOST_DATA/src]/mkspecs/features/toolchain.prf
        load(toolchain)
    }
}

defineTest(qtConfOutput_shared) {
    !$${2}: return()

    # export this here, so later tests can use it
    CONFIG += shared
    export(CONFIG)
}

defineTest(qtConfOutput_sanitizer) {
    !$${2}: return()

    # Export this here, so that WebEngine can access it at configure time.
    CONFIG += sanitizer
    $$qtConfEvaluate("features.sanitize_address"): CONFIG += sanitize_address
    $$qtConfEvaluate("features.sanitize_thread"): CONFIG += sanitize_thread
    $$qtConfEvaluate("features.sanitize_memory"): CONFIG += sanitize_memory
    $$qtConfEvaluate("features.sanitize_undefined"): CONFIG += sanitize_undefined

    export(CONFIG)
}

defineTest(qtConfOutput_architecture) {
    arch = $$qtConfEvaluate("tests.architecture.arch")
    subarch = $$qtConfEvaluate('tests.architecture.subarch')
    buildabi = $$qtConfEvaluate("tests.architecture.buildabi")

    $$qtConfEvaluate("features.cross_compile") {
        host_arch = $$qtConfEvaluate("tests.host_architecture.arch")
        host_buildabi = $$qtConfEvaluate("tests.host_architecture.buildabi")

        privatePro = \
            "host_build {" \
            "    QT_CPU_FEATURES.$$host_arch = $$qtConfEvaluate('tests.host_architecture.subarch')" \
            "} else {" \
            "    QT_CPU_FEATURES.$$arch = $$subarch" \
            "}"
        publicPro = \
            "host_build {" \
            "    QT_ARCH = $$host_arch" \
            "    QT_BUILDABI = $$host_buildabi" \
            "    QT_TARGET_ARCH = $$arch" \
            "    QT_TARGET_BUILDABI = $$buildabi" \
            "} else {" \
            "    QT_ARCH = $$arch" \
            "    QT_BUILDABI = $$buildabi" \
            "}"

    } else {
        privatePro = \
            "QT_CPU_FEATURES.$$arch = $$subarch"
        publicPro = \
            "QT_ARCH = $$arch" \
            "QT_BUILDABI = $$buildabi"
    }

    $${currentConfig}.output.publicPro += $$publicPro
    export($${currentConfig}.output.publicPro)
    $${currentConfig}.output.privatePro += $$privatePro
    export($${currentConfig}.output.privatePro)

    # setup QT_ARCH and QT_CPU_FEATURES variables used by qtConfEvaluate
    QT_ARCH = $$arch
    export(QT_ARCH)
    QT_CPU_FEATURES.$$arch = $$subarch
    export(QT_CPU_FEATURES.$$arch)
}

defineTest(qtConfOutput_qreal) {
    qreal = $$config.input.qreal
    isEmpty(qreal): qreal = "double"
    qreal_string = $$replace(qreal, [^a-zA-Z0-9], "_")
    qtConfOutputVar(assign, "privatePro", "QT_COORD_TYPE", $$qreal)
    !equals(qreal, "double") {
        qtConfOutputSetDefine("publicHeader", "QT_COORD_TYPE", $$qreal)
        qtConfOutputSetDefine("publicHeader", "QT_COORD_TYPE_STRING", "\"$$qreal_string\"")
    }
}

defineTest(qtConfOutput_pkgConfig) {
    !$${2}: return()

    PKG_CONFIG_EXECUTABLE = $$eval($${currentConfig}.tests.pkg-config.pkgConfig)
    qtConfOutputVar(assign, "privatePro", "PKG_CONFIG_EXECUTABLE", $$PKG_CONFIG_EXECUTABLE)
    export(PKG_CONFIG_EXECUTABLE)
    # this method also exports PKG_CONFIG_(LIB|SYSROOT)DIR, so that tests using pkgConfig will work correctly
    PKG_CONFIG_SYSROOT_DIR = $$eval($${currentConfig}.tests.pkg-config.pkgConfigSysrootDir)
    !isEmpty(PKG_CONFIG_SYSROOT_DIR) {
        qtConfOutputVar(assign, "publicPro", "PKG_CONFIG_SYSROOT_DIR", $$PKG_CONFIG_SYSROOT_DIR)
        export(PKG_CONFIG_SYSROOT_DIR)
    }
    PKG_CONFIG_LIBDIR = $$eval($${currentConfig}.tests.pkg-config.pkgConfigLibdir)
    !isEmpty(PKG_CONFIG_LIBDIR) {
        qtConfOutputVar(assign, "publicPro", "PKG_CONFIG_LIBDIR", $$PKG_CONFIG_LIBDIR)
        export(PKG_CONFIG_LIBDIR)
    }
}

defineTest(qtConfOutput_crossCompile) {
    !$${2}: return()

    # We need to preempt the output here, as subsequent tests rely on it
    CONFIG += cross_compile
    export(CONFIG)
}

defineTest(qtConfOutput_useBFDLinker) {
    !$${2}: return()

    # We need to preempt the output here, so that qtConfTest_linkerSupportsFlag can work properly in qtbase
    CONFIG += use_bfd_linker
    export(CONFIG)
}

defineTest(qtConfOutput_useGoldLinker) {
    !$${2}: return()

    # We need to preempt the output here, so that qtConfTest_linkerSupportsFlag can work properly in qtbase
    CONFIG += use_gold_linker
    export(CONFIG)
}

defineTest(qtConfOutput_useLLDLinker) {
    !$${2}: return()

    # We need to preempt the output here, so that qtConfTest_linkerSupportsFlag can work properly in qtbase
    CONFIG += use_lld_linker
    export(CONFIG)
}

defineTest(qtConfOutput_debugAndRelease) {
    $$qtConfEvaluate("features.debug") {
        qtConfOutputVar(append, "publicPro", "CONFIG", "debug")
        $${2}: qtConfOutputVar(append, "publicPro", "QT_CONFIG", "release")
        qtConfOutputVar(append, "publicPro", "QT_CONFIG", "debug")
    } else {
        qtConfOutputVar(append, "publicPro", "CONFIG", "release")
        $${2}: qtConfOutputVar(append, "publicPro", "QT_CONFIG", "debug")
        qtConfOutputVar(append, "publicPro", "QT_CONFIG", "release")
    }
}

defineTest(qtConfOutput_compilerFlags) {
    # this output also exports the variables locally, so that subsequent compiler tests can use them

    output =
    !isEmpty(config.input.wflags) {
        wflags = $$join(config.input.wflags, " -W", "-W")
        QMAKE_CFLAGS_WARN_ON += $$wflags
        QMAKE_CXXFLAGS_WARN_ON += $$wflags
        export(QMAKE_CFLAGS_WARN_ON)
        export(QMAKE_CXXFLAGS_WARN_ON)
        output += \
            "QMAKE_CFLAGS_WARN_ON += $$wflags" \
            "QMAKE_CXXFLAGS_WARN_ON += $$wflags"
    }
    !isEmpty(config.input.defines) {
        EXTRA_DEFINES += $$config.input.defines
        export(EXTRA_DEFINES)
        output += "EXTRA_DEFINES += $$val_escape(config.input.defines)"
    }
    !isEmpty(config.input.includes) {
        EXTRA_INCLUDEPATH += $$config.input.includes
        export(EXTRA_INCLUDEPATH)
        output += "EXTRA_INCLUDEPATH += $$val_escape(config.input.includes)"
    }

    !isEmpty(config.input.lpaths) {
        EXTRA_LIBDIR += $$config.input.lpaths
        export(EXTRA_LIBDIR)
        output += "EXTRA_LIBDIR += $$val_escape(config.input.lpaths)"
    }
    darwin:!isEmpty(config.input.fpaths) {
        EXTRA_FRAMEWORKPATH += $$config.input.fpaths
        export(EXTRA_FRAMEWORKPATH)
        output += "EXTRA_FRAMEWORKPATH += $$val_escape(config.input.fpaths)"
    }

    $${currentConfig}.output.privatePro += $$output
    export($${currentConfig}.output.privatePro)
}

defineTest(qtConfOutput_gccSysroot) {
    !$${2}: return()

    # This variable also needs to be exported immediately, so the compilation tests
    # can pick it up.
    EXTRA_QMAKE_ARGS += \
        "\"QMAKE_CFLAGS += --sysroot=$$config.input.sysroot\"" \
        "\"QMAKE_CXXFLAGS += --sysroot=$$config.input.sysroot\"" \
        "\"QMAKE_LFLAGS += --sysroot=$$config.input.sysroot\""
    export(EXTRA_QMAKE_ARGS)

    # This one is for qtConfToolchainSupportsFlag().
    QMAKE_CXXFLAGS += --sysroot=$$config.input.sysroot
    export(QMAKE_CXXFLAGS)

    output = \
        "!host_build {" \
        "    QMAKE_CFLAGS    += --sysroot=\$\$[QT_SYSROOT]" \
        "    QMAKE_CXXFLAGS  += --sysroot=\$\$[QT_SYSROOT]" \
        "    QMAKE_LFLAGS    += --sysroot=\$\$[QT_SYSROOT]" \
        "}"
    $${currentConfig}.output.publicPro += $$output
    export($${currentConfig}.output.publicPro)
}

defineTest(qtConfOutput_qmakeArgs) {
    !$${2}: return()

    $${currentConfig}.output.privatePro += "!host_build|!cross_compile {"
    for (a, config.input.qmakeArgs) {
        $${currentConfig}.output.privatePro += "    $$a"
        EXTRA_QMAKE_ARGS += $$system_quote($$a)
    }
    $${currentConfig}.output.privatePro += "}"
    export(EXTRA_QMAKE_ARGS)
    export($${currentConfig}.output.privatePro)
}

defineReplace(qtConfOutputPostProcess_publicPro) {
    qt_version = $$[QT_VERSION]
    output = \
        $$1 \
        "QT_VERSION = $$qt_version" \
        "QT_MAJOR_VERSION = $$section(qt_version, '.', 0, 0)" \
        "QT_MINOR_VERSION = $$section(qt_version, '.', 1, 1)" \
        "QT_PATCH_VERSION = $$section(qt_version, '.', 2, 2)"

    #libinfix and namespace
    !isEmpty(config.input.qt_libinfix): output += "QT_LIBINFIX = $$config.input.qt_libinfix"
    !isEmpty(config.input.qt_namespace): output += "QT_NAMESPACE = $$config.input.qt_namespace"

    !isEmpty(QMAKE_GCC_MAJOR_VERSION) {
        output += \
            "QT_GCC_MAJOR_VERSION = $$QMAKE_GCC_MAJOR_VERSION" \
            "QT_GCC_MINOR_VERSION = $$QMAKE_GCC_MINOR_VERSION" \
            "QT_GCC_PATCH_VERSION = $$QMAKE_GCC_PATCH_VERSION"
    }
    !isEmpty(QMAKE_MAC_SDK_VERSION): \
        output += "QT_MAC_SDK_VERSION = $$QMAKE_MAC_SDK_VERSION"
    !isEmpty(QMAKE_CLANG_MAJOR_VERSION) {
        output += \
            "QT_CLANG_MAJOR_VERSION = $$QMAKE_CLANG_MAJOR_VERSION" \
            "QT_CLANG_MINOR_VERSION = $$QMAKE_CLANG_MINOR_VERSION" \
            "QT_CLANG_PATCH_VERSION = $$QMAKE_CLANG_PATCH_VERSION"
    }
    !isEmpty(QMAKE_APPLE_CLANG_MAJOR_VERSION) {
        output += \
            "QT_APPLE_CLANG_MAJOR_VERSION = $$QMAKE_APPLE_CLANG_MAJOR_VERSION" \
            "QT_APPLE_CLANG_MINOR_VERSION = $$QMAKE_APPLE_CLANG_MINOR_VERSION" \
            "QT_APPLE_CLANG_PATCH_VERSION = $$QMAKE_APPLE_CLANG_PATCH_VERSION"
    }
    !isEmpty(QMAKE_MSC_VER) {
        output += \
            "QT_MSVC_MAJOR_VERSION = $$replace(QMAKE_MSC_FULL_VER, "(..)(..)(.*)", "\\1")" \
            "QT_MSVC_MINOR_VERSION = $$format_number($$replace(QMAKE_MSC_FULL_VER, "(..)(..)(.*)", "\\2"))" \
            "QT_MSVC_PATCH_VERSION = $$replace(QMAKE_MSC_FULL_VER, "(..)(..)(.*)", "\\3")"
    }
    !isEmpty(QMAKE_ICC_VER) {
        output += \
            "QT_ICC_MAJOR_VERSION = $$replace(QMAKE_ICC_VER, "(..)(..)", "\\1")" \
            "QT_ICC_MINOR_VERSION = $$format_number($$replace(QMAKE_ICC_VER, "(..)(..)", "\\2"))" \
            "QT_ICC_PATCH_VERSION = $$QMAKE_ICC_UPDATE_VER"
    }
    !isEmpty(QMAKE_GHS_VERSION) {
        output += \
            "QT_GHS_MAJOR_VERSION = $$replace(QMAKE_GHS_VERSION, "(.*)(.)(.)", "\\1")" \
            "QT_GHS_MINOR_VERSION = $$replace(QMAKE_GHS_VERSION, "(.*)(.)(.)", "\\2")" \
            "QT_GHS_PATCH_VERSION = $$replace(QMAKE_GHS_VERSION, "(.*)(.)(.)", "\\3")"
    }

    output += "QT_EDITION = $$config.input.qt_edition"
    !contains(config.input.qt_edition, "(OpenSource|Preview)") {
        output += \
            "QT_LICHECK = $$config.input.qt_licheck" \
            "QT_RELEASE_DATE = $$config.input.qt_release_date"
    }

    wasm: {
        qt_emcc_version = $$qtSystemEmccVersion()
        output += \
           "QT_EMCC_VERSION = $$qt_emcc_version"
    }

    return($$output)
}

defineReplace(qtConfOutputPostProcess_privatePro) {
    output = $$1

    !isEmpty(config.input.external-hostbindir): \
        output += "HOST_QT_TOOLS = $$val_escape(config.input.external-hostbindir)"

    return($$output)
}

defineReplace(qtConfOutputPostProcess_publicHeader) {
    qt_version = $$[QT_VERSION]
    output = \
        $$1 \
        "$${LITERAL_HASH}define QT_VERSION_STR \"$$qt_version\"" \
        "$${LITERAL_HASH}define QT_VERSION_MAJOR $$section(qt_version, '.', 0, 0)" \
        "$${LITERAL_HASH}define QT_VERSION_MINOR $$section(qt_version, '.', 1, 1)" \
        "$${LITERAL_HASH}define QT_VERSION_PATCH $$section(qt_version, '.', 2, 2)"

    !$$qtConfEvaluate("features.shared") {
        output += \
            "/* Qt was configured for a static build */" \
            "$${LITERAL_HASH}if !defined(QT_SHARED) && !defined(QT_STATIC)" \
            "$${LITERAL_HASH} define QT_STATIC" \
            "$${LITERAL_HASH}endif"
    }

    !isEmpty(config.input.qt_libinfix): \
        output += "$${LITERAL_HASH}define QT_LIBINFIX \"$$eval(config.input.qt_libinfix)\""

    wasm: {
        qt_emcc_version = $$qtSystemEmccVersion()
output += \
           "$${LITERAL_HASH}define QT_EMCC_VERSION \"$$qt_emcc_version\""
    }

    return($$output)
}


# custom reporting

defineTest(qtConfReport_buildParts) {
    qtConfReportPadded($${1}, $$qtConfEvaluate("tests.build_parts.value"))
}

defineReplace(qtConfReportArch) {
    arch = $$qtConfEvaluate('tests.$${1}.arch')
    subarch = $$qtConfEvaluate('tests.$${1}.subarch')
    isEmpty(subarch): subarch = <none>
    return("$$arch, CPU features: $$subarch")
}

defineReplace(qtConfReportCompiler) {
    clang_cl: {
        return("clang-cl $${QMAKE_CLANG_MAJOR_VERSION}.$${QMAKE_CLANG_MINOR_VERSION}.$${QMAKE_CLANG_PATCH_VERSION}")
    } else: clang {
        !isEmpty(QMAKE_APPLE_CLANG_MAJOR_VERSION) {
            return("clang (Apple) $${QMAKE_APPLE_CLANG_MAJOR_VERSION}.$${QMAKE_APPLE_CLANG_MINOR_VERSION}.$${QMAKE_APPLE_CLANG_PATCH_VERSION}")
        } else {
            return("clang $${QMAKE_CLANG_MAJOR_VERSION}.$${QMAKE_CLANG_MINOR_VERSION}.$${QMAKE_CLANG_PATCH_VERSION}")
        }
    } else: intel_icc {
        return("intel_icc $$QMAKE_ICC_VER")
    } else: intel_icl {
        return("intel_icl $$QMAKE_ICC_VER")
    } else: rim_qcc {
        return("rim_qcc $${QMAKE_GCC_MAJOR_VERSION}.$${QMAKE_GCC_MINOR_VERSION}.$${QMAKE_GCC_PATCH_VERSION}")
    } else: gcc {
        return("gcc $${QMAKE_GCC_MAJOR_VERSION}.$${QMAKE_GCC_MINOR_VERSION}.$${QMAKE_GCC_PATCH_VERSION}")
    } else: msvc {
        return("msvc $$QMAKE_MSC_FULL_VER")
    } else: ghs {
        return("ghs $$QMAKE_GHS_VERSION")
    } else {
        return("unknown ($$QMAKE_COMPILER)")
    }
}


defineTest(qtConfReport_buildTypeAndConfig) {
    !$$qtConfEvaluate("features.cross_compile") {
        qtConfAddReport("Build type: $$[QMAKE_SPEC] ($$qtConfReportArch(architecture))")
        qtConfAddReport("Compiler: $$qtConfReportCompiler()")
    } else {
        qtConfAddReport("Building on: $$[QMAKE_SPEC] ($$qtConfReportArch(host_architecture))")
        qtConfAddReport("Building for: $$[QMAKE_XSPEC] ($$qtConfReportArch(architecture))")
        qtConfAddReport("Target compiler: $$qtConfReportCompiler()")
    }

    qtConfAddReport()
    qtConfAddReport("Configuration: $$eval($${currentConfig}.output.privatePro.append.CONFIG) $$eval($${currentConfig}.output.publicPro.append.QT_CONFIG)")
    qtConfAddReport()
}

defineTest(qtConfReport_buildMode) {
    $$qtConfEvaluate("features.force_debug_info"): \
        release = "release (with debug info)"
    else: \
        release = "release"

    $$qtConfEvaluate("features.debug") {
        build_mode = "debug"
        raw_build_mode = "debug"
    } else {
        build_mode = $$release
        raw_build_mode = "release"
    }

    $$qtConfEvaluate("features.debug_and_release"): \
        build_mode = "debug and $$release; default link: $$raw_build_mode"

    $$qtConfEvaluate("features.release_tools"): \
        build_mode = "$$build_mode; optimized tools"

    qtConfReportPadded($$1, $$build_mode)
}

defineTest(qtConfReport_emccVersion) {
    EMCC_VERSION = $$qtSystemEmccVersion()
    REQ_VERSION = $$qtEmccRecommendedVersion()
    !equals(EMCC_VERSION, $$REQ_VERSION) {
        qtConfAddReport("You should use the recommended Emscripten version $$REQ_VERSION with this Qt. You have $$EMCC_VERSION $$QT_EMCC_VERSION")
    }
}

# ensure pristine environment for configuration
discard_from($$[QT_HOST_DATA/get]/mkspecs/qconfig.pri)
discard_from($$[QT_HOST_DATA/get]/mkspecs/qmodule.pri)
# ... and cause them to be reloaded afterwards
QMAKE_POST_CONFIGURE += \
    "include(\$\$[QT_HOST_DATA/get]/mkspecs/qconfig.pri)" \
    "include(\$\$[QT_HOST_DATA/get]/mkspecs/qmodule.pri)"

defineTest(createConfigStatus) {
    $$QMAKE_REDO_CONFIG: return()
    cfg = $$relative_path($$_PRO_FILE_PWD_/configure, $$OUT_PWD)
    ext =
    equals(QMAKE_HOST.os, Windows) {
        ext = .bat
        cont = \
            "$$system_quote($$system_path($$cfg)$$ext) -redo %*"
    } else {
        !contains(cfg, .*/.*): cfg = ./$$cfg
        cont = \
            "$${LITERAL_HASH}!/bin/sh" \
            "exec $$system_quote($$cfg) -redo \"$@\""
    }
    write_file($$OUT_PWD/config.status$$ext, cont, exe)|error()
}

QMAKE_POST_CONFIGURE += \
    "createConfigStatus()"