Derive project version from git tag

The project version was hardcoded in project(VERSION ...) and in
LSL_LIBRARY_VERSION, so release assets carried a stale version unless
both were bumped by hand.

- cmake/ProjectVersion.cmake: derive MAJOR.MINOR.PATCH (plus the full
  tag incl. pre-release suffix) from the nearest v[0-9]* git tag, with
  the literal as a fallback for git/tag-less builds and a
  LSL_VERSION_OVERRIDE escape hatch.
- CMakeLists.txt: feed PROJECT_VERSION from the tag; use the full tag
  for CPACK_PACKAGE_VERSION so pre-release suffixes survive.
- src/lsl_version.h.in + TargetObjLib.cmake: generate the version
  header so lsl_library_version() tracks the release.
- CI: fetch-depth: 0 on the build-job checkouts so the tag is visible
  to git describe (default shallow clone fetches no tags).

Author: cboulay

.github/workflows/apple.yml

@@ -43,6 +43,9 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+      with:
+        # Need full history + tags so the version can be derived from the git tag
+        fetch-depth: 0
 
     - name: Install certificates and provisioning profiles
       uses: ./.github/actions/install-apple-certs

.github/workflows/cppcmake.yml

@@ -63,6 +63,9 @@ jobs:
 
     steps:
     - uses: actions/checkout@v5
+      with:
+        # Need full history + tags so the version can be derived from the git tag
+        fetch-depth: 0
 
     # Set up cross-compilation toolchain for ARM on Linux
     - name: Install cross-compilation toolchain

CMakeLists.txt

@@ -1,6 +1,12 @@
 cmake_minimum_required (VERSION 3.23)
+
+# Derive the version from the most recent git tag (e.g. v1.18.0 -> 1.18.0).
+# The literal below is the single source of truth for builds without git/tags.
+include(cmake/ProjectVersion.cmake)
+lsl_version_from_git(LSL_VERSION LSL_VERSION_FULL FALLBACK "1.17.7")
+
 project (liblsl
-	VERSION 1.17.7
+	VERSION ${LSL_VERSION}
 	LANGUAGES C CXX
 	DESCRIPTION "Labstreaminglayer C/C++ library"
 	HOMEPAGE_URL "https://github.com/sccn/liblsl"
@@ -32,7 +38,9 @@ LSL_get_target_arch()
 LSL_get_os_name()
 
 set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
-set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
+# Use the full tag (incl. any pre-release suffix like b1) for package metadata,
+# while PROJECT_VERSION stays strictly numeric as CMake requires.
+set(CPACK_PACKAGE_VERSION "${LSL_VERSION_FULL}")
 set(CPACK_PACKAGE_VENDOR "Labstreaminglayer")
 set(CPACK_STRIP_FILES ON)
 

cmake/ProjectVersion.cmake

@@ -0,0 +1,61 @@
+# ProjectVersion.cmake
+# Derive the project version from the most recent git tag.
+#
+# liblsl tags look like `v1.18.0` or, for pre-releases, `v1.18.0b1`. This module
+# turns the nearest such tag into:
+#   - a strict MAJOR.MINOR.PATCH string suitable for project(... VERSION ...)
+#   - the full tag (sans leading `v`), preserving any pre-release suffix, for
+#     packaging metadata.
+#
+# It must be included and called BEFORE project(), since project() needs the
+# numeric version. When git or a matching tag is unavailable (release tarballs,
+# shallow clones without tags, FetchContent on an exported tree) it falls back
+# to the supplied literal so the source tree always builds.
+#
+# Usage:
+#   include(cmake/ProjectVersion.cmake)
+#   lsl_version_from_git(LSL_VERSION LSL_VERSION_FULL FALLBACK "1.17.7")
+#   project(liblsl VERSION ${LSL_VERSION} ...)
+#
+# A version can be forced (e.g. from CI) by passing -DLSL_VERSION_OVERRIDE=1.18.0b1.
+
+function(lsl_version_from_git out_numeric out_full)
+    cmake_parse_arguments(ARG "" "FALLBACK" "" ${ARGN})
+
+    set(_ver "")
+    if(LSL_VERSION_OVERRIDE)
+        string(REGEX REPLACE "^v" "" _ver "${LSL_VERSION_OVERRIDE}")
+        message(STATUS "lsl: using LSL_VERSION_OVERRIDE=${_ver}")
+    else()
+        find_package(Git QUIET)
+        if(Git_FOUND)
+            execute_process(
+                COMMAND ${GIT_EXECUTABLE} describe --tags --abbrev=0 --match "v[0-9]*"
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                OUTPUT_VARIABLE _tag
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                ERROR_QUIET
+                RESULT_VARIABLE _res
+            )
+            if(_res EQUAL 0 AND _tag)
+                string(REGEX REPLACE "^v" "" _ver "${_tag}")
+            endif()
+        endif()
+    endif()
+
+    if(NOT _ver)
+        set(_ver "${ARG_FALLBACK}")
+        message(STATUS "lsl: no git tag found; using fallback version ${_ver}")
+    endif()
+
+    # Strict numeric MAJOR.MINOR.PATCH for project(VERSION); ignore any suffix.
+    if(_ver MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)")
+        set(${out_numeric} "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" PARENT_SCOPE)
+        set(${out_full} "${_ver}" PARENT_SCOPE)
+        message(STATUS "lsl version: ${_ver}")
+    else()
+        message(WARNING "lsl: version '${_ver}' is not MAJOR.MINOR.PATCH; using ${ARG_FALLBACK}")
+        set(${out_numeric} "${ARG_FALLBACK}" PARENT_SCOPE)
+        set(${out_full} "${ARG_FALLBACK}" PARENT_SCOPE)
+    endif()
+endfunction()

cmake/TargetObjLib.cmake

@@ -1,10 +1,23 @@
+# Generate the version header from the (tag-derived) project version so that
+# lsl_library_version() tracks the release instead of a hand-maintained constant.
+configure_file(
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lsl_version.h.in"
+        "${CMAKE_CURRENT_BINARY_DIR}/lsl_version.h"
+        @ONLY
+)
+
 # Create object library so all files are only compiled once
 add_library(lslobj OBJECT
         ${lslsources}
         ${lslheaders}
 )
 set_target_properties(lslobj PROPERTIES FOLDER "liblsl")
 
+# Make the generated lsl_version.h visible to the sources (and to internal tests
+# that compile individual source files and link lslobj). Build-tree only; this is
+# an internal header and is not installed.
+target_include_directories(lslobj PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+
 # Set the includes/headers for the lslobj target
 # Note: We cannot use PUBLIC_HEADER because it flattens the include tree upon install
 # Note: We cannot use FILE_SET because it is not compatible with HEADERS.

src/common.h

@@ -1,6 +1,8 @@
 #ifndef COMMON_H
 #define COMMON_H
 
+#include "lsl_version.h"
+
 extern "C" {
 #include "api_types.hpp"
 // api_types.h defines LSL_TYPES so it needs to be included before the next header
@@ -45,8 +47,9 @@ extern "C" {
 // * 110 is an alternative protocol that improves throughput, supported by library versions 1.10+
 const int LSL_PROTOCOL_VERSION = 110;
 
-// the library version
-const int LSL_LIBRARY_VERSION = 117;
+// the library version, derived from the project version at configure time
+// (LSL_LIBRARY_VERSION_* come from the generated lsl_version.h)
+const int LSL_LIBRARY_VERSION = (LSL_LIBRARY_VERSION_MAJOR * 100) + LSL_LIBRARY_VERSION_MINOR;
 
 /// size of the lsl_last_error() buffer size
 const int LAST_ERROR_SIZE = 512;

src/lsl_version.h.in

@@ -0,0 +1,10 @@
+// Auto-generated by CMake from the project version (see cmake/ProjectVersion.cmake).
+// Do not edit; edit the version source (git tag / fallback) instead.
+#ifndef LSL_VERSION_GENERATED_H
+#define LSL_VERSION_GENERATED_H
+
+#define LSL_LIBRARY_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define LSL_LIBRARY_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define LSL_LIBRARY_VERSION_PATCH @PROJECT_VERSION_PATCH@
+
+#endif