2e10b38c6a
... instead of relying on the global qt_framework flag. Change-Id: Ie23f55788c26d732ada87aab7284c0a1fe0bfa28 Reviewed-by: Qt Doc Bot <qt_docbot@qt-project.org> Reviewed-by: Joerg Bornemann <joerg.bornemann@nokia.com> Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@nokia.com>
224 lines
7.4 KiB
Plaintext
224 lines
7.4 KiB
Plaintext
defineReplace(qtPlatformTargetSuffix) {
|
|
CONFIG(debug, debug|release) {
|
|
!debug_and_release|build_pass {
|
|
mac:return(_debug)
|
|
win32:return(d)
|
|
}
|
|
}
|
|
return()
|
|
}
|
|
|
|
defineReplace(qtLibraryTarget) {
|
|
unset(LIBRARY_NAME)
|
|
LIBRARY_NAME = $$1
|
|
mac:!static:contains(QT_CONFIG, qt_framework) {
|
|
QMAKE_FRAMEWORK_BUNDLE_NAME = $$LIBRARY_NAME
|
|
export(QMAKE_FRAMEWORK_BUNDLE_NAME)
|
|
}
|
|
unset(LIBRARY_SUFFIX)
|
|
contains(TEMPLATE, .*lib):LIBRARY_SUFFIX = $$qtPlatformTargetSuffix()
|
|
isEmpty(LIBRARY_SUFFIX):return($$LIBRARY_NAME)
|
|
else:return($$member(LIBRARY_NAME, 0)$$LIBRARY_SUFFIX)
|
|
}
|
|
|
|
defineTest(qtAddLibrary) {
|
|
warning("qtAddLibrary() is deprecated. Use qtAddModule() or QT+= instead.")
|
|
|
|
# Reverse-engineer the module name from the library name.
|
|
for(var, $$list($$find($$list($$enumerate_vars()), ^QT\\.[^.]+\\.name$))) {
|
|
isEqual($$var, $$1) {
|
|
var ~= s,^QT\\.([^.]+)\\.name$,\\1,
|
|
qtAddModule($$var, , LIBS):return(true):break()
|
|
return(false):break() # Yes, the break is insanity. But necessary.
|
|
}
|
|
}
|
|
error("No module matching library '$$1' found.")
|
|
}
|
|
|
|
# qt module, UsePrivate flag, libs variable
|
|
defineTest(qtAddModule) {
|
|
MODULE_NAME = $$eval(QT.$${1}.name)
|
|
MODULE_INCLUDES = $$eval(QT.$${1}.includes)
|
|
MODULE_LIBS = $$eval(QT.$${1}.libs)
|
|
MODULE_CONFIG = $$eval(QT.$${1}.module_config)
|
|
MODULE_MAJOR_VERSION = $$eval(QT.$${1}.MAJOR_VERSION)
|
|
|
|
CONFIG += $$eval(QT.$${1}.CONFIG)
|
|
DEFINES += $$eval(QT.$${1}.DEFINES)
|
|
|
|
MODULE_INCLUDES -= $$QMAKE_DEFAULT_INCDIRS
|
|
MODULE_LIBS -= $$QMAKE_DEFAULT_LIBDIRS
|
|
|
|
INCLUDEPATH *= $$MODULE_INCLUDES
|
|
auto_use_privates|isEqual(2, UsePrivate) { # Tests function parameter 2 ($$2) being equal to 'UsePrivate'
|
|
INCLUDEPATH += $$eval(QT.$${1}.private_includes)
|
|
}
|
|
|
|
unset(LINKAGE)
|
|
mac {
|
|
contains(MODULE_CONFIG, lib_bundle) {
|
|
FRAMEWORK_INCLUDE = $${MODULE_LIBS}/$${MODULE_NAME}.framework/Headers
|
|
!qt_no_framework_direct_includes:exists($$FRAMEWORK_INCLUDE) {
|
|
INCLUDEPATH *= $$FRAMEWORK_INCLUDE
|
|
LINKAGE = -F$${MODULE_LIBS}
|
|
} else {
|
|
QMAKE_FRAMEWORKPATH *= $${MODULE_LIBS}
|
|
}
|
|
LINKAGE += -framework $${MODULE_NAME}$${QT_LIBINFIX}
|
|
}
|
|
}
|
|
|
|
win32 {
|
|
# Make sure we link against the version pulled from the module's .pri
|
|
ver_var = QMAKE_$${upper($$MODULE_NAME$$QT_LIBINFIX)}_VERSION_OVERRIDE
|
|
dver_var = QMAKE_$${upper($$MODULE_NAME$$QT_LIBINFIX)}D_VERSION_OVERRIDE
|
|
$$ver_var = $$MODULE_MAJOR_VERSION
|
|
$$dver_var = $$MODULE_MAJOR_VERSION
|
|
export($$ver_var)
|
|
export($$dver_var)
|
|
}
|
|
|
|
isEmpty(LINKAGE) {
|
|
!isEmpty(MODULE_LIBS): LINKAGE = -L$$MODULE_LIBS
|
|
lib =
|
|
if(!debug_and_release|build_pass):CONFIG(debug, debug|release) {
|
|
win32: lib = -l$${MODULE_NAME}$${QT_LIBINFIX}d
|
|
mac: lib = -l$${MODULE_NAME}$${QT_LIBINFIX}_debug
|
|
}
|
|
isEmpty(lib): lib = -l$${MODULE_NAME}$${QT_LIBINFIX}
|
|
LINKAGE += $$lib
|
|
|
|
contains(QT_CONFIG, rpath) {
|
|
rpath = $$eval(QT.$${MODULE}.rpath)
|
|
isEmpty(rpath): rpath = $$MODULE_LIBS
|
|
QMAKE_RPATHDIR *= $$rpath
|
|
}
|
|
|
|
# Make sure we can link to uninstalled libraries
|
|
unix:!mac:!isEmpty(QT.$${1}.libs) { # Use unmodified path, so /usr/lib also works
|
|
for(rpl, QT.$${1}.rpath_link): \
|
|
QMAKE_LFLAGS *= -Wl,-rpath-link,$$rpl
|
|
!auto_use_privates:!isEqual(2, UsePrivate): \
|
|
for(rpl, QT.$${1}.rpath_link_private): \
|
|
QMAKE_LFLAGS *= -Wl,-rpath-link,$$rpl
|
|
}
|
|
}
|
|
# Only link to this module if a libs directory is set, else this is just a module
|
|
# to give access to sources or include files, and not for linking.
|
|
!isEmpty(QT.$${1}.libs) { # Use unmodified path, so /usr/lib also works
|
|
!isEmpty(QMAKE_LSB) {
|
|
!isEmpty(MODULE_LIBS): QMAKE_LFLAGS *= --lsb-libpath=$$MODULE_LIBS
|
|
QMAKE_LIBDIR *= /opt/lsb/lib
|
|
QMAKE_LFLAGS *= --lsb-shared-libs=$${MODULE_NAME}$${QT_LIBINFIX}
|
|
}
|
|
$$3 += $$LINKAGE
|
|
}
|
|
export(CONFIG)
|
|
export(DEFINES)
|
|
export($$3)
|
|
export(INCLUDEPATH)
|
|
export(QMAKE_FRAMEWORKPATH)
|
|
export(QMAKE_LFLAGS)
|
|
export(QMAKE_LIBDIR)
|
|
export(QMAKE_RPATHDIR)
|
|
return(true)
|
|
}
|
|
|
|
# qt variable, libs variable
|
|
defineTest(qtAddModules) {
|
|
# Figure out from which modules we're wanting to use the private headers
|
|
NEWQT =
|
|
for(QTLIB, $$1) {
|
|
QTLIBRAW = $$replace(QTLIB, -private$, )
|
|
!isEqual(QTLIBRAW, $$QTLIB) {
|
|
want_var = QT.$${QTLIBRAW}.want_private
|
|
$$want_var = UsePrivate
|
|
using_privates = true
|
|
NEWQT += $$eval(QT.$${QTLIBRAW}.private_depends)
|
|
}
|
|
NEWQT += $$QTLIBRAW
|
|
contains(QT.$${QTLIBRAW}.CONFIG, auto_use_privates): CONFIG += auto_use_privates
|
|
}
|
|
# Topological resolution of modules based on their QT.<module>.depends variable
|
|
$$1 = $$resolve_depends(NEWQT, "QT.")
|
|
# Finally actually add the modules
|
|
unset(BAD_QT)
|
|
for(QTLIB, $$1) {
|
|
QTLIBNAME = $$eval(QT.$${QTLIB}.name)
|
|
isEmpty(QTLIBNAME) {
|
|
BAD_QT += $$QTLIB
|
|
next()
|
|
}
|
|
|
|
target_qt:isEqual(TARGET, $$QTLIBNAME) {
|
|
warning("$$TARGET cannot have a $$1 of $$QTLIB")
|
|
next()
|
|
}
|
|
|
|
qtAddModule($$QTLIB, $$eval(QT.$${QTLIB}.want_private), $$2)
|
|
}
|
|
!isEmpty(BAD_QT):error("Unknown module(s) in $$1: $$BAD_QT")
|
|
|
|
export(using_privates)
|
|
}
|
|
|
|
# variable, default
|
|
defineTest(qtPrepareTool) {
|
|
$$1 = $$eval(QT_TOOL.$${2}.command)
|
|
isEmpty($$1) {
|
|
MODBASE = $$[QT_HOST_BINS/get]
|
|
count(ARGS, 2, greaterThan) {
|
|
isEmpty(QT.$${3}.bins):warning("No QT.$${3}.bins, module path ignored for qtPrepareTool($$1, $$2, $$3)")
|
|
else:MODBASE = $$eval(QT.$${3}.bins)
|
|
}
|
|
isEmpty($$1):$$1 = $$MODBASE/$$2
|
|
contains(QMAKE_HOST.os, Windows):!contains($$1, .*\\.(exe|bat)$) {
|
|
exists($$eval($$1).bat) {
|
|
$$1 = $$eval($$1).bat
|
|
} else {
|
|
$$1 = $$eval($$1).exe
|
|
}
|
|
} else:contains(QMAKE_HOST.os, Darwin) {
|
|
BUNDLENAME = $$eval($$1).app/Contents/MacOS/$$2
|
|
exists($$BUNDLENAME) {
|
|
$$1 = $$BUNDLENAME
|
|
}
|
|
}
|
|
$$1 = $$shell_path($$eval($$1))
|
|
}
|
|
export($$1)
|
|
}
|
|
|
|
defineReplace(pkgConfigExecutable) {
|
|
isEmpty(PKG_CONFIG) {
|
|
PKG_CONFIG = pkg-config
|
|
|
|
!isEmpty(PKG_CONFIG_SYSROOT_DIR) {
|
|
win32:isEmpty(MINGW_IN_SHELL):PKG_CONFIG = set PKG_CONFIG_SYSROOT_DIR=$$PKG_CONFIG_SYSROOT_DIR& $$PKG_CONFIG
|
|
else:PKG_CONFIG = PKG_CONFIG_SYSROOT_DIR=\"$$PKG_CONFIG_SYSROOT_DIR\" $$PKG_CONFIG
|
|
}
|
|
|
|
!isEmpty(PKG_CONFIG_LIBDIR) {
|
|
win32:isEmpty(MINGW_IN_SHELL):PKG_CONFIG = set PKG_CONFIG_LIBDIR=$$PKG_CONFIG_LIBDIR& $$PKG_CONFIG
|
|
else:PKG_CONFIG = PKG_CONFIG_LIBDIR=\"$$PKG_CONFIG_LIBDIR\" $$PKG_CONFIG
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|