Update cmake from MK3 branch

CMakeLists.txt

@@ -2,60 +2,97 @@ cmake_minimum_required(VERSION 3.19)
 include(cmake/Utilities.cmake)
 include(cmake/GetGitRevisionDescription.cmake)
 include(cmake/ReproducibleBuild.cmake)
+include(cmake/ProjectVersion.cmake)
+resolve_version_variables()
+
+OPTION(ENFORCE_VERSION_MATCH "Enforce checking that configuration.h matches any parsed git tags" OFF)
+OPTION(NO_TAG_IS_FATAL "If tag parsing fails, issue a fatal error" OFF)
 
 set(PROJECT_VERSION_SUFFIX
     "<auto>"
     CACHE
       STRING
-      "Full version suffix to be shown on the info screen in settings (e.g. full_version=4.0.3-BETA+1035.PR111.B4, suffix=-BETA+1035.PR111.B4). Defaults to '+<commit sha>.<dirty?>.<debug?>' if set to '<auto>'."
+      "Version suffix to be appended to the final filename (<ver+PROJECT_VERSION_SUFFIX>). Overrides git hash if set."
     )
-set(PROJECT_VERSION_SUFFIX_SHORT
+if(PROJECT_VERSION_SUFFIX STREQUAL "<auto>")
+  set(PROJECT_VERSION_SUFFIX "${FW_COMMIT_HASH}")
+endif()
+set(PROJECT_VERSION_FULL
     "<auto>"
     CACHE
       STRING
-      "Short version suffix to be shown on splash screen. Defaults to '+<BUILD_NUMBER>' if set to '<auto>'."
+      "Full version string to be shown on the info screen in settings. Overrides git version if set."
     )
-set(BUILD_NUMBER
+if(PROJECT_VERSION_FULL STREQUAL "<auto>")
-    ""
+  set(PROJECT_VERSION_FULL "${FW_COMMIT_DSC}")
-    CACHE STRING "Build number of the firmware. Resolved automatically if not specified."
+endif()
-    )
+set(PROJECT_REPOSITORY
-set(PROJECT_VERSION_TIMESTAMP
+    "Unknown"
-    ""
+    CACHE STRING "Repository string to be shown on the info screen in settings."
-    CACHE STRING "Timestamp for the build. Resolved automatically if not specified."
     )
+
 set(CUSTOM_COMPILE_OPTIONS
     ""
     CACHE STRING "Allows adding custom C/C++ flags"
     )
 
-include(cmake/ProjectVersion.cmake)
+set(FN_PREFIX "FW${PROJECT_VERSION}+${PROJECT_VERSION_SUFFIX}")
-resolve_version_variables()
-
-set(PROJECT_VERSION_FLAVOUR
-    ""
-    CACHE STRING "Firmware flavour to build - DEBUG, DEVEL, APLHA, BETA or RC"
-    )
-set(PROJECT_VERSION_FLAVOUR_REVISION
-    ""
-    CACHE STRING "Firmware flavour version, e.g. 1 for RC1, etc"
-    )
-
-if(NOT PROJECT_VERSION_FLAVOUR STREQUAL "")
-  set(PROJECT_VERSION "${PROJECT_VERSION}-${PROJECT_VERSION_FLAVOUR}")
-  add_compile_definitions(FW_FLAVOR=${PROJECT_VERSION_FLAVOUR})
-  if(NOT PROJECT_VERSION_FLAVOUR_REVISION STREQUAL "")
-    set(PROJECT_VERSION "${PROJECT_VERSION}${PROJECT_VERSION_FLAVOUR_REVISION}")
-    add_compile_definitions(FW_FLAVERSION=${PROJECT_VERSION_FLAVOUR_REVISION})
-  endif()
-endif()
 
 # Inform user about the resolved settings
-message(STATUS "Project version: ${PROJECT_VERSION}")
+message(STATUS "Project version (Configuration.h): ${PROJECT_VERSION}")
-message(
+message(STATUS "Project version suffix ..........: ${PROJECT_VERSION_SUFFIX}")
-  STATUS "Project version with short suffix: ${PROJECT_VERSION}${PROJECT_VERSION_SUFFIX_SHORT}"
+message(STATUS "Project version description......: ${PROJECT_VERSION_FULL}")
-  )
 
-set(FN_PREFIX "FW${PROJECT_VERSION}${PROJECT_VERSION_SUFFIX_SHORT}")
+# testing
+# SET(FW_COMMIT_DSC "v3.13.0-1234")
+
+if(NOT "${PROJECT_VERSION_SUFFIX}" STREQUAL "UNKNOWN" AND NOT "${FW_COMMIT_DSC}" MATCHES ".+NOTFOUND.+") # else -> no commit hash is known... likely no git.
+string(REGEX MATCH "v([0-9]+)\.([0-9]+)\.([0-9]+)-?(${DEV_TAG_REGEX})?([0-9]+)?-([0-9]+)" TAG_VERSION "${FW_COMMIT_DSC}")
+
+if (CMAKE_MATCH_4) # Do we have a build type?
+    decode_flavor_code(PROJECT_VER_TAG_FLV "${CMAKE_MATCH_4}" "${CMAKE_MATCH_5}")
+else()
+    # No dev status found, it must be a final tag.
+    decode_flavor_code(PROJECT_VER_TAG_FLV "RELEASED" "0")
+endif()
+
+if(ENFORCE_VERSION_MATCH)
+    if(NOT ${CMAKE_MATCH_1} STREQUAL ${PROJECT_VERSION_MAJOR})
+        message(FATAL_ERROR "Major version of current tag disagrees with Configuration.h ${CMAKE_MATCH_1}!=${PROJECT_VERSION_MAJOR}")
+    endif()
+
+    if(NOT ${CMAKE_MATCH_2} STREQUAL ${PROJECT_VERSION_MINOR})
+        message(FATAL_ERROR "Minor version of current tag disagrees with Configuration.h ${CMAKE_MATCH_2}!=${PROJECT_VERSION_MINOR}")
+    endif()
+
+    if(NOT ${CMAKE_MATCH_3} STREQUAL ${PROJECT_VERSION_REV})
+        message(FATAL_ERROR "Rev version of current tag disagrees with Configuration.h ${CMAKE_MATCH_3}!=${PROJECT_VERSION_REV}")
+    endif()
+
+    if(NOT ${PROJECT_VER_TAG_FLV} STREQUAL ${PROJECT_VERSION_TWEAK})
+        message(FATAL_ERROR "Dev status of current tag disagrees with Configuration.h ${PROJECT_VER_TAG_FLV}!=${PROJECT_VERSION_TWEAK}")
+    endif()
+    # Note - we don't check the commit counter, that'd be too much of a headache. Maybe it
+    # should be an error only on a tagged build?
+    MESSAGE(STATUS "Configuration.h and tag match: OK (${PROJECT_VERSION}/${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}.${PROJECT_VER_TAG_FLV})")
+else()
+    MESSAGE(STATUS "Configuration.h and tag (not enforced): (${PROJECT_VERSION}/${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}.${PROJECT_VER_TAG_FLV})")
+endif()
+
+MESSAGE(STATUS "Commit Nr: Configuration.h: ${PROJECT_VERSION_COMMIT} Tag: ${CMAKE_MATCH_6}")
+MESSAGE(STATUS "These tag values will override Configuration.h")
+SET(PROJECT_VERSION ${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}.${PROJECT_VER_TAG_FLV})
+SET(PROJECT_VERSION_COMMIT ${CMAKE_MATCH_6})
+git_get_repository(PROJECT_REPOSITORY)
+else(GIT_FOUND)
+if (NO_TAG_IS_FATAL)
+    MESSAGE(FATAL_ERROR "Git was not found or an error occurred parsing the tag. This is a fatal error according to the settings.")
+else()
+    MESSAGE(STATUS "Git was not found or an error occurred parsing the tag. Falling back to Configuration.h values (${PROJECT_VERSION}).")
+endif()
+set(FW_COMMIT_HASH ${FW_COMMIT_HASH_UNKNOWN}) # Clear it, the code expects a binary...
+set(PROJECT_VERSION_TIMESTAMP "0")
+endif()
 
 # Language configuration
 set(MAIN_LANGUAGES
@@ -75,7 +112,7 @@ set(COMMUNITY_LANGUAGES
 set(SELECTED_LANGUAGES ${MAIN_LANGUAGES} ${COMMUNITY_LANGUAGES})
 
 get_dependency_directory(prusa3dboards PRUSA_BOARDS_DIR)
-project(Prusa-Firmware)
+project(Prusa-Firmware VERSION ${PROJECT_VERSION})
 add_subdirectory(lib)
 
 # Get LANG_MAX_SIZE from sources
@@ -237,7 +274,6 @@ list(TRANSFORM AVR_SOURCES PREPEND ${PRUSA_BOARDS_DIR}/cores/prusa_einsy_rambo/)
 # Target configuration
 #
 if(CMAKE_CROSSCOMPILING)
-  # set source epoch
   set_source_epoch(${PROJECT_VERSION_TIMESTAMP})
 
   # default optimization flags
@@ -327,8 +363,25 @@ function(add_base_binary variant_name)
   target_link_options(
     ${variant_name} PUBLIC -Wl,-Map=${CMAKE_CURRENT_BINARY_DIR}/${variant_name}.map
     )
-
+  decode_tweak_version(PROJECT_VERSION_FLV PROJECT_VERSION_FLV_VER)
-  target_compile_definitions(${variant_name} PRIVATE CMAKE_CONTROL)
+  target_compile_definitions(
+    ${variant_name}
+    PRIVATE CMAKE_CONTROL FW_REPOSITORY="${PROJECT_REPOSITORY}"
+            FW_COMMIT_HASH="${FW_COMMIT_HASH}"
+            FW_COMMIT_HASH_LENGTH=${FW_COMMIT_HASH_LENGTH}
+            FW_MAJOR=${PROJECT_VERSION_MAJOR}
+            FW_MINOR=${PROJECT_VERSION_MINOR}
+            FW_REVISION=${PROJECT_VERSION_REV}
+            FW_COMMITNR=${PROJECT_VERSION_COMMIT}
+    )
+    if(NOT PROJECT_VERSION_FLV STREQUAL "RELEASED")
+        target_compile_definitions(
+        ${variant_name}
+        PRIVATE
+        FW_FLAVERSION=${PROJECT_VERSION_FLV_VER}
+        FW_FLAVOR=${PROJECT_VERSION_FLV}
+        )
+    endif()
 endfunction()
 
 function(fw_add_variant variant_name)
@@ -386,7 +439,7 @@ function(fw_add_variant variant_name)
     add_custom_target(
       check_lang_${variant_name}_${LANG}
       COMMENT "Checking ${variant_name} language ${LANG}"
-      COMMAND ${CMAKE_SOURCE_DIR}/lang/lang-check.py --map ${LANG_MAP} ${PO_FILE}
+      COMMAND "${Python3_EXECUTABLE}" ${CMAKE_SOURCE_DIR}/lang/lang-check.py --map ${LANG_MAP} ${PO_FILE}
       DEPENDS ${LANG_MAP} ${PO_FILE}
       USES_TERMINAL
       )
@@ -458,7 +511,7 @@ function(fw_add_variant variant_name)
       add_custom_command(
         OUTPUT ${FW_LANG_FINAL}.bin
         COMMAND ${CMAKE_OBJCOPY} -O binary ${FW_LANG_BASE} ${FW_LANG_FINAL}.bin
-        COMMAND ${CMAKE_SOURCE_DIR}/lang/lang-patchsec.py ${FW_LANG_BASE} ${LANG_BIN}
+        COMMAND "${Python3_EXECUTABLE}" ${CMAKE_SOURCE_DIR}/lang/lang-patchsec.py ${FW_LANG_BASE} ${LANG_BIN}
                 ${FW_LANG_FINAL}.bin
         DEPENDS ${FW_LANG_BASE} ${LANG_BIN}
         COMMENT "Generating ${FW_LANG_FINAL}.bin"
@@ -514,7 +567,7 @@ if(CMAKE_CROSSCOMPILING)
     set(DIR_NAME ${THIS_VAR})
     file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/build_gen/${DIR_NAME})
     file(WRITE ${CMAKE_CURRENT_SOURCE_DIR}/build_gen/${DIR_NAME}/CMakeLists.txt
-         "project(${DIR_NAME})\nfw_add_variant(${THIS_VAR})"
+         "project(${DIR_NAME} VERSION ${PROJECT_VERSION})\nfw_add_variant(${THIS_VAR})"
          )
     add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/build_gen/${DIR_NAME})
   endforeach(THIS_VAR IN LISTS FW_VARIANTS)

Firmware/Configuration.h

@@ -5,6 +5,8 @@
 
 #define STR_HELPER(x) #x
 #define STR(x) STR_HELPER(x)
+#define _CONCAT(x,y) x##y
+#define CONCAT(x,y) _CONCAT(x,y)
 
 #include <avr/pgmspace.h>
 extern const uint16_t _nPrinterType;
@@ -12,54 +14,41 @@ extern const char _sPrinterName[] PROGMEM;
 extern const uint16_t _nPrinterMmuType;
 extern const char _sPrinterMmuName[] PROGMEM;
 
-// Firmware version
+// Firmware version.
+// NOTE: These are ONLY used if you are not building via cmake and/or not in a git repository.
+// Otherwise the repository information takes precedence.
+#ifndef CMAKE_CONTROL
 #define FW_MAJOR 3
 #define FW_MINOR 13
-#define FW_REVISION 2
+#define FW_REVISION 0
-#define FW_FLAVOR RC      //uncomment if DEBUG, DEVEL, ALPHA, BETA or RC
+#warning "** Not sure why I had to touch this, but it seems like v3.13.1 is not in the linear history of this branch yet?"
+#define FW_COMMITNR 6853
+#define FW_FLAVOR RC      //uncomment if DEV, ALPHA, BETA or RC
 #define FW_FLAVERSION 1     //uncomment if FW_FLAVOR is defined and versioning is needed. Limited to max 8.
-#ifndef FW_FLAVOR
-    #define FW_VERSION STR(FW_MAJOR) "." STR(FW_MINOR) "." STR(FW_REVISION)
-#else
-    #define FW_VERSION STR(FW_MAJOR) "." STR(FW_MINOR) "." STR(FW_REVISION) "-" STR(FW_FLAVOR) "" STR(FW_FLAVERSION)
 #endif
 
-#define FW_COMMIT_NR 7068
+#ifndef FW_FLAVOR
+    #define FW_TWEAK (FIRMWARE_REVISION_RELEASED)
+    #define FW_VERSION STR(FW_MAJOR) "." STR(FW_MINOR) "." STR(FW_REVISION)
+    #define FW_VERSION_FULL STR(FW_MAJOR) "." STR(FW_MINOR) "." STR(FW_REVISION) "-" STR(FW_COMMITNR)
+#else
+    // Construct the TWEAK value as it is expected from the enum.
+    #define FW_TWEAK (CONCAT(FIRMWARE_REVISION_,FW_FLAVOR) + FW_FLAVERSION)
+    #define FW_VERSION STR(FW_MAJOR) "." STR(FW_MINOR) "." STR(FW_REVISION) "-" STR(FW_FLAVOR) "" STR(FW_FLAVERSION)
+    #define FW_VERSION_FULL STR(FW_MAJOR) "." STR(FW_MINOR) "." STR(FW_REVISION) "-" STR(FW_FLAVOR) "" STR(FW_FLAVERSION) "-" STR(FW_COMMITNR)
+#endif
 
-// FW_VERSION_UNKNOWN means this is an unofficial build.
+// The full version string and repository source are set via cmake
-// The firmware should only be checked into github with this symbol.
+#ifndef CMAKE_CONTROL
-#define FW_DEV_VERSION FW_VERSION_UNKNOWN
+#define FW_COMMIT_HASH_LENGTH 1
+#define FW_COMMIT_HASH "0"
 #define FW_REPOSITORY "Unknown"
-#define FW_VERSION_FULL FW_VERSION "-" STR(FW_COMMIT_NR)
+#define FW_VERSION_FULL FW_VERSION "-unknown"
+#endif
 
 // G-code language level
 #define GCODE_LEVEL 1
 
-// Debug version has debugging enabled (the symbol DEBUG_BUILD is set).
-// The debug build may be a bit slower than the non-debug build, therefore the debug build should
-// not be shipped to a customer.
-#define FW_VERSION_DEBUG    6
-// This is a development build. A development build is either built from an unofficial git repository,
-// or from an unofficial branch, or it does not have a label set. Only the build server should set this build type.
-#define FW_VERSION_DEVEL    5
-// This is an alpha release. Only the build server should set this build type.
-#define FW_VERSION_ALPHA    4
-// This is a beta release. Only the build server should set this build type.
-#define FW_VERSION_BETA     3
-// This is a release candidate build. Only the build server should set this build type.
-#define FW_VERSION_RC       2
-// This is a final release. Only the build server should set this build type.
-#define FW_VERSION_GOLD     1
-// This is an unofficial build. The firmware should only be checked into github with this symbol,
-// the build server shall never produce builds with this build type.
-#define FW_VERSION_UNKNOWN  0
-
-#if FW_DEV_VERSION == FW_VERSION_DEBUG
-#define DEBUG_BUILD
-#else
-#undef DEBUG_BUILD
-#endif
-
 #ifndef SOURCE_DATE_EPOCH
 #define SOURCE_DATE_EPOCH __DATE__
 #endif
@@ -160,7 +149,7 @@ extern const char _sPrinterMmuName[] PROGMEM;
 
 // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it
 // Ultimaker
-    
+
 
 // MakerGear
 //    #define  DEFAULT_Kp 7.0
@@ -196,15 +185,15 @@ The issue: If a thermistor come off, it will read a lower temperature than actua
 The system will turn the heater on forever, burning up the filament and anything
 else around.
 
-After the temperature reaches the target for the first time, this feature will 
+After the temperature reaches the target for the first time, this feature will
-start measuring for how long the current temperature stays below the target 
+start measuring for how long the current temperature stays below the target
 minus _HYSTERESIS (set_temperature - THERMAL_RUNAWAY_PROTECTION_HYSTERESIS).
 
 If it stays longer than _PERIOD, it means the thermistor temperature
 cannot catch up with the target, so something *may be* wrong. Then, to be on the
 safe side, the system will he halt.
 
-Bear in mind the count down will just start AFTER the first time the 
+Bear in mind the count down will just start AFTER the first time the
 thermistor temperature is over the target, so you will have no problem if
 your extruder heater takes 2 minutes to hit the target on heating.
 
@@ -296,7 +285,7 @@ your extruder heater takes 2 minutes to hit the target on heating.
 
 
 #define X_MAX_LENGTH (X_MAX_POS - X_MIN_POS)
-#define Y_MAX_LENGTH (Y_MAX_POS - Y_MIN_POS) 
+#define Y_MAX_LENGTH (Y_MAX_POS - Y_MIN_POS)
 #define Z_MAX_LENGTH (Z_MAX_POS - Z_MIN_POS)
 
 #define Z_HEIGHT_HIDE_LIVE_ADJUST_MENU 2.0f
@@ -415,9 +404,9 @@ your extruder heater takes 2 minutes to hit the target on heating.
 	  #endif
 	#endif
 
-	
+
   #endif
-  
+
 #endif // ENABLE_AUTO_BED_LEVELING
 
 

Firmware/ultralcd.cpp

@@ -1605,9 +1605,7 @@ static void lcd_support_menu()
 
   MENU_ITEM_BACK_P(PSTR("Firmware:"));
   MENU_ITEM_BACK_P(PSTR(" " FW_VERSION_FULL));
-#if (FW_DEV_VERSION != FW_VERSION_GOLD) && (FW_DEV_VERSION != FW_VERSION_RC)
+//  MENU_ITEM_BACK_P(PSTR(" repo " FW_REPOSITORY));
-  MENU_ITEM_BACK_P(PSTR(" repo " FW_REPOSITORY));
-#endif
 
   MENU_ITEM_BACK_P(_n("prusa3d.com"));////MSG_PRUSA3D c=18
   MENU_ITEM_BACK_P(_n("forum.prusa3d.com"));////MSG_PRUSA3D_FORUM c=18

Firmware/util.cpp

@@ -14,21 +14,17 @@ const uint16_t FW_VERSION_NR[4] PROGMEM = {
     FW_MAJOR,
     FW_MINOR,
     FW_REVISION,
-#ifndef FW_FLAVOR
+    FW_TWEAK,
-    FW_COMMIT_NR
-#else
-#   if FW_DEV_VERSION == FW_VERSION_ALPHA
-    FIRMWARE_REVISION_ALPHA + FW_FLAVERSION
-#   elif FW_DEV_VERSION == FW_VERSION_BETA
-    FIRMWARE_REVISION_BETA + FW_FLAVERSION
-#   elif FW_DEV_VERSION == FW_VERSION_RC
-    FIRMWARE_REVISION_RC + FW_FLAVERSION
-#   elif FW_DEV_VERSION == FW_VERSION_GOLD
-    0
-#   endif
-#endif
 };
 
+const char FW_VERSION_HASH[] PROGMEM = FW_COMMIT_HASH;
+static_assert(sizeof(FW_VERSION_HASH) == FW_COMMIT_HASH_LENGTH + 1);
+
+const char* FW_VERSION_HASH_P()
+{
+    return FW_VERSION_HASH;
+}
+
 const char* FW_VERSION_STR_P()
 {
     return FW_VERSION_STR;
@@ -159,7 +155,7 @@ inline bool strncmp_PP(const char *p1, const char *p2, uint8_t n)
 				return -1;
 			if (pgm_read_byte(p1) > pgm_read_byte(p2))
 				return 1;
-		}            
+		}
     }
     return 0;
 }

Firmware/util.h

@@ -2,7 +2,10 @@
 #include <stdint.h>
 
 extern const uint16_t FW_VERSION_NR[4];
-extern const char* FW_VERSION_STR_P();
+const char* FW_VERSION_STR_P();
+
+extern const char FW_VERSION_HASH[];
+const char* FW_VERSION_HASH_P();
 
 // Definition of a firmware flavor numerical values.
 // To keep it short as possible

cmake/GetGitRevisionDescription.cmake

@@ -1,33 +1,33 @@
-# * Returns a version string from Git
+# - Returns a version string from Git
 #
-# These functions force a re-configure on each git commit so that you can trust the values of the
+# These functions force a re-configure on each git commit so that you can
-# variables in your build system.
+# trust the values of the variables in your build system.
 #
-# get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
+#  get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR])
 #
 # Returns the refspec and sha hash of the current head revision
 #
-# git_describe(<var> [<additional arguments to git describe> ...])
+#  git_describe(<var> [<additional arguments to git describe> ...])
 #
-# Returns the results of git describe on the source tree, and adjusting the output so that it tests
+# Returns the results of git describe on the source tree, and adjusting
-# false if an error occurs.
+# the output so that it tests false if an error occurs.
 #
-# git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
 #
-# Returns the results of git describe --exact-match on the source tree, and adjusting the output so
+# Returns the results of git describe on the working tree (--dirty option),
-# that it tests false if there was no exact matching tag.
+# and adjusting the output so that it tests false if an error occurs.
 #
-# git_local_changes(<var>)
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
 #
-# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes. Uses the return code of
+# Returns the results of git describe --exact-match on the source tree,
-# "git diff-index --quiet HEAD --". Does not regard untracked files.
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
 #
-# git_count_parent_commits(<var>)
+#  git_local_changes(<var>)
 #
-# Returns number of commits preceeding current commit -1 if git rev-list --count HEAD failed or
+# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
-# "GIT-NOTFOUND" if git executable was not found or "HEAD-HASH-NOTFOUND" if head hash was not found.
+# Uses the return code of "git diff-index --quiet HEAD --".
-# I don't know if get_git_head_revision() must be called internally or not, as reason of calling it
+# Does not regard untracked files.
-# is not clear for me also in git_local_changes().
 #
 # git_head_commit_timestamp(<var>)
 #
@@ -35,204 +35,260 @@
 #
 # Requires CMake 2.6 or newer (uses the 'function' command)
 #
-# Original Author: 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# Original Author:
-# http://academic.cleardefinition.com Iowa State University HCI Graduate Program/VRAC
+# 2009-2020 Ryan Pavlik <ryan.pavlik@gmail.com> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
 #
-# Copyright Iowa State University 2009-2010. Distributed under the Boost Software License, Version
+# Copyright 2009-2013, Iowa State University.
-# 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# Copyright 2013-2020, Ryan Pavlik
+# Copyright 2013-2020, Contributors
+# SPDX-License-Identifier: BSL-1.0
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
 
 if(__get_git_revision_description)
-  return()
+    return()
 endif()
 set(__get_git_revision_description YES)
 
-# We must run the following at "include" time, not at function call time, to find the path to this
+# We must run the following at "include" time, not at function call time,
-# module rather than the path to a calling list file
+# to find the path to this module rather than the path to a calling list file
 get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
 
+# Function _git_find_closest_git_dir finds the next closest .git directory
+# that is part of any directory in the path defined by _start_dir.
+# The result is returned in the parent scope variable whose name is passed
+# as variable _git_dir_var. If no .git directory can be found, the
+# function returns an empty string via _git_dir_var.
+#
+# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
+# neither foo nor bar contain a file/directory .git. This wil return
+# C:/bla/.git
+#
+function(_git_find_closest_git_dir _start_dir _git_dir_var)
+    set(cur_dir "${_start_dir}")
+    set(git_dir "${_start_dir}/.git")
+    while(NOT EXISTS "${git_dir}")
+        # .git dir not found, search parent directories
+        set(git_previous_parent "${cur_dir}")
+        get_filename_component(cur_dir "${cur_dir}" DIRECTORY)
+        if(cur_dir STREQUAL git_previous_parent)
+            # We have reached the root directory, we are not in git
+            set(${_git_dir_var}
+                ""
+                PARENT_SCOPE)
+            return()
+        endif()
+        set(git_dir "${cur_dir}/.git")
+    endwhile()
+    set(${_git_dir_var}
+        "${git_dir}"
+        PARENT_SCOPE)
+endfunction()
+
 function(get_git_head_revision _refspecvar _hashvar)
-  set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
-  set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+
-  while(NOT EXISTS "${GIT_DIR}") # .git dir not found, search parent directories
+    if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
-    set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
-    get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
+    else()
-    if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
+        set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE)
-      # We have reached the root directory, we are not in git
+    endif()
-      set(${_refspecvar}
+    if(NOT "${GIT_DIR}" STREQUAL "")
-          "GITDIR-NOTFOUND"
+        file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}"
-          PARENT_SCOPE
+             "${GIT_DIR}")
-          )
+        if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR)
-      set(${_hashvar}
+            # We've gone above the CMake root dir.
-          "GITDIR-NOTFOUND"
+            set(GIT_DIR "")
-          PARENT_SCOPE
+        endif()
-          )
+    endif()
-      return()
+    if("${GIT_DIR}" STREQUAL "")
+        set(${_refspecvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        set(${_hashvar}
+            "GITDIR-NOTFOUND"
+            PARENT_SCOPE)
+        return()
     endif()
-    set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-  endwhile()
-  # check if this is a submodule
-  if(NOT IS_DIRECTORY ${GIT_DIR})
-    file(READ ${GIT_DIR} submodule)
-    string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
-    get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
-    get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
-  endif()
-  set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
-  if(NOT EXISTS "${GIT_DATA}")
-    file(MAKE_DIRECTORY "${GIT_DATA}")
-  endif()
 
-  if(NOT EXISTS "${GIT_DIR}/HEAD")
+    # Check if the current source dir is a git submodule or a worktree.
-    return()
+    # In both cases .git is a file instead of a directory.
-  endif()
+    #
-  set(HEAD_FILE "${GIT_DATA}/HEAD")
+    if(NOT IS_DIRECTORY ${GIT_DIR})
-  configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
+        # The following git command will return a non empty string that
+        # points to the super project working tree if the current
+        # source dir is inside a git submodule.
+        # Otherwise the command will return an empty string.
+        #
+        execute_process(
+            COMMAND "${GIT_EXECUTABLE}" rev-parse
+                    --show-superproject-working-tree
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            OUTPUT_VARIABLE out
+            ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(NOT "${out}" STREQUAL "")
+            # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule
+            file(READ ${GIT_DIR} submodule)
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE
+                                 ${submodule})
+            string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE)
+            get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+            get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE}
+                                   ABSOLUTE)
+            set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+        else()
+            # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree
+            file(READ ${GIT_DIR} worktree_ref)
+            # The .git directory contains a path to the worktree information directory
+            # inside the parent git repo of the worktree.
+            #
+            string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
+                                 ${worktree_ref})
+            string(STRIP ${git_worktree_dir} git_worktree_dir)
+            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
+            set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
+        endif()
+    else()
+        set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD")
+    endif()
+    set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+    if(NOT EXISTS "${GIT_DATA}")
+        file(MAKE_DIRECTORY "${GIT_DATA}")
+    endif()
 
-  configure_file(
+    if(NOT EXISTS "${HEAD_SOURCE_FILE}")
-    "${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" "${GIT_DATA}/grabRef.cmake" @ONLY
+        return()
-    )
+    endif()
-  include("${GIT_DATA}/grabRef.cmake")
+    set(HEAD_FILE "${GIT_DATA}/HEAD")
+    configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY)
 
-  set(${_refspecvar}
+    configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
-      "${HEAD_REF}"
+                   "${GIT_DATA}/grabRef.cmake" @ONLY)
-      PARENT_SCOPE
+    include("${GIT_DATA}/grabRef.cmake")
-      )
+
-  set(${_hashvar}
+    set(${_refspecvar}
-      "${HEAD_HASH}"
+        "${HEAD_REF}"
-      PARENT_SCOPE
+        PARENT_SCOPE)
-      )
+    set(${_hashvar}
+        "${HEAD_HASH}"
+        PARENT_SCOPE)
 endfunction()
 
 function(git_describe _var)
-  if(NOT GIT_FOUND)
+    if(NOT GIT_FOUND)
-    find_package(Git QUIET)
+        find_package(Git QUIET)
-  endif()
+    endif()
-  get_git_head_revision(refspec hash)
+    get_git_head_revision(refspec hash)
-  if(NOT GIT_FOUND)
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    if(NOT hash)
+        set(${_var}
+            "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    # TODO sanitize
+    #if((${ARGN}" MATCHES "&&") OR
+    #	(ARGN MATCHES "||") OR
+    #	(ARGN MATCHES "\\;"))
+    #	message("Please report the following error to the project!")
+    #	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+    #endif()
+
+    #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
     set(${_var}
-        "GIT-NOTFOUND"
+        "${out}"
-        PARENT_SCOPE
+        PARENT_SCOPE)
-        )
+endfunction()
-    return()
+
-  endif()
+function(git_describe_working_tree _var)
-  if(NOT hash)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    git_head_commit_number(COMMIT_COUNT) #Bake the commit count into the full DSC
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" describe --abbrev=0 --dirty=-D --broken=-B ${ARGN}
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+    if( "${out}" MATCHES "-D\$")
+        STRING(REPLACE "-D" "-${COMMIT_COUNT}-D" out "${out}")
+    else()
+        set(out "${out}-${COMMIT_COUNT}")
+    endif()
     set(${_var}
-        "HEAD-HASH-NOTFOUND"
+        "${out}"
-        PARENT_SCOPE
+        PARENT_SCOPE)
-        )
-    return()
-  endif()
-
-  # TODO sanitize if((${ARGN}" MATCHES "&&") OR (ARGN MATCHES "||") OR (ARGN MATCHES "\\;"))
-  # message("Please report the following error to the project!") message(FATAL_ERROR "Looks like
-  # someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") endif()
-
-  # message(STATUS "Arguments to execute_process: ${ARGN}")
-
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" describe ${hash} ${ARGN}
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE res
-    OUTPUT_VARIABLE out
-    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-  if(NOT res EQUAL 0)
-    set(out "${out}-${res}-NOTFOUND")
-  endif()
-
-  set(${_var}
-      "${out}"
-      PARENT_SCOPE
-      )
 endfunction()
 
 function(git_get_exact_tag _var)
-  git_describe(out --exact-match ${ARGN})
+    git_describe(out --exact-match ${ARGN})
-  set(${_var}
+    set(${_var}
-      "${out}"
+        "${out}"
-      PARENT_SCOPE
+        PARENT_SCOPE)
-      )
 endfunction()
 
 function(git_local_changes _var)
-  if(NOT GIT_FOUND)
+    if(NOT GIT_FOUND)
-    find_package(Git QUIET)
+        find_package(Git QUIET)
-  endif()
+    endif()
-  get_git_head_revision(refspec hash)
+    get_git_head_revision(refspec hash)
-  if(NOT GIT_FOUND)
+    if(NOT GIT_FOUND)
-    set(${_var}
+        set(${_var}
-        "GIT-NOTFOUND"
+            "GIT-NOTFOUND"
-        PARENT_SCOPE
+            PARENT_SCOPE)
-        )
+        return()
-    return()
+    endif()
-  endif()
+    if(NOT hash)
-  if(NOT hash)
+        set(${_var}
-    set(${_var}
+            "HEAD-HASH-NOTFOUND"
-        "HEAD-HASH-NOTFOUND"
+            PARENT_SCOPE)
-        PARENT_SCOPE
+        return()
-        )
+    endif()
-    return()
-  endif()
-
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE res
-    OUTPUT_VARIABLE out
-    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-  if(res EQUAL 0)
-    set(${_var}
-        "CLEAN"
-        PARENT_SCOPE
-        )
-  else()
-    set(${_var}
-        "DIRTY"
-        PARENT_SCOPE
-        )
-  endif()
-endfunction()
-
-function(git_count_parent_commits _var)
-  if(NOT GIT_FOUND)
-    find_package(Git QUIET)
-  endif()
-  get_git_head_revision(refspec hash)
-  if(NOT GIT_FOUND)
-    set(${_var}
-        "GIT-NOTFOUND"
-        PARENT_SCOPE
-        )
-    return()
-  endif()
-  if(NOT hash)
-    set(${_var}
-        "HEAD-HASH-NOTFOUND"
-        PARENT_SCOPE
-        )
-    return()
-  endif()
-
-  execute_process(
-    COMMAND "${GIT_EXECUTABLE}" rev-list --count HEAD
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    RESULT_VARIABLE res
-    OUTPUT_VARIABLE out
-    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-  if(res EQUAL 0)
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE
-        )
-  else()
-    set(${_var}
-        "-1"
-        PARENT_SCOPE
-        )
-  endif()
 
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(res EQUAL 0)
+        set(${_var}
+            "CLEAN"
+            PARENT_SCOPE)
+    else()
+        set(${_var}
+            "DIRTY"
+            PARENT_SCOPE)
+    endif()
 endfunction()
 
 function(git_get_commit_timestamp _var hash)
@@ -282,3 +338,85 @@ function(git_head_commit_timestamp _var)
       PARENT_SCOPE
       )
 endfunction()
+
+function(git_head_commit_data _var _format)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" show -s --quiet --format=format:${_format} HEAD
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "HEAD-FORMAT-NOTFOUND")
+    endif()
+    set(${_var}
+        ${out}
+        PARENT_SCOPE)
+endfunction()
+
+function(git_head_commit_number _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "GIT-NOTFOUND"
+            PARENT_SCOPE)
+        return()
+    endif()
+
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" rev-list --count HEAD
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(NOT res EQUAL 0)
+        set(out "${out}-${res}-NOTFOUND")
+    endif()
+
+    set(${_var}
+        "${out}"
+        PARENT_SCOPE)
+endfunction()
+
+function(git_get_repository _var)
+    if(NOT GIT_FOUND)
+        find_package(Git QUIET)
+    endif()
+    if(NOT GIT_FOUND)
+        set(${_var}
+            "Unknown"
+            PARENT_SCOPE)
+        return()
+    endif()
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" ls-remote --get-url
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        RESULT_VARIABLE res
+        OUTPUT_VARIABLE out
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        message("remote URL is ${out}")
+    string(REGEX MATCH "([A-z0-9-]+)/Prusa-Firmware.?g?i?t?" out "${out}")
+    if("${CMAKE_MATCH_COUNT}" EQUAL 1)
+        message("Found repository name ${CMAKE_MATCH_1}")
+        set(${_var}
+            "${CMAKE_MATCH_1}"
+            PARENT_SCOPE)
+    else()
+        message("Failed to get repository information")
+        set(${_var}
+           #"${out}" #outputs the github repo user name
+           "Unknown" #All other repos shown as unknown
+           PARENT_SCOPE)
+    endif()
+endfunction()

cmake/GetGitRevisionDescription.cmake.in

@@ -3,11 +3,17 @@
 #
 # Requires CMake 2.6 or newer (uses the 'function' command)
 #
-# Original Author: 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# Original Author:
-# http://academic.cleardefinition.com Iowa State University HCI Graduate Program/VRAC
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
 #
-# Copyright Iowa State University 2009-2010. Distributed under the Boost Software License, Version
+# Copyright 2009-2012, Iowa State University
-# 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# Copyright 2011-2015, Contributors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+# SPDX-License-Identifier: BSL-1.0
 
 set(HEAD_HASH)
 
@@ -15,23 +21,23 @@ file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
 
 string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
 if(HEAD_CONTENTS MATCHES "ref")
-  # named branch
+	# named branch
-  string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
-  if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
-    configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-  else()
+	else()
-    configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
+		configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY)
-    file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
+		file(READ "@GIT_DATA@/packed-refs" PACKED_REFS)
-    if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
+		if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}")
-      set(HEAD_HASH "${CMAKE_MATCH_1}")
+			set(HEAD_HASH "${CMAKE_MATCH_1}")
-    endif()
+		endif()
-  endif()
+	endif()
 else()
-  # detached HEAD
+	# detached HEAD
-  configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
 endif()
 
 if(NOT HEAD_HASH)
-  file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-  string(STRIP "${HEAD_HASH}" HEAD_HASH)
+	string(STRIP "${HEAD_HASH}" HEAD_HASH)
 endif()

cmake/ProjectVersion.cmake

@@ -1,71 +1,132 @@
-#
+#[[
 # This file is responsible for setting the following variables:
 #
 # ~~~
-# BUILD_NUMBER (1035)
+# PROJECT_VERSION_MAJOR (3)
-# PROJECT_VERSION (4.0.3)
+# PROJECT_VERSION_MINOR (13)
-# PROJECT_VERSION_FULL (4.0.3-BETA+1035.PR111.B4)
+# PROJECT_VERSION_REV (2)
-# PROJECT_VERSION_SUFFIX (-BETA+1035.PR111.B4)
+# PROJECT_VERSION (3.13.2)
-# PROJECT_VERSION_SUFFIX_SHORT (+1035)
+# FW_COMMIT_DSC ("v3.13.2-deadbeef")
-# PROJECT_VERSION_TIMESTAMP (unix timestamp)
+# FW_COMMIT_HASH (deadbeef)
+# FW_COMMIT_DATE (1665051856)
 #
 # The `PROJECT_VERSION` variable is set as soon as the file is included.
 # To set the rest, the function `resolve_version_variables` has to be called.
-#
 # ~~~
+#]]
 
-FILE(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/Firmware/Configuration.h CFG_VER_DATA REGEX "#define FW_[A-Z]+ ([0-9]+)" )
+# NOTE: these are ordered according to the enum in Util.h. DO NOT ALTER!
-LIST(GET CFG_VER_DATA 0 PROJECT_VERSION_MAJOR)
+# // Definition of a firmware flavor numerical values.
-LIST(GET CFG_VER_DATA 1 PROJECT_VERSION_MINOR)
+# // To keep it short as possible
-LIST(GET CFG_VER_DATA 2 PROJECT_VERSION_REV)
+# // DEVs/ALPHAs/BETAs limited to max 8 flavor versions
-STRING(REGEX MATCH "FW_MAJOR ([0-9]+)" PROJECT_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
+# // RCs limited to 32 flavor versions
-SET(PROJECT_VERSION_MAJOR  "${CMAKE_MATCH_1}")
+# // Final Release always 64 as highest
+# enum FirmwareRevisionFlavorType : uint16_t {
+#     FIRMWARE_REVISION_RELEASED = 0x0040,
+#     FIRMWARE_REVISION_DEV = 0x0000,
+#     FIRMWARE_REVISION_ALPHA = 0x008,
+#     FIRMWARE_REVISION_BETA = 0x0010,
+#     FIRMWARE_REVISION_RC = 0x0020
+# };
 
-STRING(REGEX MATCH "FW_MINOR ([0-9]+)" PROJECT_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
+# Note - the Xes are padding because there is an extended allowance of RC numbers.
-SET(PROJECT_VERSION_MINOR  ${CMAKE_MATCH_1})
+SET(DEV_TAGS "DEV" "ALPHA" "BETA" "RC" "X" "X" "X" "X" "RELEASED")
+STRING(REPLACE ";" "\|" DEV_TAG_REGEX "${DEV_TAGS}")
+function(decode_flavor_code _output _label _ver)
+    LIST(FIND DEV_TAGS "${_label}" _code_index)
+    MESSAGE(DEBUG "Tweak math: (8*0${_code_index})+${_ver}")
+        MATH(EXPR _decoded "(8*0${_code_index})+${_ver}")
+    set(${_output}
+        "${_decoded}"
+        PARENT_SCOPE)
+endfunction()
 
-STRING(REGEX MATCH "FW_REVISION +([0-9]+)" PROJECT_VERSION_REV "${PROJECT_VERSION_REV}")
+function(decode_tweak_version _str _ver)
-SET(PROJECT_VERSION_REV  ${CMAKE_MATCH_1})
+    MATH(EXPR _string_id "(${PROJECT_VERSION_TWEAK})/8")
+    MATH(EXPR _version "${PROJECT_VERSION_TWEAK}-(8*${_string_id})")
+    set(${_ver} "${_version}" PARENT_SCOPE)
+    LIST(GET DEV_TAGS ${_string_id} _string_val)
+    set(${_str} "${_string_val}" PARENT_SCOPE)
+endfunction()
 
-SET(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_REV}")
 
+file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/Firmware/Configuration.h CFG_VER_DATA
+     REGEX "#define FW_[A-Z]+ (${DEV_TAG_REGEX}|[0-9]+)"
+     )
+list(GET CFG_VER_DATA 0 PROJECT_VERSION_MAJOR)
+list(GET CFG_VER_DATA 1 PROJECT_VERSION_MINOR)
+list(GET CFG_VER_DATA 2 PROJECT_VERSION_REV)
+list(GET CFG_VER_DATA 3 PROJECT_VERSION_COMMIT)
+list(GET CFG_VER_DATA 4 PROJECT_VERSION_FLV)
+list(GET CFG_VER_DATA 5 PROJECT_VERSION_FLV_VER)
+
+string(REGEX MATCH "FW_MAJOR ([0-9]+)" PROJECT_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
+set(PROJECT_VERSION_MAJOR "${CMAKE_MATCH_1}")
+
+string(REGEX MATCH "FW_MINOR ([0-9]+)" PROJECT_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
+set(PROJECT_VERSION_MINOR ${CMAKE_MATCH_1})
+
+string(REGEX MATCH "FW_REVISION +([0-9]+)" PROJECT_VERSION_REV "${PROJECT_VERSION_REV}")
+set(PROJECT_VERSION_REV ${CMAKE_MATCH_1})
+
+string(REGEX MATCH "FW_COMMITNR +([0-9]+)" PROJECT_VERSION_COMMIT "${PROJECT_VERSION_COMMIT}")
+set(PROJECT_VERSION_COMMIT ${CMAKE_MATCH_1})
+
+string(REGEX MATCH "^#define FW_FLAVOR +(${DEV_TAG_REGEX})" PROJECT_VERSION_FLV "${PROJECT_VERSION_FLV}")
+IF(PROJECT_VERSION_FLV)
+    message(STATUS "Found a defined FW_FLAVOR")
+    set(PROJECT_VERSION_FLV ${CMAKE_MATCH_1})
+    string(REGEX MATCH "FW_FLAVERSION +([0-9]+)" PROJECT_VERSION_FLV_VER "${PROJECT_VERSION_FLV_VER}")
+    set(PROJECT_VERSION_FLV_VER ${CMAKE_MATCH_1})
+
+    decode_flavor_code(PROJECT_VERSION_TWEAK "${PROJECT_VERSION_FLV}" "${PROJECT_VERSION_FLV_VER}")
+ELSE()
+    decode_flavor_code(PROJECT_VERSION_TWEAK "RELEASED" "0")
+ENDIF()
+
+
+set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_REV}.${PROJECT_VERSION_TWEAK}")
+
+# Define a constant length for the commit hash
+set(FW_COMMIT_HASH_LENGTH 9)
+
+# Create fallback value with constant length
+string(REPEAT "0" ${FW_COMMIT_HASH_LENGTH} FW_COMMIT_HASH_UNKNOWN)
 
 function(resolve_version_variables)
-  # BUILD_NUMBER
+  if(FW_COMMIT_DSC)
-  if(NOT BUILD_NUMBER)
+    return()
-    git_count_parent_commits(BUILD_NUMBER)
+  endif()
-    set(ERRORS "GIT-NOTFOUND" "HEAD-HASH-NOTFOUND")
+  if(NOT GIT_FOUND)
-    if(BUILD_NUMBER IN_LIST ERRORS)
+    find_package(Git QUIET)
-      message(WARNING "Failed to resolve build number: ${BUILD_NUMBER}. Setting to zero.")
-      set(BUILD_NUMBER "0")
-    endif()
-    set(BUILD_NUMBER
-        ${BUILD_NUMBER}
-        PARENT_SCOPE
-        )
   endif()
 
-  # PROJECT_VERSION_SUFFIX
+  # Get the full commit hash
-  if(PROJECT_VERSION_SUFFIX STREQUAL "<auto>")
+  git_head_commit_data(FW_COMMIT_HASH "%H")
-    # TODO: set to +<sha>.dirty?.debug?
-    set(PROJECT_VERSION_SUFFIX "+${BUILD_NUMBER}.LOCAL")
-    set(PROJECT_VERSION_SUFFIX
-        "+${BUILD_NUMBER}.LOCAL"
-        PARENT_SCOPE
-        )
-  endif()
 
-  # PROJECT_VERSION_SUFFIX_SHORT
+  # Keep only the first 'FW_COMMIT_HASH_LENGTH' characters
-  if(PROJECT_VERSION_SUFFIX_SHORT STREQUAL "<auto>")
+  string(SUBSTRING "${FW_COMMIT_HASH}" 0 ${FW_COMMIT_HASH_LENGTH} FW_COMMIT_HASH)
-    set(PROJECT_VERSION_SUFFIX_SHORT
-        "+${BUILD_NUMBER}"
-        PARENT_SCOPE
-        )
-  endif()
 
-  # PROJECT_VERSION_FULL
+  set(ERRORS "GIT-NOTFOUND" "HEAD-FORMAT-NOTFOUND")
-  set(PROJECT_VERSION_FULL
+  if(FW_COMMIT_HASH IN_LIST ERRORS)
-      "${PROJECT_VERSION}${PROJECT_VERSION_SUFFIX}"
+    # git not available, set fallback values
+    set(FW_COMMIT_HASH ${FW_COMMIT_HASH_UNKNOWN})
+    set(FW_COMMIT_DSC "v${PROJECT_VERSION}-${FW_COMMIT_HASH}")
+    string(TIMESTAMP FW_COMMIT_DATE "%s")
+  else()
+    git_describe_working_tree(FW_COMMIT_DSC)
+    git_head_commit_data(FW_COMMIT_DATE "%ct")
+  endif()
+  set(FW_COMMIT_DSC
+      "${FW_COMMIT_DSC}"
+      PARENT_SCOPE
+      )
+  set(FW_COMMIT_HASH
+      "${FW_COMMIT_HASH}"
+      PARENT_SCOPE
+      )
+  set(FW_COMMIT_DATE
+      "${FW_COMMIT_DATE}"
       PARENT_SCOPE
       )
 

tests/CMakeLists.txt

@@ -16,3 +16,27 @@ add_executable(tests ${TEST_SOURCES})
 target_include_directories(tests PRIVATE tests)
 target_link_libraries(tests Catch2::Catch2WithMain)
 catch_discover_tests(tests)
+
+set(ctest_test_args --output-on-failure)
+
+include(ProcessorCount)
+ProcessorCount(N)
+if(N EQUAL 0)
+  message(
+    WARNING "CTest: There was an issue reading the core count, tests won't be run in parallel"
+    )
+else()
+  message(STATUS "CTest: Detected ${N} CPU threads")
+  set(ctest_test_args -j${N} ${ctest_test_args})
+endif()
+
+# This step needs to always return OK but log whether it was successful or not. The thought here
+# is that if the tests all pass, .ctest-finished is created and we can check for its existance
+# after generating the report to determine if the overall build result is a pass or fail.
+add_custom_target(
+  test_run_all
+  COMMAND ${CMAKE_CTEST_COMMAND} ${ctest_test_args}
+  COMMAND ${CMAKE_COMMAND} -E touch .ctest-finished || exit 0
+  BYPRODUCTS ${PROJECT_BINARY_DIR}/.ctest-finished
+  WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
+  )