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) } else { # insert the major version in the library name # unless it's a framework build MAJOR_VERSION = $$section(VERSION, ., 0, 0) LIBRARY_NAME ~= s,^Qt,Qt$$MAJOR_VERSION, } 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.") } # target variable, flag source variable defineTest(qtProcessModuleFlags) { for(flag, $$2) { contains(flag, ^-.*): \ $$1 -= $$replace(flag, ^-, ) else: \ $$1 += $$flag } export($$1) } # 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) qtProcessModuleFlags(CONFIG, QT.$${1}.CONFIG) qtProcessModuleFlags(DEFINES, 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} } } # Re-insert the major version in the library name (cf qtLibraryTarget above) # unless it's a framework build !mac|!contains(MODULE_CONFIG, lib_bundle): \ MODULE_NAME ~= s,^Qt,Qt$$MODULE_MAJOR_VERSION, win32 { # Make sure the version number isn't appended again to the lib name ver_var = QMAKE_$${upper($$MODULE_NAME$$QT_LIBINFIX)}_VERSION_OVERRIDE dver_var = QMAKE_$${upper($$MODULE_NAME$$QT_LIBINFIX)}D_VERSION_OVERRIDE $$ver_var = 0 $$dver_var = 0 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 = $${MODULE_NAME}$${QT_LIBINFIX}d mac: lib = $${MODULE_NAME}$${QT_LIBINFIX}_debug } isEmpty(lib): lib = $${MODULE_NAME}$${QT_LIBINFIX} LINKAGE += -l$$lib contains(QT_CONFIG, rpath): QMAKE_RPATHDIR *= $$eval(QT.$${1}.rpath) contains(MODULE_CONFIG, staticlib): \ PRE_TARGETDEPS *= $$MODULE_LIBS/$${QMAKE_PREFIX_STATICLIB}$${lib}.$${QMAKE_EXTENSION_STATICLIB} # 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($$3) export(INCLUDEPATH) export(QMAKE_FRAMEWORKPATH) export(QMAKE_LFLAGS) export(QMAKE_LIBDIR) export(QMAKE_RPATHDIR) export(PRE_TARGETDEPS) 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..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) { $$1 = $$[QT_HOST_BINS/get]/$$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) } defineTest(qtAddToolEnv) { for(env, 2) { value = $$eval($${env}.value) !isEmpty(value) { name = $$eval($${env}.name) equals(QMAKE_DIR_SEP, /) { contains($${env}.CONFIG, prepend): infix = \${$$name:+:\$$$name} else: infix = val = "$$name=$$join(value, :)$$infix" } else { # Escape closing parens when expanding the variable, otherwise cmd confuses itself. contains($${env}.CONFIG, prepend): infix = ;%$$name:)=^)% else: infix = val = "(set $$name=$$join(value, ;)$$infix) &" } contains(MAKEFILE_GENERATOR, MS.*): val ~= s,%,%%,g else: val ~= s,\\\$,\$\$,g $$1 = "$$val $$eval($$1)" } } export($$1) } defineTest(qtAddTargetEnv) { deps = $$resolve_depends(QT, "QT.") !isEmpty(deps) { for(dep, deps) { deppath += $$shell_path($$eval(QT.$${dep}.libs)) for(rpath, QT.$${dep}.rpath_link): \ deppath += $$shell_path($$rpath) } equals(QMAKE_HOST.os, Windows) { deppath.name = PATH } else:contains(QMAKE_HOST.os, Linux|FreeBSD) { deppath.name = LD_LIBRARY_PATH } else:equals(QMAKE_HOST.os, Darwin) { contains(QT_CONFIG, qt_framework): \ deppath.name = DYLD_FRAMEWORK_PATH else: \ deppath.name = DYLD_LIBRARY_PATH } else { error("Operating system not supported.") } deppath.value = $$unique(deppath) deppath.CONFIG = prepend pluginpath.value = for(qmod, QMAKEMODULES) { qmod = $$section(qmod, /, 0, -3)/plugins exists($$qmod): pluginpath.value += $$shell_path($$qmod) } pluginpath.name = QT_PLUGIN_PATH QT_TOOL_ENV += deppath pluginpath } qtAddToolEnv($$1, $$QT_TOOL_ENV) } 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) { contains(QT_CONFIG, no-pkg-config):return(false) # 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) }