# custom command line handling defineTest(qtConfCommandline_qmakeArgs) { contains(1, QMAKE_[A-Z_]+ *[-+]?=.*) { config.input.qmakeArgs += $$1 export(config.input.qmakeArgs) return(true) } return(false) } defineTest(qtConfCommandline_cxxstd) { msvc: \ qtConfAddError("Command line option -c++std is not supported with MSVC compilers.") arg = $${1} val = $${2} isEmpty(val): val = $$qtConfGetNextCommandlineArg() !contains(val, "^-.*"):!isEmpty(val) { contains(val, "(c\+\+)?11") { qtConfCommandlineSetInput("c++14", "no") } else: contains(val, "(c\+\+)?(14|1y)") { qtConfCommandlineSetInput("c++14", "yes") qtConfCommandlineSetInput("c++1z", "no") } else: contains(val, "(c\+\+)?(1z)") { qtConfCommandlineSetInput("c++14", "yes") qtConfCommandlineSetInput("c++1z", "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, "undefined") { qtConfCommandlineSetInput("sanitize_undefined", "yes") } else { qtConfAddError("Invalid argument $$val to command line parameter $$arg") } } else { qtConfAddError("Missing argument to command line parameter $$arg") } } # callbacks defineReplace(qtConfFunc_crossCompile) { spec = $$[QMAKE_SPEC] !equals(spec, $$[QMAKE_XSPEC]): return(true) return(false) } # custom tests defineTest(qtConfTest_architecture) { !qtConfTest_compile($${1}): \ error("Could not determine $$eval($${1}.description). See config.log for details.") test = $$eval($${1}.test) test_out_dir = $$shadowed($$QMAKE_CONFIG_TESTS_DIR/$$test) unix:exists($$test_out_dir/arch): \ content = $$cat($$test_out_dir/arch, blob) else: win32:exists($$test_out_dir/arch.exe): \ content = $$cat($$test_out_dir/arch.exe, blob) else: android:exists($$test_out_dir/libarch.so): \ content = $$cat($$test_out_dir/libarch.so, blob) else: \ error("$$eval($${1}.description) detection binary not found.") arch_magic = ".*==Qt=magic=Qt== Architecture:([^\\0]*).*" subarch_magic = ".*==Qt=magic=Qt== Sub-architecture:([^\\0]*).*" !contains(content, $$arch_magic)|!contains(content, $$subarch_magic): \ error("$$eval($${1}.description) 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, " ") export($${1}.arch) export($${1}.subarch) qtLog("Detected architecture: $$eval($${1}.arch) ($$eval($${1}.subarch))") $${1}.cache += arch subarch export($${1}.cache) return(true) } defineTest(qtConfTest_avx_test_apple_clang) { !*g++*:!*-clang*: return(true) qtRunLoggedCommand("$$QMAKE_CXX --version", compiler)|return(false) contains(compiler, "Apple clang version [23]") { # Some clang versions produce internal compiler errors compiling Qt AVX code return(false) } else { 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 = $$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 gcc { qtRunLoggedCommand("$$QMAKE_CXX -dumpmachine", gccMachineDump): \ !isEmpty(gccMachineDump): \ pkgConfigLibdir = "$$pkgConfigLibdir:$$sysroot/usr/lib/$$gccMachineDump/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_neon) { contains(config.tests.architecture.subarch, "neon"): return(true) return(false) } defineTest(qtConfTest_skipModules) { $${1}.cache = - export($${1}.cache) skip = uikit { skip += qtdoc qtmacextras qtserialport qtwebkit qtwebkit-examples !ios: skip += qtscript } for (m, config.input.skip) { # normalize the command line input m ~= s/^(qt)?/qt/ !exists($$_PRO_FILE_PWD_/../$$m) { qtConfAddError("-skip command line argument called with non-existent module '$$m'.") return(false) } skip += $$m } $${1}.value = $$unique(skip) export($${1}.value) 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(qtConfLibrary_openssl) { libs = $$getenv("OPENSSL_LIBS") !isEmpty(libs) { $${1}.libs = $$libs export($${1}.libs) return(true) } return(false) } defineTest(qtConfTest_checkCompiler) { contains(QMAKE_CXX, ".*clang.*") { qtRunLoggedCommand("$$QMAKE_CXX -v 2>&1", versionstr)|return(false) contains(versionstr, "^Apple (clang|LLVM) version .*") { $${1}.compilerDescription = "Apple Clang" $${1}.compilerId = "apple_clang" $${1}.compilerVersion = $$replace(versionstr, "^Apple (clang|LLVM) version ([0-9.]+).*$", "\\2") } else: contains(versionstr, ".*clang version.*") { $${1}.compilerDescription = "Clang" $${1}.compilerId = "clang" $${1}.compilerVersion = $$replace(versionstr, "^.*clang version ([0-9.]+).*", "\\1") } else { return(false) } } else: contains(QMAKE_CXX, ".*g\\+\\+.*") { qtRunLoggedCommand("$$QMAKE_CXX -dumpversion", version)|return(false) $${1}.compilerDescription = "GCC" $${1}.compilerId = "gcc" $${1}.compilerVersion = $$version } else: contains(QMAKE_CXX, ".*icpc" ) { qtRunLoggedCommand("$$QMAKE_CXX -v", version)|return(false) $${1}.compilerDescription = "ICC" $${1}.compilerId = "icc" $${1}.compilerVersion = $$replace(version, "icpc version ([0-9.]+).*", "\\1") } else: msvc { $${1}.compilerDescription = "MSVC" $${1}.compilerId = "cl" } else { return(false) } $${1}.compilerDescription += $$eval($${1}.compilerVersion) export($${1}.compilerDescription) export($${1}.compilerId) export($${1}.compilerVersion) $${1}.cache += compilerDescription compilerId compilerVersion export($${1}.cache) return(true) } defineReplace(filterLibraryPath) { str = $${1} for (l, QMAKE_DEFAULT_LIBDIRS): \ str -= "-L$$l" return($$str) } defineTest(qtConfLibrary_psqlConfig) { pg_config = $$config.input.psql_config isEmpty(pg_config): \ pg_config = $$qtConfFindInPath("pg_config") !win32:!isEmpty(pg_config) { qtRunLoggedCommand("$$pg_config --libdir", libdir)|return(false) qtRunLoggedCommand("$$pg_config --includedir", includedir)|return(false) libdir -= $$QMAKE_DEFAULT_LIBDIRS libs = !isEmpty(libdir): libs += "-L$$libdir" libs += "-lpq" $${1}.libs = "$$val_escape(libs)" includedir -= $$QMAKE_DEFAULT_INCDIRS $${1}.includedir = "$$val_escape(includedir)" !isEmpty(includedir): \ $${1}.cflags = "-I$$val_escape(includedir)" export($${1}.libs) export($${1}.includedir) export($${1}.cflags) return(true) } return(false) } defineTest(qtConfLibrary_psqlEnv) { # Respect PSQL_LIBS if set PSQL_LIBS = $$getenv(PSQL_LIBS) !isEmpty(PSQL_LIBS) { $${1}.libs = $$PSQL_LIBS export($${1}.libs) } return(true) } defineTest(qtConfLibrary_mysqlConfig) { mysql_config = $$config.input.mysql_config isEmpty(mysql_config): \ mysql_config = $$qtConfFindInPath("mysql_config") !isEmpty(mysql_config) { qtRunLoggedCommand("$$mysql_config --version", version)|return(false) version = $$split(version, '.') version = $$first(version) isEmpty(version)|lessThan(version, 4): return(false)] # query is either --libs or --libs_r query = $$eval($${1}.query) qtRunLoggedCommand("$$mysql_config $$query", libs)|return(false) qtRunLoggedCommand("$$mysql_config --include", includedir)|return(false) eval(libs = $$libs) libs = $$filterLibraryPath($$libs) # -rdynamic should not be returned by mysql_config, but is on RHEL 6.6 libs -= -rdynamic $${1}.libs = "$$val_escape(libs)" eval(includedir = $$includedir) includedir ~= s/^-I//g includedir -= $$QMAKE_DEFAULT_INCDIRS $${1}.includedir = "$$val_escape(includedir)" !isEmpty(includedir): \ $${1}.cflags = "-I$$val_escape(includedir)" export($${1}.libs) export($${1}.includedir) export($${1}.cflags) return(true) } return(false) } defineTest(qtConfLibrary_sybaseEnv) { libs = sybase = $$getenv(SYBASE) !isEmpty(sybase): \ libs += "-L$${sybase}/lib" libs += $$getenv(SYBASE_LIBS) !isEmpty(libs) { $${1}.libs = "$$val_escape(libs)" export($${1}.libs) } return(true) } # Check for Direct X SDK (include, lib, and direct shader compiler 'fxc'). # Up to Direct X SDK June 2010 and for MinGW, this is pointed to by the # DXSDK_DIR variable. Starting with Windows Kit 8, it is included in # the Windows SDK. Checking for the header is not sufficient, since it # is also present in MinGW. defineTest(qtConfTest_directX) { dxdir = $$getenv("DXSDK_DIR") !isEmpty(dxdir) { EXTRA_INCLUDEPATH += $$dxdir/include arch = $$qtConfEvaluate("tests.architecture.arch") equals(arch, x86_64): \ EXTRA_LIBDIR += $$dxdir/lib/x64 else: \ EXTRA_LIBDIR += $$dxdir/lib/x86 EXTRA_PATH += $$dxdir/Utilities/bin/x86 } $$qtConfEvaluate("features.sse2") { ky = $$size($${1}.files._KEYS_) $${1}.files._KEYS_ += $$ky # Not present on MinGW-32 $${1}.files.$${ky} = "intrin.h" } qtConfTest_files($${1}): return(true) return(false) } defineTest(qtConfTest_xkbConfigRoot) { qtConfTest_getPkgConfigVariable($${1}): return(true) for (dir, $$list("/usr/share/X11/xkb", "/usr/local/share/X11/xkb")) { exists($$dir) { $${1}.value = $$dir export($${1}.value) $${1}.cache += value export($${1}.cache) return(true) } } return(false) } defineTest(qtConfTest_qpaDefaultPlatform) { name = !isEmpty(config.input.qpa_default_platform): name = $$config.input.qpa_default_platform else: !isEmpty(QT_QPA_DEFAULT_PLATFORM): name = $$QT_QPA_DEFAULT_PLATFORM else: winrt: name = winrt else: win32: name = windows else: android: name = android else: osx: name = cocoa else: ios: name = ios else: qnx: name = qnx else: integrity: name = integrityfb else: name = xcb $${1}.value = $$name $${1}.plugin = q$$name $${1}.name = "\"$$name\"" export($${1}.value) export($${1}.plugin) export($${1}.name) $${1}.cache += value plugin name export($${1}.cache) return(true) } # custom outputs defineTest(qtConfOutput_shared) { !$${2}: return() # export this here, so later tests can use it CONFIG += shared export(CONFIG) } defineTest(qtConfOutput_architecture) { arch = $$qtConfEvaluate("tests.architecture.arch") $$qtConfEvaluate("features.cross_compile") { host_arch = $$qtConfEvaluate("tests.host_architecture.arch") privatePro = \ "host_build {" \ " QT_CPU_FEATURES.$$host_arch = $$qtConfEvaluate('tests.host_architecture.subarch')" \ "} else {" \ " QT_CPU_FEATURES.$$arch = $$qtConfEvaluate('tests.architecture.subarch')" \ "}" publicPro = \ "host_build {" \ " QT_ARCH = $$host_arch" \ " QT_TARGET_ARCH = $$arch" \ "} else {" \ " QT_ARCH = $$arch" \ "}" } else { privatePro = \ "QT_CPU_FEATURES.$$arch = $$qtConfEvaluate('tests.architecture.subarch')" publicPro = \ "QT_ARCH = $$arch" } config.output.publicPro += $$publicPro export(config.output.publicPro) config.output.privatePro += $$privatePro export(config.output.privatePro) # setup QT_ARCH variable used by qtConfEvaluate QT_ARCH = $$arch export(QT_ARCH) } defineTest(qtConfOutput_styles) { !$${2}: return() style = $$replace($${1}.feature, "style-", "") qtConfOutputVar(append, "privatePro", "styles", $$style) } defineTest(qtConfOutput_sqldriver) { $${2}: qtConfOutputVar(append, "privatePro", "sql-drivers", $$eval($${1}.feature)) } 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 = $$eval(config.tests.pkg-config.pkgConfig) export(PKG_CONFIG) # this method also exports PKG_CONFIG_(LIB|SYSROOT)DIR, so that tests using pkgConfig will work correctly PKG_CONFIG_SYSROOT_DIR = $$eval(config.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(config.tests.pkg-config.pkgConfigLibdir) !isEmpty(PKG_CONFIG_LIBDIR) { qtConfOutputVar(assign, "publicPro", "PKG_CONFIG_LIBDIR", $$PKG_CONFIG_LIBDIR) export(PKG_CONFIG_LIBDIR) } } 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_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_compilerVersion) { !$${2}: return() name = $$upper($$config.tests.compiler.compilerId) version = $$config.tests.compiler.compilerVersion major = $$section(version, '.', 0, 0) minor = $$section(version, '.', 1, 1) patch = $$section(version, '.', 2, 2) isEmpty(minor): minor = 0 isEmpty(patch): patch = 0 config.output.publicPro += \ "QT_$${name}_MAJOR_VERSION = $$major" \ "QT_$${name}_MINOR_VERSION = $$minor" \ "QT_$${name}_PATCH_VERSION = $$patch" export(config.output.publicPro) } # should go away when qfeatures.txt is ported defineTest(qtConfOutput_extraFeatures) { isEmpty(config.input.extra_features): return() # write to qconfig.pri config.output.publicPro += "$${LITERAL_HASH}ifndef QT_BOOTSTRAPPED" for (f, config.input.extra_features) { feature = $$replace(f, "^no-", "") FEATURE = $$upper($$replace(feature, -, _)) contains(f, "^no-.*") { config.output.publicPro += \ "$${LITERAL_HASH}ifndef QT_NO_$$FEATURE" \ "$${LITERAL_HASH}define QT_NO_$$FEATURE" \ "$${LITERAL_HASH}endif" } else { config.output.publicPro += \ "$${LITERAL_HASH}if defined(QT_$$FEATURE) && defined(QT_NO_$$FEATURE)" \ "$${LITERAL_HASH}undef QT_$$FEATURE" \ "$${LITERAL_HASH}elif !defined(QT_$$FEATURE) && !defined(QT_NO_$$FEATURE)" \ "$${LITERAL_HASH}define QT_$$FEATURE" \ "$${LITERAL_HASH}endif" } } config.output.publicPro += "$${LITERAL_HASH}endif" export(config.output.publicPro) # write to qmodule.pri disabled_features = for (f, config.input.extra_features) { feature = $$replace(f, "^no-", "") FEATURE = $$upper($$replace(feature, -, _)) contains(f, "^no-.*"): disabled_features += $$FEATURE } !isEmpty(disabled_features): qtConfOutputVar(assign, "privatePro", QT_NO_DEFINES, $$disabled_features) } 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)" } config.output.privatePro += $$output export(config.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) output = \ "!host_build {" \ " QMAKE_CFLAGS += --sysroot=\$\$[QT_SYSROOT]" \ " QMAKE_CXXFLAGS += --sysroot=\$\$[QT_SYSROOT]" \ " QMAKE_LFLAGS += --sysroot=\$\$[QT_SYSROOT]" \ "}" config.output.publicPro += $$output export(config.output.publicPro) } defineTest(qtConfOutput_qmakeArgs) { !$${2}: return() config.output.privatePro = "!host_build {" for (a, config.input.qmakeArgs) { config.output.privatePro += " $$a" EXTRA_QMAKE_ARGS += $$system_quote($$a) } config.output.privatePro += "}" export(EXTRA_QMAKE_ARGS) export(config.output.privatePro) } defineTest(qtConfOutputPostProcess_publicPro) { qt_version = $$[QT_VERSION] output = \ "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" 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" } config.output.publicPro += $$output export(config.output.publicPro) } defineTest(qtConfOutputPostProcess_publicHeader) { qt_version = $$[QT_VERSION] output = \ "$${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)\"" config.output.publicHeader += $$output export(config.output.publicHeader) } # custom reporting defineTest(qtConfReport_buildParts) { qtConfReportPadded($${1}, $$qtConfEvaluate("tests.build_parts.value")) } defineTest(qtConfReport_buildTypeAndConfig) { !$$qtConfEvaluate("features.cross_compile") { qtConfAddReport("Build type: $$qtConfEvaluate('tests.architecture.arch')") } else { qtConfAddReport("Building on: $$qtConfEvaluate('tests.host_architecture.arch')") qtConfAddReport("Building for: $$qtConfEvaluate('tests.architecture.arch')") } qtConfAddReport() qtConfAddReport("Configuration: $$config.output.privatePro.append.CONFIG $$config.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" else: \ build_mode = $$release $$qtConfEvaluate("features.debug_and_release"): \ build_mode = "debug and $$release; default link: $$build_mode" $$qtConfEvaluate("features.release_tools"): \ build_mode = "$$build_mode; optimized tools" qtConfReportPadded($$1, $$build_mode) } # ensure pristine environment for configuration discard_from($$[QT_HOST_DATA/get]/mkspecs/qconfig.pri) discard_from($$[QT_HOST_DATA/get]/mkspecs/qmodule.pri) # load and process input from configure exists("$$OUT_PWD/config.tests/configure.cfg") { include("$$OUT_PWD/config.tests/configure.cfg") } load(qt_configure)