Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package kf6-extra-cmake-modules for
openSUSE:Factory checked in at 2026-09-11 17:59:04
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/kf6-extra-cmake-modules (Old)
and /work/SRC/openSUSE:Factory/.kf6-extra-cmake-modules.new.1265 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "kf6-extra-cmake-modules"
Fri Sep 11 17:59:04 2026 rev:31 rq:1376669 version:6.30.0
Changes:
--------
---
/work/SRC/openSUSE:Factory/kf6-extra-cmake-modules/kf6-extra-cmake-modules.changes
2026-08-17 16:58:20.037636900 +0200
+++
/work/SRC/openSUSE:Factory/.kf6-extra-cmake-modules.new.1265/kf6-extra-cmake-modules.changes
2026-09-11 18:01:03.114147359 +0200
@@ -1,0 +2,19 @@
+Tue Sep 8 09:21:40 UTC 2026 - Christophe Marin <[email protected]>
+
+- Update to 6.30.0
+ * New feature release
+ * For more details please see:
+ * https://kde.org/announcements/frameworks/6/6.30.0
+- Changes since 6.29.0:
+ * List ECM sources explicitly instead of using GLOBS
+ * ECMInstalledLibraryCheck: add more separating linebreaks to generated files
+ * ExecuteKDEModules: add newer KDE modules to test
+ * ExecuteKDEModules: split off support for apple platform, document it
+ * ECMInstalledLibraryCheck: use $<cond:string> over $<IF:cond,string,>
+ * Add ECMInstalledLibraryCheck
+ * ecm_generate_export_header: make VERSION optional, default to
PROJECT_VERSION
+ * ECMSetupVersion: support version args in <major>.<minor> and <major> forms
+ * ECMSetupVersion: use final hex number in version header, not calculation
+ * Update version to 6.30.0
+
+-------------------------------------------------------------------
Old:
----
extra-cmake-modules-6.29.0.tar.xz
extra-cmake-modules-6.29.0.tar.xz.sig
New:
----
extra-cmake-modules-6.30.0.tar.xz
extra-cmake-modules-6.30.0.tar.xz.sig
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ kf6-extra-cmake-modules.spec ++++++
--- /var/tmp/diff_new_pack.USePSK/_old 2026-09-11 18:01:04.526206239 +0200
+++ /var/tmp/diff_new_pack.USePSK/_new 2026-09-11 18:01:04.532206489 +0200
@@ -23,12 +23,12 @@
%define rname extra-cmake-modules
-# Full KF6 version (e.g. 6.29.0)
+# Full KF6 version (e.g. 6.30.0)
%{!?_kf6_version: %global _kf6_version %{version}}
%bcond_without doc
%bcond_without released
Name: kf6-extra-cmake-modules%{?pkg_suffix}
-Version: 6.29.0
+Version: 6.30.0
Release: 0
Summary: CMake modules
License: BSD-3-Clause
++++++ extra-cmake-modules-6.29.0.tar.xz -> extra-cmake-modules-6.30.0.tar.xz
++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-cmake-modules-6.29.0/.gitignore
new/extra-cmake-modules-6.30.0/.gitignore
--- old/extra-cmake-modules-6.29.0/.gitignore 2026-08-07 22:38:40.000000000
+0200
+++ new/extra-cmake-modules-6.30.0/.gitignore 2026-09-04 13:36:44.000000000
+0200
@@ -2,6 +2,9 @@
cmake/ECMConfig.cmake
cmake/ECMConfigVersion.cmake
+# Ignore generated test clang-format file
+tests/ExecuteKDEModules/.clang-format
+
# Ignore the following files
*~
*.[oa]
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-cmake-modules-6.29.0/CMakeLists.txt
new/extra-cmake-modules-6.30.0/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/CMakeLists.txt 2026-08-07
22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -11,7 +11,7 @@
# Preliminary setup
#
-set(VERSION "6.29.0") # handled by release scripts
+set(VERSION "6.30.0") # handled by release scripts
project(ECM
VERSION "${VERSION}"
@@ -42,6 +42,7 @@
set(FIND_MODULES_INSTALL_DIR ${SHARE_INSTALL_DIR}/ECM/find-modules/)
set(KDE_MODULES_INSTALL_DIR ${SHARE_INSTALL_DIR}/ECM/kde-modules)
set(MODULES_INSTALL_DIR ${SHARE_INSTALL_DIR}/ECM/modules/)
+set(TEST_MODULES_INSTALL_DIR ${SHARE_INSTALL_DIR}/ECM/test-modules/)
set(TOOLCHAIN_MODULES_INSTALL_DIR ${SHARE_INSTALL_DIR}/ECM/toolchain/)
set(DOC_INSTALL_DIR ${SHARE_INSTALL_DIR}/doc/ECM
@@ -83,23 +84,15 @@
# Install modules
#
-file(GLOB installModuleFiles ${CMAKE_SOURCE_DIR}/modules/*[^~])
-install(FILES ${installModuleFiles} DESTINATION ${MODULES_INSTALL_DIR})
+add_subdirectory(modules)
-file(GLOB installTestModuleFiles ${CMAKE_SOURCE_DIR}/test-modules/*[^~])
-install(FILES ${installTestModuleFiles} DESTINATION
${SHARE_INSTALL_DIR}/ECM/test-modules)
+add_subdirectory(test-modules)
-file(GLOB installKdeModuleFiles LIST_DIRECTORIES FALSE
${CMAKE_SOURCE_DIR}/kde-modules/*[^~])
-install(FILES ${installKdeModuleFiles} DESTINATION ${KDE_MODULES_INSTALL_DIR})
-# The scripts need to be executable
-file(GLOB installKDECommitHooks
${CMAKE_SOURCE_DIR}/kde-modules/kde-git-commit-hooks/*[^~])
-install(PROGRAMS ${installKDECommitHooks} DESTINATION
${KDE_MODULES_INSTALL_DIR}/kde-git-commit-hooks)
+add_subdirectory(kde-modules)
-file(GLOB installFindModuleFiles ${CMAKE_SOURCE_DIR}/find-modules/*.cmake
${CMAKE_SOURCE_DIR}/find-modules/*.py)
-install(FILES ${installFindModuleFiles} DESTINATION
${FIND_MODULES_INSTALL_DIR})
+add_subdirectory(find-modules)
-file(GLOB installToolchainModuleFiles ${CMAKE_SOURCE_DIR}/toolchain/*[^~])
-install(FILES ${installToolchainModuleFiles} DESTINATION
${TOOLCHAIN_MODULES_INSTALL_DIR})
+add_subdirectory(toolchain)
#
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-cmake-modules-6.29.0/docs/CMakeLists.txt
new/extra-cmake-modules-6.30.0/docs/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/docs/CMakeLists.txt 2026-08-07
22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/docs/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -109,8 +109,14 @@
add_custom_target(documentation ALL DEPENDS ${doc_format_outputs})
if(BUILD_MAN_DOCS)
- file(GLOB man_rst RELATIVE ${ECM_SOURCE_DIR}/docs/manual
- ${ECM_SOURCE_DIR}/docs/manual/*.[1-9].rst)
+ set(man_rst
+ ecm.7.rst
+ ecm-developer.7.rst
+ ecm-find-modules.7.rst
+ ecm-kde-modules.7.rst
+ ecm-modules.7.rst
+ ecm-toolchains.7.rst
+ )
foreach(m ${man_rst})
if("x${m}" MATCHES "^x(.+)\\.([1-9])\\.rst$")
set(name "${CMAKE_MATCH_1}")
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/docs/module/ECMInstalledLibraryCheck.rst
new/extra-cmake-modules-6.30.0/docs/module/ECMInstalledLibraryCheck.rst
--- old/extra-cmake-modules-6.29.0/docs/module/ECMInstalledLibraryCheck.rst
1970-01-01 01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/docs/module/ECMInstalledLibraryCheck.rst
2026-09-04 13:36:44.000000000 +0200
@@ -0,0 +1 @@
+.. ecm-module:: ../../modules/ECMInstalledLibraryCheck.cmake
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/find-modules/CMakeLists.txt
new/extra-cmake-modules-6.30.0/find-modules/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/find-modules/CMakeLists.txt 1970-01-01
01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/find-modules/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+install(FILES
+ ECMFindModuleHelpersStub.cmake
+ Find7z.cmake
+ Find7Zip.cmake
+ FindCanberra.cmake
+ FindEGL.cmake
+ Findepoxy.cmake
+ FindFFmpeg.cmake
+ FindGLIB2.cmake
+ FindGperf.cmake
+ FindGradle.cmake
+ local.properties.cmake
+ settings.gradle.cmake
+ Findgzip.cmake
+ FindIcoTool.cmake
+ FindInotify.cmake
+ FindIsoCodes.cmake
+ FindKF5.cmake
+ FindKF6.cmake
+ FindLibcap.cmake
+ FindLibExiv2.cmake
+ FindLibGit2.cmake
+ FindLibMount.cmake
+ FindOpenEXR.cmake
+ FindPhoneNumber.cmake
+ FindPoppler.cmake
+ FindPulseAudio.cmake
+ FindQHelpGenerator.cmake
+ FindQtWaylandScanner.cmake
+ FindReuseTool.cmake
+ FindSasl2.cmake
+ FindSeccomp.cmake
+ FindSharedMimeInfo.cmake
+ FindTaglib.cmake
+ FindUDev.cmake
+ FindWayland.cmake
+ FindWaylandProtocols.cmake
+ FindWaylandScanner.cmake
+ FindX11_XCB.cmake
+ FindXCB.cmake
+
+ DESTINATION ${FIND_MODULES_INSTALL_DIR}
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/kde-modules/CMakeLists.txt
new/extra-cmake-modules-6.30.0/kde-modules/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/kde-modules/CMakeLists.txt 1970-01-01
01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/kde-modules/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+install(FILES
+ KDEClangFormat.cmake
+ clang-format.cmake
+ KDECMakeSettings.cmake
+ appstreamtest.cmake
+ KDECompilerSettings.cmake
+ KDEFrameworkCompilerLegacySettings.cmake
+ KDEFrameworkCompilerSettings.cmake
+ KDEGitCommitHooks.cmake
+ KDEInstallDirs5.cmake
+ KDEInstallDirs6.cmake
+ KDEInstallDirs.cmake
+ KDEInstallDirsCommon.cmake
+ KDEMetaInfoPlatformCheck.cmake
+ KDEPackageAppTemplates.cmake
+ KDESetupPrefixScript.cmake
+ prefix.sh.cmake
+ prefix.sh.fish.cmake
+
+ DESTINATION ${KDE_MODULES_INSTALL_DIR}
+)
+
+install(FILES
+ kde-git-commit-hooks/combined.schema.json.in
+ kde-git-commit-hooks/combined.schema.json.in.license
+
+ DESTINATION ${KDE_MODULES_INSTALL_DIR}/kde-git-commit-hooks
+)
+
+# The scripts need to be executable
+install(PROGRAMS
+ kde-git-commit-hooks/clang-format.sh
+ kde-git-commit-hooks/json-schema.py
+ kde-git-commit-hooks/pre-commit.in
+
+ DESTINATION ${KDE_MODULES_INSTALL_DIR}/kde-git-commit-hooks
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-cmake-modules-6.29.0/modules/CMakeLists.txt
new/extra-cmake-modules-6.30.0/modules/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/modules/CMakeLists.txt 1970-01-01
01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/modules/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -0,0 +1,68 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+install(FILES
+ CheckAtomic.cmake
+ ECMAddAndroidApk.cmake
+ ECMAddAppIcon.cmake
+ ECMAddQch.cmake
+ ECMQchDoxygen.config.in
+ ECMQchDoxygenLayout.xml
+ ECMAddQtDesignerPlugin.cmake
+ ECMAddTests.cmake
+ ECMCheckOutboundLicense.cmake
+ check-outbound-license.py
+ ECMConfiguredInstall.cmake
+ ECMCoverageOption.cmake
+ ECMCreateQmFromPoFiles.cmake
+ ECMDeprecationSettings.cmake
+ ECMEnableSanitizers.cmake
+ ECMFeatureSummary.cmake
+ ECMFindModuleHelpers.cmake
+ ECMFindQmlModule.cmake
+ ECMFindQmlModule.cmake.in
+ ECMGenerateDBusServiceFile.cmake
+ ECMGenerateExportHeader.cmake
+ ECMGenerateHeaders.cmake
+ ECMGeneratePkgConfigFile.cmake
+ ECMGeneratePriFile.cmake
+ ECMGeneratePythonBindings.cmake
+ ECMGeneratePythonBindings.toml.in
+ ECMGeneratePythonBindings.toml.in.license
+ ECMGenerateQDoc.cmake
+ ECMGenerateQmlTypes.cmake
+ ECMInstalledLibraryCheck.cmake
+ ecm_create_installed_library_check.cmake
+ ECMInstallIcons.cmake
+ ECMMarkAsTest.cmake
+ ECMMarkNonGuiExecutable.cmake
+ ECMOptionalAddSubdirectory.cmake
+ ECMPackageConfigHelpers.cmake
+ ECMPoQmTools.cmake
+ ECMQmLoader.cpp.in
+ ECMQmlModule5.cmake
+ ECMQmlModule6.cmake
+ ECMQmlModule.cmake
+ ECMQmlModule.cpp.in
+ ECMQmlModule.cpp.in.license
+ ECMQmlModule.h.in
+ ECMQmlModule.h.in.license
+ ECMQMLModules.cmake
+ ECMQtDeclareLoggingCategory.cmake
+ ECMQtDeclareLoggingCategory.cpp.in
+ ECMQtDeclareLoggingCategory.h.in
+ ECMQueryQmake.cmake
+ ECMQueryQt.cmake
+ ECMSetupQtPluginMacroNames.cmake
+ ECMSetupVersion.cmake
+ ECMVersionHeader.h.in
+ ECMSourceVersionControl.cmake
+ ECMUninstallTarget.cmake
+ ecm_uninstall.cmake.in
+ ECMUseFindModules.cmake
+ ECMWinResolveSymlinks.cmake
+ QtVersionOption.cmake
+
+ DESTINATION ${MODULES_INSTALL_DIR}
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/modules/ECMGenerateExportHeader.cmake
new/extra-cmake-modules-6.30.0/modules/ECMGenerateExportHeader.cmake
--- old/extra-cmake-modules-6.29.0/modules/ECMGenerateExportHeader.cmake
2026-08-07 22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/modules/ECMGenerateExportHeader.cmake
2026-09-04 13:36:44.000000000 +0200
@@ -18,7 +18,7 @@
::
ecm_generate_export_header(<library_target_name>
- VERSION <version>
+ [VERSION <version>] # Optional since 6.30
[BASE_NAME <base_name>]
[GROUP_BASE_NAME <group_base_name>]
[EXPORT_MACRO_NAME <export_macro_name>]
@@ -41,7 +41,8 @@
)
``VERSION`` specifies the version of the library, given in the format
-"<major>.<minor>.<patchlevel>".
+"<major>.<minor>.<patchlevel>". Since 6.30 this argument is optional if
+``${PROJECT_VERSION}`` is set and will default to that.
``GROUP_BASE_NAME`` specifies the name to use for the macros defining
library group default values. If set, this will generate code supporting
@@ -515,15 +516,25 @@
# helper string
set(_version_triple_regexp "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$")
# args sanity check
- if (NOT ARGS_VERSION)
- message(FATAL_ERROR "No VERSION passed when calling
ecm_generate_export_header().")
- elseif(NOT ARGS_VERSION MATCHES ${_version_triple_regexp})
- message(FATAL_ERROR "VERSION expected to be in x.y.z format when
calling ecm_generate_export_header().")
+ if (ARGS_VERSION)
+ if(NOT ARGS_VERSION MATCHES ${_version_triple_regexp})
+ message(FATAL_ERROR "VERSION expected to be in x.y.z format when
calling ecm_generate_export_header(), is: ${ARGS_VERSION}")
+ endif()
+ set(_version ${ARGS_VERSION})
+ else()
+ if (PROJECT_VERSION)
+ if(NOT PROJECT_VERSION MATCHES ${_version_triple_regexp})
+ message(FATAL_ERROR "PROJECT_VERSION expected to be in x.y.z
format when calling ecm_generate_export_header(), is: ${PROJECT_VERSION}")
+ endif()
+ set(_version ${PROJECT_VERSION})
+ else()
+ message(FATAL_ERROR "No VERSION passed when calling
ecm_generate_export_header().")
+ endif()
endif()
if (NOT ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT)
set(ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT 0)
elseif(ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT STREQUAL "CURRENT")
- set(ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT ${ARGS_VERSION})
+ set(ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT ${_version})
elseif(NOT ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT MATCHES
${_version_triple_regexp} AND
NOT ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT STREQUAL "0")
message(FATAL_ERROR "EXCLUDE_DEPRECATED_BEFORE_AND_AT expected to be
in \"x.y.z\" format, \"0\" or \"CURRENT\" when calling
ecm_generate_export_header().")
@@ -532,12 +543,12 @@
if (ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT)
set(ARGS_DEPRECATED_BASE_VERSION
"${ARGS_EXCLUDE_DEPRECATED_BEFORE_AND_AT}")
else()
- string(REGEX REPLACE ${_version_triple_regexp} "\\1"
_version_major "${ARGS_VERSION}")
+ string(REGEX REPLACE ${_version_triple_regexp} "\\1"
_version_major "${_version}")
set(ARGS_DEPRECATED_BASE_VERSION "${_version_major}.0.0")
endif()
else()
if(ARGS_DEPRECATED_BASE_VERSION STREQUAL "CURRENT")
- set(ARGS_DEPRECATED_BASE_VERSION ${ARGS_VERSION})
+ set(ARGS_DEPRECATED_BASE_VERSION ${_version})
elseif(NOT ARGS_DEPRECATED_BASE_VERSION MATCHES
${_version_triple_regexp} AND
NOT ARGS_DEPRECATED_BASE_VERSION STREQUAL "0")
message(FATAL_ERROR "DEPRECATED_BASE_VERSION expected to be in
\"x.y.z\" format, \"0\" or \"CURRENT\" when calling
ecm_generate_export_header().")
@@ -574,7 +585,7 @@
set(_version_hexnumber "${_upper_version_base_name}_VERSION")
endif()
else()
- _ecm_geh_generate_hex_number(_version_hexnumber "${ARGS_VERSION}")
+ _ecm_geh_generate_hex_number(_version_hexnumber "${_version}")
endif()
if(NOT ARGS_EXPORT_FILE_NAME)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/modules/ECMInstalledLibraryCheck.cmake
new/extra-cmake-modules-6.30.0/modules/ECMInstalledLibraryCheck.cmake
--- old/extra-cmake-modules-6.29.0/modules/ECMInstalledLibraryCheck.cmake
1970-01-01 01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/modules/ECMInstalledLibraryCheck.cmake
2026-09-04 13:36:44.000000000 +0200
@@ -0,0 +1,549 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+ECMInstalledLibraryCheck
+------------------------
+
+Generates a check to test artifacts of the library installation, like the
+self-containedness of the CMake config files as well as of the official public
+headers in the deployed directory layout.
+
+::
+
+ ecm_add_installed_library_check(<library_target>
+ [PACKAGE_NAME <package_name>]
+ [PACKAGE_VERSION <package_version>]
+ {NO_PACKAGE_VERSION]
+ [PACKAGE_TARGET_NAMESPACE <package_target_namespace>]
+ [NO_PACKAGE_TARGET_NAMESPACE]
+ [COMPILE_DEFINITIONS <definition> [...]]
+ [EXTRA_DEPENDENCIES <dependency> [<version>] [...]]
+ [EXTRA_LINK_LIBRARIES <library> [...]]
+ )
+
+The function creates a target ``<library_target>_installed_library_check``
which
+can be invoked after the installation to check if the installed library
+artifacts are self-contained when used by a consumer.
+All these targets are added as dependency to a target
+``all_installed_library_check``, which is created at the level where this
module
+is included, if there is none yet.
+
+The check generates a CMake project with a dummy library which searches the
+given package for any specified version, links to the exported target as
+imported from the package's CMake config file and as its sources add for each
+given include strings a source file with just the content
+``#include <include_string>``. Additionally checks are added to the CMake code
+and the source files for any CMake variables, compile definitions and
+preprocessor macros as configured by the additional functions (see below).
+This project then is configured with CMake and all these sources are built. The
+check is considered as passed, when the build completes.
+
+``PACKAGE_NAME`` specifies the name of the CMake package to check for.
+The default is ``${PROJECT_NAME}``.
+
+``PACKAGE_VERSION`` specifies the version of the CMake package to check for.
+The default is ``${PROJECT_VERSION}`` if set and ``NO_PACKAGE_VERSION`` not
+being used, otherwise none.
+
+``NO_PACKAGE_VERSION`` defines that the CMake package has no version to check
+for.
+
+``PACKAGE_TARGET_NAMESPACE`` specifies what namespace the exported target
+name of the library is placed in. The default is the value estimated for
+the package name, unless ``NO_PACKAGE_TARGET_NAMESPACE`` is set.
+
+``NO_PACKAGE_TARGET_NAMESPACE`` defines that the library target is exported
+in the package without any namespace.
+
+``COMPILE_DEFINITIONS`` can be used to set custom definitions for the test
+builds against the headers.
+
+``EXTRA_DEPENDENCIES`` can be used to add custom dependencies to search for
+with ``find_package()``. This can be used if the current dependencies declared
+in the installed CMake config file are not complete, but can not be changed.
+
+``EXTRA_LINK_LIBRARIES`` can be used to add custom libraries to link to with
+``target_link_libraries()``. This can be used if the current list of libraries
+in the public interface is not complete, but can not be changed.
+
+::
+
+ ecm_installed_library_check_include_strings(<library_target>
+ HEADERS <header> [...]
+ [PREFIX <prefix>]
+ )
+
+This function registers include strings with the check, by listing files
+which will be used as official public headers.
+
+``HEADERS`` specifies the header files whose base names will be available as
+public include strings. The actual path of any file listed is ignored, it also
+does not need to reference any existing file.
+
+``PREFIX`` specifies a prefix which consumers need to prepend to the base
+names of the headers passed to ``HEADERS``. The argument ``<prefix>`` is
+specified without a trailing "/". Default is none.
+
+::
+
+ ecm_installed_library_check_cmake_variable(<library_target>
+ NAME <name>
+ [VALUE <value>]
+ [UNDEFINED]
+ [TYPE <type>]
+ )
+
+This function registers a CMake variable with the check which should be tested
+for presence and its value after the library's CMake package has been found.
+
+``NAME`` specifies the name of a variable expected to be set after finding the
+package.
+
+``VALUE`` specifies the value expected to be set for the variable. For
+variables of the type ``BOOL`` the usual evaluation of CMake to a boolean value
+is checked. If this argument is not passed, the variable. is only tested for
+being defined.
+
+``UNDEFINED`` specifies if the variable should be tested for being undefined.
+
+``TYPE`` specifies the type of the variable. The options are ``BOOL``,
+``STRING``. Default is ``STRING``.
+
+::
+
+ ecm_installed_library_check_compile_definition(<library_target>
+ NAME <name>
+ [VALUE <value>]
+ [UNDEFINED]
+ )
+
+This function registers a compile definition with the check which should be
+tested for being set on the imported library target.
+
+``NAME`` specifies the name of the compile definition to test.
+
+``VALUE`` specifies the value expected to be set for the compile definition.
+If this argument is not passed, the compile definition is only tested for being
+defined. Only numeric values are supported.
+
+``UNDEFINED`` specifies if the compile definition should be tested for being
+undefined.
+
+::
+
+ ecm_installed_library_check_preprocessor_macro(<library_target>
+ NAME <name>
+ [VALUE <value>]
+ [UNDEFINED]
+ )
+
+This function registers a preprocessor macro with the check which should be
+tested for being present with all registered include strings.
+
+``NAME`` specifies the name of the macro to test.
+
+``VALUE`` specifies the value expected to be set for the macro. If this
argument
+is not passed, the macro is only tested for being defined. Only numeric values
+are supported.
+
+``UNDEFINED`` specifies if the macro should be tested for being undefined.
+
+::
+
+ ecm_installed_library_check_version_preprocessor_macros(<library_target>
+ [PREFIX <prefix>]
+ [VERSION <version>]
+ )
+
+This function is a convenience utility to register a usual set of preprocessor
+macros with the check which should be tested for being present with all
+registered include strings and match the given version. Such macros are e.g.
+created by the macro ``ecm_setup_version()`` from the module
+:module:`ECMSetupVersion` when using the ``VERSION_HEADER`` argument to
+generate a version header.
+
+``PREFIX`` specifies the prefix of the version macros to test. The expected
+macro names are:
+
+* ``<prefix>_VERSION`` (hexadecimal number in ``0xMMmmpp`` format)
+* ``<prefix>_VERSION_MAJOR``
+* ``<prefix>_VERSION_MINOR``
+* ``<prefix>_VERSION_PATCH``
+
+Default is the library target name in upper case.
+
+``VERSION`` specifies the version string "<major>.<minor>.<patch>" with the
+expected version values. The default is any "VERSION" property set on the
+target, otherwise any package version defined for the check, or otherwise
+``${PROJECT_VERSION}``.
+
+Example usage:
+
+.. code-block:: cmake
+
+ # add a non-default target "MyLib_installed_library_check",
+ # which will test for a CMake config file for "MyPackage",
+ # at version "1.0", with the imported library target
+ # "MyPackage::MyLib" and whose include strings (headers)
+ # can be used self-contained when linking the target
+ ecm_add_installed_library_check(MyLib
+ PACKAGE_NAME "MyPackage"
+ PACKAGE_VERSION "1.0"
+ )
+
+ # for any <MLFoo> etc. includes
+ ecm_installed_library_check_include_strings(MyLib
+ HEADERS
+ /absolute/path/MLFoo
+ relative/path/MLBar
+ # etc
+ )
+
+ # for any <ML/Foo> etc. includes
+ ecm_installed_library_check_include_strings(MyLib
+ HEADERS
+ /absolute/path/Foo
+ relative/path/Bar
+ # etc
+ PREFIX ML
+ )
+
+Since 6.30
+#]=======================================================================]
+
+cmake_policy(VERSION 3.29)
+
+# create global target, at include level
+if(NOT TARGET all_installed_library_check)
+ add_custom_target(all_installed_library_check)
+endif()
+
+
+function(ecm_add_installed_library_check _target)
+ set(options NO_PACKAGE_TARGET_NAMESPACE NO_PACKAGE_VERSION)
+ set(oneValueArgs PACKAGE_NAME PACKAGE_VERSION PACKAGE_TARGET_NAMESPACE)
+ set(multiValueArgs EXTRA_DEPENDENCIES EXTRA_LINK_LIBRARIES
COMPILE_DEFINITIONS)
+
+ cmake_parse_arguments(ARG "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
+
+ # argument checks
+ if(ARG_UNPARSED_ARGUMENTS)
+ message(FATAL_ERROR "Unknown keywords given to
ecm_add_installed_library_check(): \"${ARG_UNPARSED_ARGUMENTS}\"")
+ endif()
+ if(ARG_NO_PACKAGE_TARGET_NAMESPACE AND ARG_PACKAGE_TARGET_NAMESPACE)
+ message(FATAL_ERROR "ecm_add_installed_library_check cannot be called
with both NO_PACKAGE_TARGET_NAMESPACE and PACKAGE_TARGET_NAMESPACE args.")
+ endif()
+ if(ARG_NO_PACKAGE_VERSION AND ARG_PACKAGE_VERSION)
+ message(FATAL_ERROR "ecm_add_installed_library_check cannot be called
with both NO_PACKAGE_VERSION and PACKAGE_VERSION args.")
+ endif()
+ set(_library_types "STATIC_LIBRARY" "SHARED_LIBRARY" "INTERFACE_LIBRARY")
+ get_target_property(_type ${_target} TYPE)
+ if(NOT ${_type} IN_LIST _library_types)
+ message(FATAL_ERROR "ecm_add_installed_library_check cannot be called
on a target which is not some library. Was: ${_type}")
+ endif()
+
+ # setup data
+ if(ARG_PACKAGE_NAME)
+ set(_package_name "${ARG_PACKAGE_NAME}")
+ else()
+ set(_package_name "${PROJECT_NAME}")
+ endif()
+ if(ARG_PACKAGE_VERSION)
+ set(_package_version ${ARG_PACKAGE_VERSION})
+ else()
+ if(NOT ARG_NO_PACKAGE_VERSION AND PROJECT_VERSION)
+ set(_package_version ${PROJECT_VERSION})
+ else()
+ set(_package_version)
+ endif()
+ endif()
+ if(ARG_PACKAGE_TARGET_NAMESPACE)
+ set(_library_target_namespace ${ARG_PACKAGE_TARGET_NAMESPACE})
+ else()
+ if(ARG_NO_PACKAGE_TARGET_NAMESPACE)
+ set(_library_target_namespace)
+ else()
+ set(_library_target_namespace "${_package_name}::")
+ endif()
+ endif()
+
+ set(_compiler_propagation)
+ foreach(_compiler IN ITEMS CMAKE_C_COMPILER CMAKE_CXX_COMPILER)
+ if (${_compiler})
+ list(APPEND _compiler_propagation "-D${_compiler}=${${_compiler}}")
+ endif()
+ endforeach()
+
+ set(_languages)
+ if (CMAKE_C_COMPILER)
+ list(APPEND _languages "C")
+ endif()
+ if (CMAKE_CXX_COMPILER)
+ list(APPEND _languages "CXX")
+ endif()
+
+ set(_installed_library_check_dir
"${CMAKE_CURRENT_BINARY_DIR}/${_target}_ECMInstalledLibraryCheck")
+
+ # prepare (generator) expressions, to pick up data for the check set only
after this function's call
+ set(_include_strings
"$<TARGET_PROPERTY:${_target},ECM_INSTALLED_LIBRARY_INCLUDE_STRINGS>")
+ set(_include_strings_sorted "$<LIST:SORT,${_include_strings}>")
+
+ set(_exported_target_name "$<TARGET_PROPERTY:${_target},EXPORT_NAME>")
+ set(_library_target_name
"${_library_target_namespace}$<IF:$<BOOL:${_exported_target_name}>,${_exported_target_name},${_target}>")
+
+ set(_cmake_variables_check_data
"$<TARGET_PROPERTY:${_target},ECM_INSTALLED_LIBRARY_CMAKE_VARIABLES_CHECK_DATA>")
+
+ set(_compile_definitions_check_data
"$<TARGET_PROPERTY:${_target},ECM_INSTALLED_LIBRARY_COMPILE_DEFINITIONS_CHECK_DATA>")
+
+ set(_preprocessor_macro_check_data
"$<TARGET_PROPERTY:${_target},ECM_INSTALLED_LIBRARY_PREPROCESSOR_MACRO_CHECK_DATA>")
+ set(_version_check_prefix
"$<TARGET_PROPERTY:${_target},ECM_INSTALLED_LIBRARY_VERSION_PREPROCESSOR_MACRO_CHECK_PREFIX>")
+ set(_version_check_data
"$<TARGET_PROPERTY:${_target},ECM_INSTALLED_LIBRARY_VERSION_PREPROCESSOR_MACRO_CHECK_DATA>")
+ set(_version_preprocessor_macro_check_data
"$<$<BOOL:${_version_check_data}>:${_version_check_prefix}:>${_version_check_data}$<$<STREQUAL:${_version_check_data},DEFAULT>:|$<TARGET_PROPERTY:${_target},VERSION>|${_package_version}>")
+
+ # prepare non-generator-expression list values for passing as command
+ # avoids space being used as list separator when expanding there even
inside ""
+ list(JOIN _languages $<SEMICOLON> _languages)
+ list(JOIN ARG_EXTRA_DEPENDENCIES $<SEMICOLON> _extra_dependencies)
+ list(JOIN ARG_EXTRA_LINK_LIBRARIES $<SEMICOLON> _extra_link_libraries)
+ list(JOIN ARG_COMPILE_DEFINITIONS $<SEMICOLON> _compile_definitions)
+
+ # prepare dir
+ file(MAKE_DIRECTORY ${_installed_library_check_dir})
+
+ set(_check_target_name ${_target}_installed_library_check)
+
+ add_custom_target(${_check_target_name}
+ COMMENT "Running installed library check for ${_target}"
+ COMMAND ${CMAKE_COMMAND}
+ -DOUTPUT_DIR="${_installed_library_check_dir}"
+ -DLANGUAGES="${_languages}"
+ -DPACKAGE_NAME="${_package_name}"
+ -DPACKAGE_VERSION="${_package_version}"
+ -DPACKAGE_INSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}"
+ -DLIBRARY_TARGET_NAME="${_library_target_name}"
+ -DEXTRA_DEPENDENCIES="${_extra_dependencies}"
+ -DEXTRA_LINK_LIBRARIES="${_extra_link_libraries}"
+ -DEXTRA_COMPILE_DEFINITIONS="${_compile_definitions}"
+ -DINCLUDE_STRINGS="${_include_strings_sorted}"
+ -DCMAKE_VARIABLES_CHECK_DATA="${_cmake_variables_check_data}"
+
-DCOMPILE_DEFINITIONS_CHECK_DATA="${_compile_definitions_check_data}"
+ -DPREPROCESSOR_MACRO_CHECK_DATA="${_preprocessor_macro_check_data}"
+
-DVERSION_PREPROCESSOR_MACRO_CHECK_DATA="${_version_preprocessor_macro_check_data}"
+ -P
"${CMAKE_CURRENT_FUNCTION_LIST_DIR}/ecm_create_installed_library_check.cmake"
+ COMMAND ${CMAKE_COMMAND}
+ # TODO: other options to pass on? e.g. for cross-compilation,
tool-chain file?
+ -G ${CMAKE_GENERATOR}
+ ${_compiler_propagation}
+ --fresh
+ .
+ COMMAND ${CMAKE_COMMAND} --build .
+ WORKING_DIRECTORY ${_installed_library_check_dir}
+ JOB_SERVER_AWARE
+ )
+
+ add_dependencies(all_installed_library_check ${_check_target_name})
+endfunction()
+
+
+function(ecm_installed_library_check_include_strings _target)
+ set(options)
+ set(oneValueArgs PREFIX)
+ set(multiValueArgs HEADERS)
+
+ cmake_parse_arguments(ARG "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
+
+ # argument checks
+ if(ARG_UNPARSED_ARGUMENTS)
+ message(FATAL_ERROR "Unknown keywords given to
ecm_installed_library_check_include_strings(): \"${ARG_UNPARSED_ARGUMENTS}\"")
+ endif()
+
+ # store data with library target
+ get_target_property(_names ${_target}
ECM_INSTALLED_LIBRARY_INCLUDE_STRINGS)
+ if(_names STREQUAL "_names-NOTFOUND")
+ set(_names)
+ endif()
+
+ if(ARG_PREFIX)
+ string(APPEND ARG_PREFIX "/")
+ endif()
+
+ # turn file names into include strings, with optional prefix
+ foreach(_header IN LISTS ARG_HEADERS)
+ cmake_path(GET _header FILENAME _name)
+ list(APPEND _names "${ARG_PREFIX}${_name}")
+ endforeach()
+
+ set_target_properties(${_target} PROPERTIES
ECM_INSTALLED_LIBRARY_INCLUDE_STRINGS "${_names}")
+endfunction()
+
+
+function(ecm_installed_library_check_cmake_variable _target)
+ set(options UNDEFINED)
+ set(oneValueArgs NAME TYPE VALUE)
+ set(multiValueArgs)
+
+ cmake_parse_arguments(ARG "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
+
+ # argument checks
+ if(ARG_UNPARSED_ARGUMENTS)
+ message(FATAL_ERROR "Unknown keywords given to
ecm_installed_library_check_cmake_variable(): \"${ARG_UNPARSED_ARGUMENTS}\"")
+ endif()
+ if(NOT DEFINED ARG_NAME)
+ message(FATAL_ERROR "Missing NAME argument to
ecm_installed_library_check_cmake_variable().")
+ endif()
+ if(DEFINED ARG_VALUE AND ARG_UNDEFINED)
+ message(FATAL_ERROR "ecm_installed_library_check_cmake_variable cannot
be called with both VALUE and UNDEFINED args.")
+ endif()
+ if(ARG_TYPE)
+ set(_variable_types "BOOL" "STRING")
+ if(NOT ${ARG_TYPE} IN_LIST _variable_types)
+ message(FATAL_ERROR "ecm_installed_library_check_cmake_variable
called with unknown type: ${ARG_TYPE}")
+ endif()
+ else()
+ set(ARG_TYPE "STRING")
+ endif()
+
+ # store data with library target
+ get_target_property(_data ${_target}
ECM_INSTALLED_LIBRARY_CMAKE_VARIABLES_CHECK_DATA)
+ if(_data STREQUAL "_data-NOTFOUND")
+ set(_data)
+ endif()
+
+ if(DEFINED ARG_VALUE)
+ set(_var_check_data "${ARG_NAME}=${ARG_VALUE}")
+ elseif(ARG_UNDEFINED)
+ set(_var_check_data "${ARG_NAME}!")
+ else() # defined
+ set(_var_check_data "${ARG_NAME}?")
+ endif()
+ if(${ARG_TYPE} STREQUAL "BOOL")
+ string(PREPEND _var_check_data "B:")
+ else() # STRING
+ string(PREPEND _var_check_data "S:")
+ endif()
+
+ list(APPEND _data "${_var_check_data}")
+ set_target_properties(${_target} PROPERTIES
ECM_INSTALLED_LIBRARY_CMAKE_VARIABLES_CHECK_DATA "${_data}")
+endfunction()
+
+
+function(_ecm_installed_library_check_preprocessor_macro_check_data _var_name
_name _check_type _value)
+ if(_check_type STREQUAL "VALUE")
+ set(_var_check_data "${_name}=${_value}")
+ elseif(_check_type STREQUAL "UNDEFINED")
+ set(_var_check_data "${_name}!")
+ else() # "DEFINED"
+ set(_var_check_data "${_name}?")
+ endif()
+ set(${_var_name} "${_var_check_data}" PARENT_SCOPE)
+endfunction()
+
+
+function(ecm_installed_library_check_compile_definition _target)
+ set(options UNDEFINED)
+ set(oneValueArgs NAME VALUE)
+ set(multiValueArgs)
+
+ cmake_parse_arguments(ARG "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
+
+ # argument checks
+ if(ARG_UNPARSED_ARGUMENTS)
+ message(FATAL_ERROR "Unknown keywords given to
ecm_installed_library_check_compile_definition():
\"${ARG_UNPARSED_ARGUMENTS}\"")
+ endif()
+ if(NOT DEFINED ARG_NAME)
+ message(FATAL_ERROR "Missing NAME argument to
ecm_installed_library_check_compile_definition().")
+ endif()
+ if(DEFINED ARG_VALUE AND ARG_UNDEFINED)
+ message(FATAL_ERROR "ecm_installed_library_check_compile_definition
cannot be called with both VALUE and UNDEFINED args.")
+ endif()
+
+ # store data with library target
+ get_target_property(_data ${_target}
ECM_INSTALLED_LIBRARY_COMPILE_DEFINITIONS_CHECK_DATA)
+ if(_data STREQUAL "_data-NOTFOUND")
+ set(_data)
+ endif()
+
+ if(DEFINED ARG_VALUE)
+ set(_check_type "VALUE")
+ elseif(ARG_UNDEFINED)
+ set(_check_type "UNDEFINED")
+ else()
+ set(_check_type "DEFINED")
+ endif()
+
+ _ecm_installed_library_check_preprocessor_macro_check_data(_var_check_data
${ARG_NAME} ${_check_type} "${ARG_VALUE}")
+
+ list(APPEND _data "${_var_check_data}")
+ set_target_properties(${_target} PROPERTIES
ECM_INSTALLED_LIBRARY_COMPILE_DEFINITIONS_CHECK_DATA "${_data}")
+endfunction()
+
+
+function(ecm_installed_library_check_preprocessor_macro _target)
+ set(options UNDEFINED)
+ set(oneValueArgs NAME VALUE)
+ set(multiValueArgs)
+
+ cmake_parse_arguments(ARG "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
+
+ # argument checks
+ if(ARG_UNPARSED_ARGUMENTS)
+ message(FATAL_ERROR "Unknown keywords given to
ecm_installed_library_check_preprocessor_macro():
\"${ARG_UNPARSED_ARGUMENTS}\"")
+ endif()
+ if(NOT DEFINED ARG_NAME)
+ message(FATAL_ERROR "Missing NAME argument to
ecm_installed_library_check_preprocessor_macro().")
+ endif()
+ if(ARG_VALUE AND ARG_UNDEFINED)
+ message(FATAL_ERROR "ecm_installed_library_check_preprocessor_macro
cannot be called with both VALUE and UNDEFINED args.")
+ endif()
+
+ # store data with library target
+ get_target_property(_data ${_target}
ECM_INSTALLED_LIBRARY_PREPROCESSOR_MACRO_CHECK_DATA)
+ if(_data STREQUAL "_data-NOTFOUND")
+ set(_data)
+ endif()
+
+ if(DEFINED ARG_VALUE)
+ set(_check_type "VALUE")
+ elseif(ARG_UNDEFINED)
+ set(_check_type "UNDEFINED")
+ else()
+ set(_check_type "DEFINED")
+ endif()
+
+ _ecm_installed_library_check_preprocessor_macro_check_data(_var_check_data
${ARG_NAME} ${_check_type} "${ARG_VALUE}")
+
+ list(APPEND _data "${_var_check_data}")
+ set_target_properties(${_target} PROPERTIES
ECM_INSTALLED_LIBRARY_PREPROCESSOR_MACRO_CHECK_DATA "${_data}")
+endfunction()
+
+
+function(ecm_installed_library_check_version_preprocessor_macros _target)
+ set(options)
+ set(oneValueArgs PREFIX VERSION)
+ set(multiValueArgs)
+
+ cmake_parse_arguments(ARG "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
+
+ # argument checks
+ if(ARG_UNPARSED_ARGUMENTS)
+ message(FATAL_ERROR "Unknown keywords given to
ecm_installed_library_check_version_preprocessor_macros():
\"${ARG_UNPARSED_ARGUMENTS}\"")
+ endif()
+
+ if(DEFINED ARG_PREFIX)
+ set(_prefix "${ARG_PREFIX}")
+ else()
+ string(TOUPPER "${_target}" _prefix)
+ endif()
+
+ # storing separately, as *_DATA will need to be
generator-expression-compared to "DEFAULT"
+ set_target_properties(${_target} PROPERTIES
ECM_INSTALLED_LIBRARY_VERSION_PREPROCESSOR_MACRO_CHECK_PREFIX "${_prefix}")
+
+ if(DEFINED ARG_VERSION)
+ set(_version "${ARG_VERSION}")
+ else()
+ set(_version "DEFAULT")
+ endif()
+ set_target_properties(${_target} PROPERTIES
ECM_INSTALLED_LIBRARY_VERSION_PREPROCESSOR_MACRO_CHECK_DATA "${_version}")
+endfunction()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/modules/ECMSetupVersion.cmake
new/extra-cmake-modules-6.30.0/modules/ECMSetupVersion.cmake
--- old/extra-cmake-modules-6.29.0/modules/ECMSetupVersion.cmake
2026-08-07 22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/modules/ECMSetupVersion.cmake
2026-09-04 13:36:44.000000000 +0200
@@ -36,6 +36,10 @@
<prefix>_VERSION_STRING - <version> (use <prefix>_VERSION instead)
+Since ECM 6.30 additionally the forms ``<major>.<minor>`` and ``<major>``
+are supported, the variables for the respective missing components are set to
+empty strings.
+
With CMake versions older than 4.0.0 and if CMake policy CMP0048 is not
``NEW``,
the following CMake variables will also be set::
@@ -150,9 +154,22 @@
string(REGEX REPLACE "0*([0-9]+)" "\\1" _minor
"${PROJECT_VERSION_MINOR}")
string(REGEX REPLACE "0*([0-9]+)" "\\1" _patch
"${PROJECT_VERSION_PATCH}")
else()
- string(REGEX REPLACE "^0*([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" _major
"${_version}")
- string(REGEX REPLACE "^[0-9]+\\.0*([0-9]+)\\.[0-9]+.*" "\\1" _minor
"${_version}")
- string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.0*([0-9]+).*" "\\1" _patch
"${_version}")
+ # not applying final "$", to be able to ignore .<tweak>, possibly also
other appendices in usage
+ string(REGEX MATCH "^0*([0-9]+)(\\.0*([0-9]+)(\\.0*([0-9]+))?)?"
_match "${_version}")
+ if(_match STREQUAL "")
+ message(FATAL_ERROR "ecm_setup_version given version argument not
matching <major>[.<minor>[.<patch>][.<tweak>]]: ${_version}")
+ endif()
+ set(_major ${CMAKE_MATCH_1})
+ if (CMAKE_MATCH_COUNT GREATER_EQUAL 3)
+ set(_minor ${CMAKE_MATCH_3})
+ else()
+ set(_minor "")
+ endif()
+ if (CMAKE_MATCH_COUNT GREATER_EQUAL 5)
+ set(_patch ${CMAKE_MATCH_5})
+ else()
+ set(_patch "")
+ endif()
endif()
if(NOT DEFINED ESV_SOVERSION) # use DEFINED, so "0" as valid SO version is
not evaluated to FALSE
@@ -192,6 +209,22 @@
set(HEADER_VERSION_MAJOR "${_major}")
set(HEADER_VERSION_MINOR "${_minor}")
set(HEADER_VERSION_PATCH "${_patch}")
+ # handle patch or even minor level not being set
+ if (_minor STREQUAL "")
+ set(_minor_number 0)
+ else()
+ set(_minor_number "${_minor}")
+ endif()
+ if (_patch STREQUAL "")
+ set(_patch_number 0)
+ else()
+ set(_patch_number "${_patch}")
+ endif()
+ math(
+ EXPR HEADER_VERSION_HEXNUMBER "${_major}*65536 +
${_minor_number}*256 + ${_patch_number}"
+ OUTPUT_FORMAT HEXADECIMAL
+ )
+
configure_file("${_ECM_SETUP_VERSION_HEADER_TEMPLATE}"
"${ESV_VERSION_HEADER}")
endif()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/modules/ECMVersionHeader.h.in
new/extra-cmake-modules-6.30.0/modules/ECMVersionHeader.h.in
--- old/extra-cmake-modules-6.29.0/modules/ECMVersionHeader.h.in
2026-08-07 22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/modules/ECMVersionHeader.h.in
2026-09-04 13:36:44.000000000 +0200
@@ -7,6 +7,7 @@
#define @HEADER_PREFIX@_VERSION_MAJOR @HEADER_VERSION_MAJOR@
#define @HEADER_PREFIX@_VERSION_MINOR @HEADER_VERSION_MINOR@
#define @HEADER_PREFIX@_VERSION_PATCH @HEADER_VERSION_PATCH@
-#define @HEADER_PREFIX@_VERSION
((@HEADER_VERSION_MAJOR@<<16)|(@HEADER_VERSION_MINOR@<<8)|(@HEADER_VERSION_PATCH@))
+// Packed format 0xMMmmpp, 0xMM == major, 0xmm == minor, 0xpp == patch
+#define @HEADER_PREFIX@_VERSION @HEADER_VERSION_HEXNUMBER@
#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/modules/ecm_create_installed_library_check.cmake
new/extra-cmake-modules-6.30.0/modules/ecm_create_installed_library_check.cmake
---
old/extra-cmake-modules-6.29.0/modules/ecm_create_installed_library_check.cmake
1970-01-01 01:00:00.000000000 +0100
+++
new/extra-cmake-modules-6.30.0/modules/ecm_create_installed_library_check.cmake
2026-09-04 13:36:44.000000000 +0200
@@ -0,0 +1,409 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_policy(VERSION 3.29)
+
+#TODO: enable VERBOSE mode via some env var
+set(_verbose_mode FALSE)
+
+# Expected arguments
+set(_expected_arg_names
+ LANGUAGES # languages to set in the project() call
+ OUTPUT_DIR # dir where to create the CMakeLists.txt file
+ PACKAGE_NAME # package name
+ PACKAGE_VERSION # package version
+ PACKAGE_INSTALL_PREFIX # package installation prefix
+ LIBRARY_TARGET_NAME # library target name
+ EXTRA_DEPENDENCIES # extra package dependencies
+ EXTRA_LINK_LIBRARIES # extra library targets to link to
+ EXTRA_COMPILE_DEFINITIONS # compile definitions to use
+ INCLUDE_STRINGS # include strings
+ CMAKE_VARIABLES_CHECK_DATA # data about cmake variables to check, list of
format B/S:name=value
+ COMPILE_DEFINITIONS_CHECK_DATA # data about compile definitions to check,
list of format
+ PREPROCESSOR_MACRO_CHECK_DATA # data about preprocessor macros to check,
list of format
+)
+set(_missing_arg FALSE)
+foreach (_arg_name IN LISTS _expected_arg_names)
+ if(NOT DEFINED ${_arg_name})
+ set(_missing_arg TRUE)
+ message(SEND_ERROR "Missing argument: ${_arg_name}.")
+ endif()
+endforeach()
+if(_missing_arg)
+ message(FATAL_ERROR "Aborting over missing arguments.")
+endif()
+
+
+# helper functions
+function(_set_extra_deps_code _var_name _extra_deps)
+ set(_statements)
+ list(LENGTH _extra_deps _deps_count)
+ set(_i 0)
+ while(${_i} LESS ${_deps_count})
+ list(GET _extra_deps ${_i} _extra_package_name)
+ math(EXPR _i "${_i} + 1")
+ set(_extra_package_version_string)
+ # check next arg if it is version and thus to be consumed
+ if(${_i} LESS ${_deps_count})
+ list(GET _extra_deps ${_i} _extra_package_version)
+ if(_extra_package_version MATCHES
"^([0-9]+)\\.([0-9]+)(\\.([0-9]+))?$")
+ set(_extra_package_version_string " ${_extra_package_version}")
+ math(EXPR _i "${_i} + 1")
+ endif()
+ endif()
+ string(APPEND _statements
"find_package(${_extra_package_name}${_extra_package_version_string}
REQUIRED)\n")
+ endwhile()
+ set(${_var_name} ${_statements} PARENT_SCOPE)
+endfunction()
+
+
+function(_append_macro_check_data_by_version_checks _var_name _check_data)
+ string(REGEX MATCH "^(.+):(.+)$" _match "${_check_data}")
+ if(_match STREQUAL "")
+ message(FATAL_ERROR "Broken version preprocessor macro argument:
${_check_data}.")
+ endif()
+ set(_prefix "${CMAKE_MATCH_1}")
+ set(_version_data "${CMAKE_MATCH_2}")
+ if(_version_data MATCHES "^DEFAULT\\|(.*)\\|(.*)$")
+ if (NOT CMAKE_MATCH_1 STREQUAL "")
+ set(_version "${CMAKE_MATCH_1}")
+ elseif (NOT CMAKE_MATCH_2 STREQUAL "")
+ set(_version "${CMAKE_MATCH_2}")
+ else()
+ message(FATAL_ERROR
"ecm_installed_library_check_version_preprocessor_macros() called without
VERSION argument, but neither project or library target provide a default.")
+ endif()
+ else()
+ set(_version "${_version_data}")
+ endif()
+
+ string(REGEX MATCH "^0*([0-9]+)\\.0*([0-9]+)\\.0*([0-9]+)$" _match
"${_version}")
+ if ("${_match}" STREQUAL "")
+ message(FATAL_ERROR "Version to use by
ecm_installed_library_check_version_preprocessor_macros() not in
<major>.<minor>.<patch> format, is: ${_version}")
+ endif()
+ set(_version_major "${CMAKE_MATCH_1}")
+ set(_version_minor "${CMAKE_MATCH_2}")
+ set(_version_patch "${CMAKE_MATCH_3}")
+
+ math(
+ EXPR _hex_number "${_version_major}*65536 + ${_version_minor}*256 +
${_version_patch}"
+ OUTPUT_FORMAT HEXADECIMAL
+ )
+
+ list(APPEND ${_var_name}
+ "${_prefix}_VERSION=${_hex_number}"
+ "${_prefix}_VERSION_MAJOR=${_version_major}"
+ "${_prefix}_VERSION_MINOR=${_version_minor}"
+ "${_prefix}_VERSION_PATCH=${_version_patch}"
+ )
+ set(${_var_name} ${${_var_name}} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_macro_check_init_code _var_name _subject_name)
+ set(_check_code)
+ if (_verbose_mode)
+ string(APPEND _check_code "#pragma message(\\\"Checking
${_subject_name}\\\")\n")
+ endif()
+ string(APPEND _check_code
+"#define _ECM_INSTALLED_LIBRARY_CHECK_VALUE_TO_STRING(x) #x
+#define _ECM_INSTALLED_LIBRARY_CHECK_VALUE(x)
_ECM_INSTALLED_LIBRARY_CHECK_VALUE_TO_STRING(x)
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_macro_value_check_code _var_name _name _value)
+ set(_check_code
+"#if !defined(${_name})
+ #error(\\\"${_name}: not defined\\\")
+#else
+ #if ${_name} != ${_value}
+ #pragma message(\\\"${_name}: is '\\\"
_ECM_INSTALLED_LIBRARY_CHECK_VALUE(${_name}) \\\"'\\\")
+ #error(\\\"${_name}: expecting '${_value}'\\\")
+")
+ if (_verbose_mode)
+ string(APPEND _check_code
+" #else
+ #pragma message(\\\"${_name}: as expected matches '${_value}'\\\")
+")
+ endif()
+ string(APPEND _check_code
+" #endif
+#endif
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_macro_defined_check_code _var_name _name)
+ set(_check_code
+"#if !defined(${_name})
+ #error(\\\"${_name}: is undefined, expecting defined\\\")
+")
+ if (_verbose_mode)
+ string(APPEND _check_code
+"#else
+ #pragma message(\\\"${_name}: as expected defined\\\")
+")
+ endif()
+ string(APPEND _check_code
+"#endif
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_macro_undefined_check_code _var_name _name)
+ set(_check_code
+"#if defined(${_name})
+ #error(\\\"${_name}: is defined, expecting undefined\\\")
+")
+ if (_verbose_mode)
+ string(APPEND _check_code
+"#else
+ #pragma message(\\\"${_name}: as expected undefined\\\")
+")
+ endif()
+ string(APPEND _check_code
+"#endif
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_preprocessor_macro_check_statements _var_name _arg_type_name
_check_data)
+ set(_check_statements)
+ foreach(_definition_data IN LISTS _check_data)
+ string(REGEX MATCH "^([A-Za-z0-9_]+)([\!\?\=])(.*)$" _match
"${_definition_data}")
+ if(_match STREQUAL "")
+ message(FATAL_ERROR "Broken ${_arg_type_name} argument:
${_definition_data}.")
+ endif()
+
+ set(_macro_var_name "${CMAKE_MATCH_1}")
+ if (CMAKE_MATCH_2 STREQUAL "=")
+ _set_macro_value_check_code(_check_code ${_macro_var_name}
${CMAKE_MATCH_3})
+ elseif (CMAKE_MATCH_2 STREQUAL "!")
+ _set_macro_undefined_check_code(_check_code ${_macro_var_name})
+ else()
+ _set_macro_defined_check_code(_check_code ${_macro_var_name})
+ endif()
+ string(APPEND _check_statements "${_check_code}")
+ endforeach()
+
+ set(${_var_name} ${_check_statements} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_compile_definitions_check_code _var_name _check_data)
+ _set_preprocessor_macro_check_statements(_check_statements "compile
definition" "${_check_data}")
+
+ _set_macro_check_init_code(_init_check_code "compile definitions" FALSE)
+
+ set(_source_file "ecm_installed_library_check_compile_definitions.cpp")
+ set(_definitions_check_code "
+file(GENERATE OUTPUT ${_source_file} CONTENT
+\"${_init_check_code}${_check_statements}\")\n
+target_sources(InstalledLibraryCheck PRIVATE ${_source_file})\n")
+
+ set(${_var_name} ${_definitions_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_preprocessor_macro_check_code _var_name _check_data)
+ _set_preprocessor_macro_check_statements(_check_statements "preprocessor
macro" "${_check_data}")
+
+ _set_macro_check_init_code(_init_check_code "preprocessor macros")
+
+ set(_macros_check_code "\n\"\n${_init_check_code}${_check_statements}\"")
+
+ set(${_var_name} ${_macros_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_cmake_variable_defined_check_code _var_name _name)
+ set(_check_code
+"if(NOT DEFINED ${_name})
+ message(SEND_ERROR \"${_name}: is undefined, expecting defined\")
+")
+ if (_verbose_mode)
+ string(APPEND _check_code
+"else()
+ message(STATUS \"${_name}: as expected defined\")
+")
+ endif()
+ string(APPEND _check_code
+"endif()
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_cmake_variable_undefined_check_code _var_name _name)
+ set(_check_code
+"if(DEFINED ${_name})
+ message(SEND_ERROR \"${_name}: is defined, expecting undefined\")
+")
+ if (_verbose_mode)
+ string(APPEND _check_code
+"else()
+ message(STATUS \"${_name}: as expected undefined\")
+")
+ endif()
+ string(APPEND _check_code
+"endif()
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_cmake_variable_check_code _var_name _name _type _value)
+ if (_type STREQUAL "BOOL")
+ # test boolean type by code evaluating the variable
+ if (${_value})
+ set(_value_error_condition_code "NOT \${${_name}}")
+ set(_value_error_report "is FALSE, expecting TRUE")
+ else()
+ set(_value_error_condition_code "\${${_name}}")
+ set(_value_error_report "is TRUE, expecting FALSE")
+ endif()
+ else() # STRING
+ set(_value_error_condition_code "NOT \${${_name}} STREQUAL
\"${_value}\"")
+ set(_value_error_report "is '\${${_name}}', expecting '${_value}'")
+ endif()
+
+ set(_check_code
+"if(NOT DEFINED ${_name})
+ message(SEND_ERROR \"${_name}: not defined\")
+else()
+ if (${_value_error_condition_code})
+ message(SEND_ERROR \"${_name}: ${_value_error_report}\")
+")
+ if (_verbose_mode)
+ string(APPEND _check_code
+" else()
+ message(STATUS \"${_name}: as expected matches '${_value}'\")
+")
+ endif()
+ string(APPEND _check_code
+" endif()
+endif()
+")
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+function(_set_cmake_variables_check_code _var_name _check_data)
+ set(_check_code)
+ if (_verbose_mode)
+ string(APPEND _check_code "message(STATUS \"Checking CMake
variables\")\n")
+ endif()
+
+ foreach(_cmake_variable_data IN LISTS _check_data)
+ string(REGEX MATCH "^([SB]):([A-Za-z0-9_]+)([\!\?\=])(.*)$" _match
"${_cmake_variable_data}")
+ if(_match STREQUAL "")
+ message(SEND_ERROR "Broken cmake variable argument:
${_cmake_variable_data}.")
+ endif()
+ set(_cmake_var_name "${CMAKE_MATCH_2}")
+ if (CMAKE_MATCH_1 STREQUAL "B")
+ set(_type "BOOL")
+ else()
+ set(_type "STRING")
+ endif()
+
+ if (CMAKE_MATCH_3 STREQUAL "=")
+ _set_cmake_variable_check_code(_var_check_code ${_cmake_var_name}
${_type} "${CMAKE_MATCH_4}" )
+ elseif (CMAKE_MATCH_3 STREQUAL "!")
+ _set_cmake_variable_undefined_check_code(_var_check_code
${_cmake_var_name})
+ else()
+ _set_cmake_variable_defined_check_code(_var_check_code
${_cmake_var_name})
+ endif()
+
+ string(APPEND _check_code "${_var_check_code}")
+ endforeach()
+ set(${_var_name} ${_check_code} PARENT_SCOPE)
+endfunction()
+
+
+# process arguments
+set(_languages)
+if (LANGUAGES)
+ string(REPLACE ";" " " _languages "${LANGUAGES}")
+ string(PREPEND _languages " LANGUAGES ")
+endif()
+if(PACKAGE_VERSION)
+ set(_package_version_exact " EXACT ")
+else()
+ set(_package_version_exact " ")
+endif()
+set(_extra_find_packages_statements)
+if(EXTRA_DEPENDENCIES)
+ _set_extra_deps_code(_extra_find_packages_statements
"${EXTRA_DEPENDENCIES}")
+endif()
+set(_extra_link_libraries_list)
+foreach(_link_library IN LISTS EXTRA_LINK_LIBRARIES)
+ string(APPEND _extra_link_libraries_list "\n ${_link_library}")
+endforeach()
+set(_compile_definitions_statement)
+if(EXTRA_COMPILE_DEFINITIONS)
+ set(_compile_definitions_statement
"target_compile_definitions(InstalledLibraryCheck PRIVATE
${EXTRA_COMPILE_DEFINITIONS})\n")
+endif()
+string(JOIN "\n " _include_strings_lines ${INCLUDE_STRINGS})
+
+set(_cmake_variables_check_code)
+if (CMAKE_VARIABLES_CHECK_DATA)
+ _set_cmake_variables_check_code(_cmake_variables_check_code
"${CMAKE_VARIABLES_CHECK_DATA}")
+ string(PREPEND _cmake_variables_check_code "\n")
+endif()
+
+set(_compile_definitions_check_code)
+if(COMPILE_DEFINITIONS_CHECK_DATA)
+ _set_compile_definitions_check_code(_compile_definitions_check_code
"${COMPILE_DEFINITIONS_CHECK_DATA}")
+endif()
+
+if(VERSION_PREPROCESSOR_MACRO_CHECK_DATA)
+ _append_macro_check_data_by_version_checks(PREPROCESSOR_MACRO_CHECK_DATA
"${VERSION_PREPROCESSOR_MACRO_CHECK_DATA}")
+endif()
+
+set(_preprocessor_macro_check_code)
+if(PREPROCESSOR_MACRO_CHECK_DATA)
+ _set_preprocessor_macro_check_code(_preprocessor_macro_check_code
"${PREPROCESSOR_MACRO_CHECK_DATA}")
+endif()
+
+
+# create CMakeLists.txt file
+file(CONFIGURE
+ OUTPUT "${OUTPUT_DIR}/CMakeLists.txt"
+ CONTENT
+"# This file was generated by ecm_add_installed_library_check(). DO NOT EDIT!
+cmake_minimum_required(VERSION 3.29)
+
+project(InstalledLibraryCheck@_languages@)
+
+find_package(@PACKAGE_NAME@ @PACKAGE_VERSION@@_package_version_exact@CONFIG
REQUIRED NO_DEFAULT_PATH
+ PATHS \"@PACKAGE_INSTALL_PREFIX@\"
+)
+@_extra_find_packages_statements@
+include(FeatureSummary)
+feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
+@_cmake_variables_check_code@
+add_library(InstalledLibraryCheck MODULE)
+target_link_libraries(InstalledLibraryCheck
+ @LIBRARY_TARGET_NAME@@_extra_link_libraries_list@
+)
+@_compile_definitions_statement@
+set(_include_strings
+ @_include_strings_lines@
+)
+@_compile_definitions_check_code@
+set(_preprocessor_macro_check_statements@_preprocessor_macro_check_code@)
+
+foreach(_include_string IN LISTS _include_strings)
+ string(REPLACE \"/\" \"__\" _escaped_include_string \${_include_string})
+ set(_source_file
\"\${CMAKE_CURRENT_BINARY_DIR}/\${_escaped_include_string}.cpp\")
+ file(GENERATE OUTPUT \${_source_file} CONTENT \"#include
<\${_include_string}>\\n\${_preprocessor_macro_check_statements}\")
+ target_sources(InstalledLibraryCheck PRIVATE \${_source_file})
+endforeach()
+"
+ @ONLY
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/test-modules/CMakeLists.txt
new/extra-cmake-modules-6.30.0/test-modules/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/test-modules/CMakeLists.txt 1970-01-01
01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/test-modules/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+install(FILES
+ test_execute_and_compare.cmake
+
+ DESTINATION ${TEST_MODULES_INSTALL_DIR}
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/tests/ECMSetupVersionTest/CMakeLists.txt
new/extra-cmake-modules-6.30.0/tests/ECMSetupVersionTest/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/tests/ECMSetupVersionTest/CMakeLists.txt
2026-08-07 22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/tests/ECMSetupVersionTest/CMakeLists.txt
2026-09-04 13:36:44.000000000 +0200
@@ -35,6 +35,7 @@
add_version_test(new_explicit_soversion dummy)
add_version_test(new_explicit_version_file dummy)
add_version_test(new_explicit_version_file_abspath dummy)
+add_version_test(new_explicit_version_file_no_patchlevel dummy)
add_version_test(new_project_header check_header)
add_version_test(new_project_header_abspath check_header)
add_version_test(new_project_header_prefix check_header)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/CMakeLists.txt
new/extra-cmake-modules-6.30.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/CMakeLists.txt
---
old/extra-cmake-modules-6.29.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/CMakeLists.txt
1970-01-01 01:00:00.000000000 +0100
+++
new/extra-cmake-modules-6.30.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/CMakeLists.txt
2026-09-04 13:36:44.000000000 +0200
@@ -0,0 +1,69 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(new_explicit_version_file_no_patchlevel VERSION 1.5.6.7)
+
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../modules)
+include(ECMSetupVersion)
+
+ecm_setup_version(2.3
+ VARIABLE_PREFIX Foo
+ PACKAGE_VERSION_FILE FooVersion.cmake
+)
+
+include(../version_helpers.cmake)
+project_version_var_checks(1.5.6.7)
+version_var_checks(Foo 2.3)
+assert_var_num_value(Foo_SOVERSION 2)
+
+macro(AnyNewer_2_3_checks filename)
+ # too old - fails
+ test_version_file("${filename}" "3.1")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE FALSE ALLOW_UNDEFINED)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # too old - fails
+ test_version_file("${filename}" "3")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE FALSE ALLOW_UNDEFINED)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # too old - fails
+ test_version_file("${filename}" "2.3.4")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE FALSE ALLOW_UNDEFINED)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # newer - succeeds
+ test_version_file("${filename}" "1.1")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE TRUE)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # newer - succeeds
+ test_version_file("${filename}" "2.1")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE TRUE)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # newer - succeeds
+ test_version_file("${filename}" "2")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE TRUE)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # unspecified - succeeds
+ test_version_file("${filename}" "")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE TRUE)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT FALSE ALLOW_UNDEFINED)
+
+ # exact - succeeds
+ test_version_file("${filename}" "2.3")
+ assert_var_str_value(PACKAGE_VERSION "2.3")
+ assert_var_bool_value(PACKAGE_VERSION_COMPATIBLE TRUE)
+ assert_var_bool_value(PACKAGE_VERSION_EXACT TRUE)
+endmacro()
+AnyNewer_2_3_checks("${CMAKE_CURRENT_BINARY_DIR}/FooVersion.cmake")
+
+add_executable(dummy main.c)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/main.c
new/extra-cmake-modules-6.30.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/main.c
---
old/extra-cmake-modules-6.29.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/main.c
1970-01-01 01:00:00.000000000 +0100
+++
new/extra-cmake-modules-6.30.0/tests/ECMSetupVersionTest/new_explicit_version_file_no_patchlevel/main.c
2026-09-04 13:36:44.000000000 +0200
@@ -0,0 +1,4 @@
+int main()
+{
+ return 0;
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/tests/ExecuteCoreModules/CMakeLists.txt
new/extra-cmake-modules-6.30.0/tests/ExecuteCoreModules/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/tests/ExecuteCoreModules/CMakeLists.txt
2026-08-07 22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/tests/ExecuteCoreModules/CMakeLists.txt
2026-09-04 13:36:44.000000000 +0200
@@ -3,6 +3,8 @@
set(ECM_GLOBAL_FIND_VERSION "5.90.0")
file(GLOB all_core_modules "${CMAKE_CURRENT_SOURCE_DIR}/../../modules/*cmake")
+# drop helper scripts from the list
+list(FILTER all_core_modules EXCLUDE REGEX "modules/ecm_.*cmake")
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../modules)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../find-modules)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/tests/ExecuteKDEModules/CMakeLists.txt
new/extra-cmake-modules-6.30.0/tests/ExecuteKDEModules/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/tests/ExecuteKDEModules/CMakeLists.txt
2026-08-07 22:38:40.000000000 +0200
+++ new/extra-cmake-modules-6.30.0/tests/ExecuteKDEModules/CMakeLists.txt
2026-09-04 13:36:44.000000000 +0200
@@ -7,12 +7,16 @@
KDECMakeSettings
KDECompilerSettings
KDEFrameworkCompilerSettings
- ECMMarkNonGuiExecutable
+
+ KDEClangFormat
+ KDEGitCommitHooks
+ KDEMetaInfoPlatformCheck
+ KDEPackageAppTemplates
)
set(ECM_KDE_MODULE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../kde-modules)
set(ECM_MODULE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../modules)
-set(CMAKE_MODULE_PATH "${ECM_KDE_MODULE_DIR}" "${ECM_MODULE_DIR}")
+set(CMAKE_MODULE_PATH "${ECM_KDE_MODULE_DIR}")
foreach(module ${all_kde_modules})
message(STATUS "module: ${module}")
@@ -20,6 +24,10 @@
endforeach()
add_executable(dummy main.c)
+
+# tune test for Apple, no bundle expected there
+list(APPEND CMAKE_MODULE_PATH "${ECM_MODULE_DIR}")
+include(ECMMarkNonGuiExecutable)
ecm_mark_nongui_executable(dummy)
set_target_properties(dummy PROPERTIES RUNTIME_OUTPUT_DIRECTORY
${CMAKE_CURRENT_BINARY_DIR})
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/extra-cmake-modules-6.29.0/tests/ExecuteKDEModules/metainfo.yaml
new/extra-cmake-modules-6.30.0/tests/ExecuteKDEModules/metainfo.yaml
--- old/extra-cmake-modules-6.29.0/tests/ExecuteKDEModules/metainfo.yaml
1970-01-01 01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/tests/ExecuteKDEModules/metainfo.yaml
2026-09-04 13:36:44.000000000 +0200
@@ -0,0 +1,9 @@
+# Needed for KDEMetaInfoPlatformCheck
+description: ExecuteKDEModules test
+platforms:
+ - name: Linux
+ - name: FreeBSD
+ - name: Windows
+ - name: macOS
+ - name: Android
+release: false
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/extra-cmake-modules-6.29.0/toolchain/CMakeLists.txt
new/extra-cmake-modules-6.30.0/toolchain/CMakeLists.txt
--- old/extra-cmake-modules-6.29.0/toolchain/CMakeLists.txt 1970-01-01
01:00:00.000000000 +0100
+++ new/extra-cmake-modules-6.30.0/toolchain/CMakeLists.txt 2026-09-04
13:36:44.000000000 +0200
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: 2026 Friedrich W. H. Kossebau <[email protected]>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+install(FILES
+ Android.cmake
+ deployment-file.json.in
+ deployment-file-qt514.json.in
+ deployment-file-qt6.json.in
+ deployment-file-qt6.json.in.license
+ ECMAndroidDeployQt5.cmake
+ ecm-version.gradle.in
+ generate-fastlane-metadata.py
+ hasMainSymbol.cmake
+ specifydependencies.cmake
+
+ DESTINATION ${TOOLCHAIN_MODULES_INSTALL_DIR}
+)
