
defineReplace(qtPlatformTargetSuffix) {
    suffix =
    android: return($${suffix}_$${QT_ARCH})
    win32 {
        CONFIG(debug, debug|release) {
            mingw {
                qtConfig(debug_and_release):build_pass: \
                    return($${suffix}d)
            } else {
                !debug_and_release|build_pass: \
                    return($${suffix}d)
            }
        }
    }
    darwin {
        CONFIG(debug, debug|release) {
            !debug_and_release|build_pass: \
                return($${suffix}_debug)
        }
    }
    return($$suffix)
}

defineReplace(qtLibraryTarget) {
   LIBRARY_NAME = $$1
   CONFIG(shared, static|shared):qtConfig(framework) {
      QMAKE_FRAMEWORK_BUNDLE_NAME = $$LIBRARY_NAME
      export(QMAKE_FRAMEWORK_BUNDLE_NAME)
   }
   return($$LIBRARY_NAME$$qtPlatformTargetSuffix())
}

defineReplace(qt5LibraryTarget) {
   android {
        LIBRARY_NAME_PREFIX = $$2
        LIBRARY_NAME_PREFIX = $$replace(LIBRARY_NAME_PREFIX, "//", "/")
        LIBRARY_NAME_PREFIX = $$replace(LIBRARY_NAME_PREFIX, "/", "_")
        LIBRARY_NAME = $$LIBRARY_NAME_PREFIX$$qtLibraryTarget($$1)
        unset(LIBRARY_NAME_PREFIX)
   } else: LIBRARY_NAME = $$qtLibraryTarget($$1)
   isEmpty(QMAKE_FRAMEWORK_BUNDLE_NAME) {
       # Insert the major version of Qt in the library name
       # unless it's a framework build.
       LIBRARY_NAME ~= s,^Qt,Qt$$QT_MAJOR_VERSION,
   }
   return($$LIBRARY_NAME)
}

defineReplace(qtRelativeRPathBase) {
    darwin {
        if(equals(TEMPLATE, app):app_bundle)|\
                if(equals(TEMPLATE, lib):plugin:plugin_bundle) {
            shallow_bundle: return($$target.path/$${TARGET}.app)
            return($$target.path/$${TARGET}.app/Contents/MacOS)
        }
        equals(TEMPLATE, lib):!plugin:lib_bundle {
            shallow_bundle: return($$target.path/$${TARGET}.framework)
            return($$target.path/$${TARGET}.framework/Versions/Current)
        }
    }
    return($$target.path)
}

defineTest(qtAddLibrary) {
    warning("qtAddLibrary() is deprecated. Use QT+= instead.")

    # Reverse-engineer the module name from the library name.
    for(var, QT_MODULES) {
        isEqual(QT.$${var}.name, $$1) {
            QT += $$var
            export(QT)
            return(true)
        }
    }
    error("No module matching library '$$1' found.")
}

# qt module
defineTest(qtHaveModule) {
    !isEmpty(QT.$$replace(1, -, _).name): \
        return(true)
    return(false)
}

# variable, default, [suffix for variable for system() use], [prepare primary variable for system() use]
defineTest(qtPrepareTool) {
    cmd = $$eval(QT_TOOL.$${2}.binary)
    isEmpty(cmd) {
        cmd = $$[QT_HOST_BINS]/$$2
        exists($${cmd}.pl) {
            $${1}_EXE = $${cmd}.pl
            cmd = perl -w $$system_path($${cmd}.pl)
        } else: contains(QMAKE_HOST.os, Windows) {
            $${1}_EXE = $${cmd}.exe
            cmd = $$system_path($${cmd}.exe)
        } else:contains(QMAKE_HOST.os, Darwin) {
            BUNDLENAME = $${cmd}.app/Contents/MacOS/$$2
            exists($$BUNDLENAME) {
                cmd = $$BUNDLENAME
            }
            $${1}_EXE = $$cmd
        } else {
            $${1}_EXE = $$cmd
        }
    } else {
        $${1}_EXE = $$last(cmd)
    }
    export($${1}_EXE)
    QT_TOOL_ENV += $$eval(QT_TOOL.$${2}.envvars)
    QT_TOOL_NAME = $$2
    !isEmpty(3)|!isEmpty(4) {
        $$1$$3 =
        for (arg, cmd): \
            $$1$$3 += $$system_quote($$arg)
        qtAddTargetEnv($$1$$3, QT_TOOL.$${2}.depends, system)
    }
    isEmpty(4) {
        $$1 =
        for (arg, cmd): \
            $$1 += $$shell_quote($$arg)
        qtAddTargetEnv($$1, QT_TOOL.$${2}.depends, )
    }
}

# target variable, list of env var names, [non-empty: prepare for system(), not make]
defineTest(qtAddToolEnv) {
    isEmpty(3): \
        ds = $$QMAKE_DIR_SEP
    else: \
        ds = $$DIR_SEPARATOR
    batch_sets =
    for(env, 2) {
        value = $$eval($${env}.value)
        !isEmpty(value) {
            name = $$eval($${env}.name)
            config = $$eval($${env}.CONFIG)
            equals(ds, /) {
                contains(config, prepend): infix = \${$$name:+:\$$$name}
                else: contains(config, always_prepend): infix = :\$$$name
                else: infix =
                # Under msys, this path is taken only in the non-system()
                # case, so using shell_quote() always works.
                batch_sets += \
                    "$$name=$$shell_quote($$join(value, :))$$infix" \
                    "export $$name"
            } else {
                value ~= s,\\^,^^^^,g
                value ~= s,!,^^!,g
                value ~= s,\\),^),g
                contains(config, prepend) {
                    batch_sets += \
                        "if defined $$name (" \
                        "    set $$name=$$join(value, ;);!$$name!" \
                        ") else (" \
                        "    set $$name=$$join(value, ;)" \
                        ")"
                } else: contains(config, always_prepend) {
                    batch_sets += "(set $$name=$$join(value, ;);!$$name!)"
                } else {
                    batch_sets += "(set $$name=$$join(value, ;))"
                }
            }
        }
    }
    !isEmpty(batch_sets) {
        batch_name = wrapper
        !isEmpty(QT_TOOL_NAME): batch_name = $${QT_TOOL_NAME}_wrapper
        cmd = $$eval($$1)
        !isEmpty(cmd): cmd = "$$cmd "
        equals(ds, /) {
            batch_name = $${batch_name}.sh
            equals(QMAKE_HOST.os, Darwin):exists(/bin/bash): \
                shell = /bin/bash
            else: \
                shell = /bin/sh
            batch_cont = \
                "$$LITERAL_HASH!$$shell" \
                $$batch_sets \
                "exec $$cmd\"$@\""
            # It would be nicer to use the '.' command (without 'exec' above),
            # but that doesn't set the positional arguments under (d)ash.
            $$1 =
        } else {
            batch_name = $${batch_name}.bat
            batch_cont = \
                "@echo off" \
                "SetLocal EnableDelayedExpansion" \
                $$batch_sets \
                "$$cmd%*" \
                "EndLocal"
            $$1 = call
        }
        !build_pass:!write_file($$OUT_PWD/$$batch_name, batch_cont, exe): error()
        isEmpty(3): \
            $$1 += $$shell_quote($$shell_path($$OUT_PWD/$$batch_name))
        else: \
            $$1 += $$system_quote($$system_path($$OUT_PWD/$$batch_name))
        QMAKE_DISTCLEAN += $$OUT_PWD/$$batch_name
    }
    export($$1)
    export(QMAKE_DISTCLEAN)
}

# target variable, dependency var name, [non-empty: prepare for system(), not make]
defineTest(qtAddTargetEnv) {
    deps = $$replace($$2, -private$, _private)
    deps = $$resolve_depends(deps, "QT.", ".depends" ".run_depends")
    !isEmpty(deps) {
        libs = libs
        deppath.CONFIG = prepend
        equals(QMAKE_HOST.os, Windows) {
            libs = bins
            deppath.CONFIG = always_prepend
            deppath.name = PATH
        } else:contains(QMAKE_HOST.os, Linux|FreeBSD|OpenBSD|NetBSD|DragonFly|SunOS|HP-UX|QNX|GNU) {
            deppath.name = LD_LIBRARY_PATH
        } else:contains(QMAKE_HOST.os, Haiku) {
            deppath.name = LIBRARY_PATH
        } else:equals(QMAKE_HOST.os, Darwin) {
            qtConfig(framework): \
                deppath.name = DYLD_FRAMEWORK_PATH
            else: \
                deppath.name = DYLD_LIBRARY_PATH
        } else:equals(QMAKE_HOST.os, AIX) {
            deppath.name = LIBPATH
        } else {
            error("Operating system not supported.")
        }
        ptypes =
        for(dep, deps) {
            isEmpty(3): \
                deppath += $$shell_path($$eval(QT.$${dep}.$$libs))
            else: \
                deppath += $$system_path($$eval(QT.$${dep}.$$libs))
            ptypes += $$eval(QT.$${dep}.plugin_types)
        }
        deppath.value = $$unique(deppath)

        pluginpath.value =
        ppaths = $$[QT_INSTALL_PLUGINS/get]
        for(qplug, QT_PLUGINS): \
            contains(ptypes, $$eval(QT_PLUGIN.$${qplug}.TYPE)): \
                ppaths += $$eval(QT_PLUGIN.$${qplug}.PATH)
        ppaths = $$unique(ppaths)
        for(qplug, ppaths) {
            isEmpty(3): \
                pluginpath.value += $$shell_path($$qplug)
            else: \
                pluginpath.value += $$system_path($$qplug)
        }
        pluginpath.name = QT_PLUGIN_PATH
        pluginpath.CONFIG = prepend

        QT_TOOL_ENV += deppath pluginpath
    }
    qtAddToolEnv($$1, $$QT_TOOL_ENV, $$3)
}

defineReplace(pkgConfigExecutable) {
    isEmpty(PKG_CONFIG) {
        !isEmpty(QMAKE_PKG_CONFIG) {
            # Assumed to be properly sysrootified.
            PKG_CONFIG = $$QMAKE_PKG_CONFIG
            export(PKG_CONFIG)
        } else {
            PKG_CONFIG = pkg-config
            !cross_compile {
                export(PKG_CONFIG)
            } else {
                # Cross compiling, ensure that pkg-config is set up sanely.
                sysroot = $$[QT_SYSROOT]

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

                    pkgConfigLibdir = $$system_path($$sysroot/usr/lib/pkgconfig)$$QMAKE_DIRLIST_SEP$$system_path($$sysroot/usr/share/pkgconfig)
                    !isEmpty(GCC_MACHINE_DUMP): \
                        pkgConfigLibdir = "$$pkgConfigLibdir$$QMAKE_DIRLIST_SEP$$system_path($$sysroot/usr/lib/$$GCC_MACHINE_DUMP/pkgconfig)"
                    message("PKG_CONFIG_LIBDIR automatically set to $$pkgConfigLibdir")
                }
                pkgConfigSysrootDir = $$(PKG_CONFIG_SYSROOT_DIR)
                isEmpty(pkgConfigSysrootDir) {
                    isEmpty(sysroot) {
                        warning("Disabling pkg-config since PKG_CONFIG_SYSROOT_DIR is not set.")
                        warning("Set this variable to your sysroot for pkg-config to function")
                        warning("correctly when cross-compiling.")
                        return()
                    }

                    pkgConfigSysrootDir = $$sysroot
                    message("PKG_CONFIG_SYSROOT_DIR automatically set to $$pkgConfigSysrootDir")
                }

                sysroot.name = PKG_CONFIG_SYSROOT_DIR
                sysroot.value = $$pkgConfigSysrootDir
                libdir.name = PKG_CONFIG_LIBDIR
                libdir.value = $$pkgConfigLibdir
                QT_TOOL_NAME = pkg-config
                qtAddToolEnv(PKG_CONFIG, sysroot libdir, SYS)
            }
        }
    }

    PKG_CONFIG += 2> $$QMAKE_SYSTEM_NULL_DEVICE

    return($$PKG_CONFIG)
}

defineTest(packagesExist) {
    # this can't be done in global scope here because qt_functions is loaded
    # before the .pro is parsed, so if the .pro set PKG_CONFIG, we wouldn't know it
    # yet. oops.
    pkg_config = $$pkgConfigExecutable()

    for(package, ARGS) {
        !system($$pkg_config --exists $$package):return(false)
    }

    return(true)
}

# Prepares target that will iterate through all subdirs (except those
# with no_default_target or no_{name_of_target}_target. The prepared
# target must still be manually added to QMAKE_EXTRA_TARGETS.
defineTest(prepareRecursiveTarget) {
    target = $$1
    no_$${target}_target: return()

    for(subdir, SUBDIRS) {
        subdir_config = $$eval($${subdir}.CONFIG)
        contains(subdir_config, no_default_target): next()
        contains(subdir_config, no_$${target}_target): next()

        $${target}.recurse += $$subdir
    }

    # Set up the recurse target only when there
    # is something to recurse into.
    isEmpty($${target}.recurse): return()

    $${target}.CONFIG = recursive
    $${target}.recurse_target = $${target}

    export($${target}.recurse)
    export($${target}.CONFIG)
    export($${target}.recurse_target)
}

defineTest(qtConfig) {
    modules = $$QT $$QT_PRIVATE $$QT_FOR_CONFIG
    modules ~= s,-private$,_private,g
    modules = $$resolve_depends(modules, "QT.", ".depends")
    modules += global global_private
    modules = $$reverse(modules)
    for (module, modules) {
        contains(QT.$${module}.enabled_features, $$1): \
            return(true)
        contains(QT.$${module}.disabled_features, $$1): \
            return(false)
    }
    error("Could not find feature $${1}.")
}
