375 lines
13 KiB
Plaintext
375 lines
13 KiB
Plaintext
|
|
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}.")
|
|
}
|