Исправлена функция для внедрения переводов

CMLibBuildTypes.cmake

@@ -6,12 +6,16 @@ if(CMAKE_CONFIGURATION_TYPES)
     list(APPEND CMAKE_CONFIGURATION_TYPES Profile)
   endif()
 else()
-  set(_allowed_build_types None Debug Release Profile RelWithDebInfo MinSizeRel)
+  set(_allowed_build_types
+      None
+      Debug
+      Release
+      Profile
+      RelWithDebInfo
+      MinSizeRel)
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${_allowed_build_types})
   if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "" FORCE)
-        Debug
-        CACHE STRING "" FORCE)
   elseif(NOT "${CMAKE_BUILD_TYPE}" IN_LIST _allowed_build_types)
     message(FATAL_ERROR "Invalid build type: ${CMAKE_BUILD_TYPE}")
   endif()
@@ -20,24 +24,12 @@ endif()
 if(CMAKE_BUILD_TYPE STREQUAL Profile)
   # Ключи компиляции для режима профилирования в зависимости от типа компилятора
   if(CMAKE_CXX_COMPILER_IS_Clang OR CMAKE_CXX_COMPILER_IS_GCC)
-    set(CMAKE_C_FLAGS_PROFILE
+    set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -ggdb -pg" CACHE STRING "")
-        "${CMAKE_C_FLAGS_RELEASE} -ggdb -pg"
+    set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE} -ggdb -pg" CACHE STRING "")
-        CACHE STRING "")
+    set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "")
-    set(CMAKE_CXX_FLAGS_PROFILE
+    set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "")
-        "${CMAKE_CXX_FLAGS_RELEASE} -ggdb -pg"
+    set(CMAKE_STATIC_LINKER_FLAGS_PROFILE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "")
-        CACHE STRING "")
+    set(CMAKE_MODULE_LINKER_FLAGS_PROFILE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "")
-    set(CMAKE_EXE_LINKER_FLAGS_PROFILE
-        "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -pg"
-        CACHE STRING "")
-    set(CMAKE_SHARED_LINKER_FLAGS_PROFILE
-        "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -pg"
-        CACHE STRING "")
-    set(CMAKE_STATIC_LINKER_FLAGS_PROFILE
-        "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} -pg"
-        CACHE STRING "")
-    set(CMAKE_MODULE_LINKER_FLAGS_PROFILE
-        "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -pg"
-        CACHE STRING "")
   elseif(CMAKE_CXX_COMPILER_IS_Intel)
     message("Set options for profiling with Intel C++")
   elseif(CMAKE_CXX_COMPILER_IS_MSVC)
@@ -50,27 +42,19 @@ elseif(CMAKE_BUILD_TYPE STREQUAL Debug)
     string(APPEND CMAKE_C_FLAGS_DEBUG " -ggdb")
     string(APPEND CMAKE_CXX_FLAGS_DEBUG " -ggdb")
   endif()
-  set(CMAKE_VERBOSE_MAKEFILE
+  set(CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "Enable verbose build file generation." FORCE)
-      ON
+  set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Enable output of compile commands during generation."
-      CACHE BOOL "Enable verbose build file generation." FORCE)
+                                             FORCE)
-  set(CMAKE_EXPORT_COMPILE_COMMANDS
-      ON
-      CACHE BOOL "Enable output of compile commands during generation." FORCE)
   set(DEBUG 1)
 elseif(CMAKE_BUILD_TYPE STREQUAL Release)
   set(RELEASE 1)
 elseif(CMAKE_BUILD_TYPE STREQUAL None)
   # Режим None используется для статического анализа кода
   set(ANALYSIS 1)
-  set(CMAKE_VERBOSE_MAKEFILE
+  set(CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "Enable verbose build file generation." FORCE)
-      ON
+  set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Enable output of compile commands during generation."
-      CACHE BOOL "Enable verbose build file generation." FORCE)
+                                             FORCE)
-  set(CMAKE_EXPORT_COMPILE_COMMANDS
-      ON
-      CACHE BOOL "Enable output of compile commands during generation." FORCE)
   #  set(USE_CLANG_TIDY ON CACHE BOOL "Use clang-tidy")
   #  set(USE_CPPCHECK ON CACHE BOOL "Use cppcheck")
-  set(USE_PVS_STUDIO
+  set(USE_PVS_STUDIO ON CACHE BOOL "Use PVS-Studio")
-      ON
-      CACHE BOOL "Use PVS-Studio")
 endif()

CMLibCPack.cmake

@@ -0,0 +1,24 @@
+# Общие настройки для пакета: организация, автор, версия
+set(CPACK_PACKAGE_VENDOR ${CMLIB_ORGANIZATION_NAME_LOWER})
+set(CPACK_PACKAGE_NAME ${CMLIB_PROJECT_NAME_LOWER})
+set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
+
+# Параметры для архива исходных текстов
+set(CPACK_SOURCE_GENERATOR TXZ)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
+
+# Параметры для архива собранного проекта
+set(CPACK_TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+  set(CPACK_TARGET_ARCH "amd64")
+endif()
+set(CPACK_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}_${CPACK_TARGET_ARCH}_${CPACK_PACKAGE_VERSION}")
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
+
+set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_CURRENT_LIST_DIR}/CMLibCPackProject.cmake)
+
+# Правила для сборки пакетов для Debian
+include(CMLibCPackDeb)
+
+# Подключение модуля, выполняющего сборку архивов и пакетов
+include(CPack)

CMLibCPackDeb.cmake

@@ -0,0 +1,52 @@
+# По умолчанию пакет собирается для дистрибутива unstable
+if(NOT DEBIAN_PACKAGE_TYPE)
+  set(DEBIAN_PACKAGE_TYPE "unstable")
+endif()
+
+# По умолчанию пакет для Debian делится на компоненты
+if(NOT CPACK_DEB_COMPONENT_INSTALL)
+  set(CPACK_DEB_COMPONENT_INSTALL ON)
+endif()
+
+# Если имя компонента по умолчанию не определено, то устанавливается MAIN
+if(NOT CMAKE_INSTALL_DEFAULT_COMPONENT_NAME)
+  set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME MAIN)
+endif()
+
+# В списке компонентов обязательно должны быть MAIN и DEV
+list(APPEND CPACK_COMPONENTS_ALL MAIN DEV)
+list(REMOVE_DUPLICATES CPACK_COMPONENTS_ALL)
+
+# Правило формирования имени пакета и файла для компонента MAIN
+set(CPACK_DEBIAN_MAIN_PACKAGE_NAME "${CMLIB_PROJECT_NAME_LOWER}")
+set(CPACK_DEBIAN_MAIN_FILE_NAME
+    "${CMLIB_PROJECT_NAME_LOWER}_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}.deb")
+
+# Правило формирования имени пакета и файла для остальных компонентов
+foreach(C ${CPACK_COMPONENTS_ALL})
+  if(NOT "${C}" STREQUAL "MAIN")
+    string(TOLOWER "${C}" cl)
+    set(CPACK_DEBIAN_${C}_PACKAGE_NAME "${CMLIB_PROJECT_NAME_LOWER}-${cl}")
+    set(CPACK_DEBIAN_${C}_FILE_NAME
+        "${CMLIB_PROJECT_NAME_LOWER}-${cl}_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}.deb")
+  endif()
+endforeach()
+
+# Если в каталоге ${CMAKE_SOURCE_DIR}/cmake/deb находятся сценарии сопровождающего
+# postinst, preinst, postrm и prerm, то они будут добавлены к пакету.
+if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/preinst")
+  list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/preinst")
+endif()
+if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/postinst")
+  list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/postinst")
+endif()
+if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/prerm")
+  list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/prerm")
+endif()
+if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/postrm")
+  list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/postrm")
+endif()
+
+if(UNIX AND NOT TARGET deb)
+  add_custom_target(deb WORKING_DIRECTORY ${CMAKE_BINARY_DIR} COMMAND cpack -G DEB)
+endif()

CMLibCPackProject.cmake

@@ -0,0 +1,5 @@
+if(CPACK_GENERATOR MATCHES "DEB")
+  set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/${CPACK_PACKAGE_VENDOR}/${CPACK_PACKAGE_NAME}")
+else()
+  set(CPACK_PACKAGING_INSTALL_PREFIX "${PROJECT_NAME}")
+endif()

CMLibCPackSources.cmake

@@ -1,12 +0,0 @@
-set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
-set(CPACK_SOURCE_GENERATOR TXZ)
-set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
-
-set(CPACK_TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
-if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-  set(CPACK_TARGET_ARCH "amd64")
-endif()
-set(CPACK_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}")
-
-include(CPack)
-add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source)

CMLibCodeAnalysisClangAnalyze.cmake

@@ -1,13 +1,18 @@
-find_program(CLANG_CHECK_EXE NAMES clang-check-10 clang-check-9 clang-check-8 clang-check-7 clang-check-6.0
+find_program(
-                                   clang-check)
+  CLANG_CHECK_EXE
+  NAMES
+    clang-check-10
+    clang-check-9
+    clang-check-8
+    clang-check-7
+    clang-check-6.0
+    clang-check)
 if(CLANG_CHECK_EXE)
   option(CLANG_ANALYZE_FIX "Perform fixes for Clang-Check" OFF)
 endif()
 
-function(add_clang_analyze_check)
+function(add_clang_analyze_check target)
-  list(GET ARGN 0 _target)
   set(_sources ${ARGN})
-  list(REMOVE_AT _sources 0)
 
   if(CLANG_CHECK_EXE)
     if(CLANG_CHECK_FIX)
@@ -17,12 +22,11 @@ function(add_clang_analyze_check)
       add_custom_target(clang-analyze-check)
     endif()
     add_custom_target(
-      clang-analyze-check-${_target}
+      clang-analyze-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
       COMMAND ${CLANG_CHECK_EXE} -analyze -extra-arg="-Wno-unknown-warning-option" -p ${CMAKE_BINARY_DIR}
               ${_sources})
-    add_dependencies(clang-analyze-check-${_target} ${_target})
+    add_dependencies(clang-analyze-check-${target} ${target})
-    add_dependencies(clang-analyze-check clang-analyze-check-${_target})
+    add_dependencies(clang-analyze-check clang-analyze-check-${target})
   else()
     message(STATUS "CMLIB warning:")
     message(STATUS "  Clang-Check analyzer is not found")

CMLibCodeAnalysisClangTidy.cmake

@@ -1,5 +1,12 @@
-find_program(CLANG_TIDY_EXE NAMES clang-tidy-10 clang-tidy-9 clang-tidy-8 clang-tidy-7 clang-tidy-6.0
+find_program(
-                                  clang-tidy)
+  CLANG_TIDY_EXE
+  NAMES
+    clang-tidy-10
+    clang-tidy-9
+    clang-tidy-8
+    clang-tidy-7
+    clang-tidy-6.0
+    clang-tidy)
 if(CLANG_TIDY_EXE)
   option(CLANG_TIDY_FIX "Perform fixes for Clang-Tidy" OFF)
   if(CLANG_TIDY_FIX)
@@ -7,21 +14,18 @@ if(CLANG_TIDY_EXE)
   endif()
 endif()
 
-function(add_clang_tidy_check)
+function(add_clang_tidy_check target)
-  list(GET ARGN 0 _target)
   set(_sources ${ARGN})
-  list(REMOVE_AT _sources 0)
 
   if(CLANG_TIDY_EXE)
     if(NOT TARGET clang-tidy-check)
       add_custom_target(clang-tidy-check)
     endif()
     add_custom_target(
-      clang-tidy-check-${_target}
+      clang-tidy-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
       COMMAND ${CLANG_TIDY_EXE} -extra-arg="-Wno-unknown-warning-option" -p ${CMAKE_BINARY_DIR} ${_sources})
-    add_dependencies(clang-tidy-check-${_target} ${_target})
+    add_dependencies(clang-tidy-check-${target} ${target})
-    add_dependencies(clang-tidy-check clang-tidy-check-${_target})
+    add_dependencies(clang-tidy-check clang-tidy-check-${target})
   else()
     message(STATUS "CMLIB warning:")
     message(STATUS "  ClangTidy analyzer is not found")

CMLibCodeAnalysisClazy.cmake

@@ -2,10 +2,8 @@ set(clazy_checks
     container-inside-loop,heap-allocated-small-trivial-type,inefficient-qlist,isempty-vs-count,qt-keywords,unneeded-cast
 )
 
-function(add_clazy_check)
+function(add_clazy_check target)
-  list(GET ARGN 0 _target)
   set(_sources ${ARGN})
-  list(REMOVE_AT _sources 0)
 
   find_program(CLAZY_EXE NAMES clazy-standalone)
   if(CLAZY_EXE)
@@ -13,12 +11,11 @@ function(add_clazy_check)
       add_custom_target(clazy-check)
     endif()
     add_custom_target(
-      clazy-check-${_target}
+      clazy-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
       COMMAND ${CLAZY_EXE} -checks=level2,${clazy_checks} -extra-arg="-Wno-unknown-warning-option" -p
               ${CMAKE_BINARY_DIR} ${_sources})
-    add_dependencies(clazy-check-${_target} ${_target})
+    add_dependencies(clazy-check-${target} ${target})
-    add_dependencies(clazy-check clazy-check-${_target})
+    add_dependencies(clazy-check clazy-check-${target})
   else()
     message(STATUS "CMLIB warning:")
     message(STATUS "  Clazy analyzer is not found")

CMLibCodeAnalysisPvsStudio.cmake

@@ -1,6 +1,4 @@
-function(add_pvs_check)
+function(add_pvs_check target)
-  list(GET ARGN 0 _target)
-
   if(CMAKE_EXPORT_COMPILE_COMMANDS)
     include(PVS-Studio)
     find_program(PVS_STUDIO_ANALYZER_EXE NAMES pvs-studio-analyzer)
@@ -9,14 +7,14 @@ function(add_pvs_check)
         add_custom_target(pvs-check)
       endif()
       pvs_studio_add_target(
-        TARGET pvs-check-${_target}
+        TARGET pvs-check-${target}
-        DEPENDS ${_target}
+        DEPENDS ${target}
         COMPILE_COMMANDS HIDE_HELP OUTPUT
         FORMAT errorfile
-        CONFIG "${CMAKE_BINARY_DIR}/PVS-Studio-${_target}.cfg"
+        CONFIG "${CMAKE_BINARY_DIR}/PVS-Studio-${target}.cfg"
-        ARGS --analysis-mode 29 --exclude-path ${CMAKE_CURRENT_BINARY_DIR}/${_target}_autogen
+        ARGS --analysis-mode 29 --exclude-path ${CMAKE_CURRENT_BINARY_DIR}/${target}_autogen
         MODE GA:1,2,3;64:1;OP:1,2;CS:1,2)
-      add_dependencies(pvs-check pvs-check-${_target})
+      add_dependencies(pvs-check pvs-check-${target})
     else()
       message(STATUS "CMLIB warning:")
       message(STATUS "  PVS-Studio analyzer is not found")

CMLibCodeCoverage.cmake

@@ -2,30 +2,26 @@ option(ENABLE_CODE_COVERAGE "Enable code coverage support" OFF)
 find_program(LCOV_EXE NAMES lcov)
 find_program(GENHTML_EXE NAMES genhtml)
 
-function(add_code_coverage)
+function(add_code_coverage target)
-  list(GET ARGN 0 _target)
 
   if(ENABLE_CODE_COVERAGE)
     if(CMAKE_CXX_COMPILER_IS_GCC)
-      target_compile_options(${_target} PUBLIC "--coverage")
+      target_compile_options(${target} PUBLIC "--coverage")
-      get_target_property(LF ${_target} LINK_FLAGS)
+      get_target_property(LF ${target} LINK_FLAGS)
       string(APPEND LF " --coverage")
-      set_target_properties(${_target} PROPERTIES LINK_FLAGS ${LF})
+      set_target_properties(${target} PROPERTIES LINK_FLAGS ${LF})
 
       if(LCOV_EXE)
         add_custom_target(
-          coverage-${_target}
+          coverage-${target} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-          WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+          COMMAND ${LCOV_EXE} --test-name ${target} --output "${target}.lcov" --capture --directory
-          COMMAND ${LCOV_EXE} --test-name ${_target} --output "${_target}.lcov" --capture --directory
                   ${CMAKE_BINARY_DIR})
-        add_dependencies(coverage-${_target} ${_target})
+        add_dependencies(coverage-${target} ${target})
 
         if(GENHTML_EXE)
-          add_custom_target(
+          add_custom_target(coverage-report-${target} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-            coverage-report-${_target}
+                            COMMAND ${GENHTML_EXE} --output-directory "report-${target}" "${target}.lcov")
-            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+          add_dependencies(coverage-report-${target} coverage-${target})
-            COMMAND ${GENHTML_EXE} --output-directory "report-${_target}" "${_target}.lcov")
-          add_dependencies(coverage-report-${_target} coverage-${_target})
         endif()
       endif()
     else()

CMLibCommon.cmake

@@ -45,5 +45,5 @@ include(CMLibQtTranslation)
 include(CMLibToday)
 include(CMLibAuxilarySymlinks)
 include(CMLibConfigHPPGenerate)
-include(CMLibCPackSources)
+include(CMLibCPack)
 include(CMLibUninstall)

CMLibCommonLibraryTarget.cmake

@@ -1,41 +1,40 @@
 # Создание статической и динамической библиотеки из одинаковых объектных файлов
-function(add_common_library)
+function(add_common_library target)
   set(options)
-  set(oneValueArgs TARGET OUTPUT_NAME)
+  set(oneValueArgs OUTPUT_NAME)
   set(multiValueArgs SOURCES)
 
   cmake_parse_arguments(_LOCAL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-  set(LIBNAME ${_LOCAL_TARGET})
   set(SOURCES ${_LOCAL_SOURCES})
 
   if(_LOCAL_OUTPUT_NAME)
     set(OUTNAME ${_LOCAL_OUTPUT_NAME})
   else()
-    set(OUTNAME ${LIBNAME})
+    set(OUTNAME ${target})
   endif()
 
-  add_library(${LIBNAME} OBJECT ${SOURCES})
+  add_library(${target} OBJECT ${SOURCES})
   target_include_directories(
-    ${LIBNAME} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    ${target} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-                      $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include> $<INSTALL_INTERFACE:include/${LIBNAME}>)
+                     $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include> $<INSTALL_INTERFACE:include/${target}>)
-  set_target_properties(${LIBNAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+  set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
   if(BUILD_SHARED_LIBS)
-    add_library(${LIBNAME}_shared SHARED $<TARGET_OBJECTS:${LIBNAME}>)
+    add_library(${target}_shared SHARED $<TARGET_OBJECTS:${target}>)
     set_target_properties(
-      ${LIBNAME}_shared
+      ${target}_shared
       PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} OUTPUT_NAME ${OUTNAME}
                  LIBRARY_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR})
-    install(TARGETS ${LIBNAME}_shared LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install(TARGETS ${target}_shared LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
   endif()
 
   if(NOT SKIP_STATIC_LIBS)
-    add_library(${LIBNAME}_static STATIC $<TARGET_OBJECTS:${LIBNAME}>)
+    add_library(${target}_static STATIC $<TARGET_OBJECTS:${target}>)
-    set_target_properties(${LIBNAME}_static PROPERTIES OUTPUT_NAME ${OUTNAME} ARCHIVE_OUTPUT_DIRECTORY
+    set_target_properties(${target}_static PROPERTIES OUTPUT_NAME ${OUTNAME} ARCHIVE_OUTPUT_DIRECTORY
                                                                               ${CMAKE_INSTALL_LIBDIR})
-    install(TARGETS ${LIBNAME}_static ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install(TARGETS ${target}_static ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
   endif()
 
-  configure_file(${CMLIB_MODULE_DIR}/pc/lib.pc.in ${CMAKE_BINARY_DIR}/${LIBNAME}.pc)
+  configure_file(${CMLIB_MODULE_DIR}/pc/lib.pc.in ${CMAKE_BINARY_DIR}/${target}.pc)
-  install(FILES ${CMAKE_BINARY_DIR}/${LIBNAME}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+  install(FILES ${CMAKE_BINARY_DIR}/${target}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 endfunction()

CMLibCommonTargetProperties.cmake

@@ -1,74 +1,70 @@
 set(COMMON_CXX_FEATURES cxx_alias_templates cxx_nullptr cxx_override)
 
-function(common_target_properties Name)
+function(common_target_properties target)
-  get_target_property(__type ${Name} TYPE)
+  get_target_property(__type ${target} TYPE)
   set(__visibility PUBLIC)
   if(__type STREQUAL INTERFACE_LIBRARY)
     set(__interface 1)
     set(__visibility INTERFACE)
   endif()
-  target_compile_features(
+
-    ${Name}
+  get_target_property(__sources ${target} SOURCES)
-    ${__visibility}
+  foreach(__src IN LISTS __sources)
-    ${COMMON_CXX_FEATURES})
+    string(REGEX MATCH ".*/qrc_.*\\.cpp$" __qrc ${__src})
-  get_target_property(_targetType ${Name} TYPE)
+    if (__qrc)
+      set_property(SOURCE ${__qrc} PROPERTY COTIRE_EXCLUDED ON)
+    endif()
+  endforeach()
+
+  target_compile_features(${target} ${__visibility} ${COMMON_CXX_FEATURES})
+  get_target_property(_targetType ${target} TYPE)
   if(_targetType STREQUAL "EXECUTABLE" AND CMAKE_CXX_COMPILE_OPTIONS_PIE)
-    target_compile_options(${Name} PUBLIC "${CMAKE_CXX_COMPILE_OPTIONS_PIE}")
+    target_compile_options(${target} PUBLIC "${CMAKE_CXX_COMPILE_OPTIONS_PIE}")
   endif()
   target_include_directories(
-    ${Name}
+    ${target}
     PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}> $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>)
   if(APPLE)
-    target_compile_definitions(
+    target_compile_definitions(${target} ${__visibility} Darwin)
-      ${Name}
-      ${__visibility}
-      Darwin)
   endif()
   if(NOT __interface)
     if(TARGET Qt5::Core)
       if(_targetType STREQUAL "EXECUTABLE")
-        target_compile_options(${Name} PUBLIC "${Qt5Core_EXECUTABLE_COMPILE_FLAGS}")
+        target_compile_options(${target} PUBLIC "${Qt5Core_EXECUTABLE_COMPILE_FLAGS}")
       endif()
-      set_target_properties(${Name} PROPERTIES AUTOMOC TRUE AUTORCC TRUE)
+      # set_target_properties(${target} PROPERTIES AUTOMOC TRUE)
+      # set_target_properties(${target} PROPERTIES AUTORCC TRUE)
     endif()
     if(TARGET Qt5::Widgets)
-      set_target_properties(${Name} PROPERTIES AUTOUIC TRUE)
+      # set_target_properties(${target} PROPERTIES AUTOUIC TRUE)
       #      if(CMAKE_VERSION VERSION_LESS 3.7.99)
       #        target_include_directories(
-      #          ${Name}
+      #          ${target}
       #          PUBLIC
-      #          $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/${Name}_autogen/include>
+      #          $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/${target}_autogen/include>
       #          )
       #      endif()
     endif()
     if(CMAKE_CXX_COMPILER_IS_GCC AND NOT APPLE)
-      set_target_properties(${Name} PROPERTIES LINK_FLAGS "-Wl,--no-as-needed")
+      set_target_properties(${target} PROPERTIES LINK_FLAGS "-Wl,--no-as-needed")
     endif()
   endif()
 
   # LTO only for executables (not libraries) in Release build type
-  get_target_property(target_type ${Name} TYPE)
+  get_target_property(target_type ${target} TYPE)
   if(target_type STREQUAL "EXECUTABLE" AND CMAKE_BUILD_TYPE STREQUAL "Release")
     check_cxx_compiler_flag(-flto CXX_HAS_LTO_FLAG)
     check_cxx_compiler_flag(-fno-fat-lto-objects CXX_HAS_NO_FAT_LTO_FLAG)
     if(CMAKE_CXX_COMPILER_IS_GCC AND CXX_HAS_LTO_FLAG)
+      find_program(CMAKE_GCC_AR NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar${_CMAKE_TOOLCHAIN_SUFFIX}"
+                                      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar" HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+      find_program(CMAKE_GCC_NM NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm${_CMAKE_TOOLCHAIN_SUFFIX}"
+                                      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm" HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
       find_program(
-        CMAKE_GCC_AR
+        CMAKE_GCC_RANLIB NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib${_CMAKE_TOOLCHAIN_SUFFIX}"
-        NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar${_CMAKE_TOOLCHAIN_SUFFIX}" "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar"
+                               "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib" HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-        HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+      if(CMAKE_GCC_AR AND CMAKE_GCC_NM AND CMAKE_GCC_RANLIB)
-      find_program(
-        CMAKE_GCC_NM
-        NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm${_CMAKE_TOOLCHAIN_SUFFIX}" "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm"
-        HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-      find_program(
-        CMAKE_GCC_RANLIB
-        NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib${_CMAKE_TOOLCHAIN_SUFFIX}"
-              "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib"
-        HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-      if(CMAKE_GCC_AR
-         AND CMAKE_GCC_NM
-         AND CMAKE_GCC_RANLIB)
         set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto")
         if(CXX_HAS_NO_FAT_LTO_FLAG)
           set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-fat-lto-objects")
@@ -86,28 +82,16 @@ function(common_target_properties Name)
   endif()
 
   if(CMAKE_BUILD_TYPE STREQUAL Profile)
-    target_compile_definitions(
+    target_compile_definitions(${target} ${__visibility} PROFILE)
-      ${Name}
-      ${__visibility}
-      PROFILE)
   elseif(CMAKE_BUILD_TYPE STREQUAL Debug)
-    target_compile_definitions(
+    target_compile_definitions(${target} ${__visibility} DEBUG)
-      ${Name}
-      ${__visibility}
-      DEBUG)
   elseif(CMAKE_BUILD_TYPE STREQUAL Release)
-    target_compile_definitions(
+    target_compile_definitions(${target} ${__visibility} RELEASE)
-      ${Name}
-      ${__visibility}
-      RELEASE)
   elseif(CMAKE_BUILD_TYPE STREQUAL None)
-    target_compile_definitions(
+    target_compile_definitions(${target} ${__visibility} ANALYSIS)
-      ${Name}
-      ${__visibility}
-      ANALYSIS)
   endif()
   target_compile_definitions(
-    ${Name}
+    ${target}
     ${__visibility}
     "TARGET_LSB_ID_${LSB_DISTRIBUTOR_ID}"
     "TARGET_LSB_CODENAME_${LSB_CODENAME}")

CMLibCompilerFlags.cmake

@@ -17,9 +17,8 @@ macro(CHECK_ENABLE_CXX_FLAG flag)
   unset(CHECK_CXX_FLAG CACHE)
 endmacro()
 
-if(LSB_DISTRIBUTOR_ID STREQUAL "AstraLinuxSE"
+if(LSB_DISTRIBUTOR_ID STREQUAL "AstraLinuxSE" AND LSB_CODENAME STREQUAL "smolensk" AND LSB_RELEASE STREQUAL
-   AND LSB_CODENAME STREQUAL "smolensk"
+                                                                                       "1.5")
-   AND LSB_RELEASE STREQUAL "1.5")
   set(_CMAKE_TOOLCHAIN_PREFIX "x86_64-linux-gnu-")
   set(_CMAKE_TOOLCHAIN_SUFFIX "-4.7")
   set(_CMAKE_TOOLCHAIN_LOCATION} "/usr/bin")
@@ -31,9 +30,7 @@ else()
 endif()
 
 # Common configuration for GCC, clang and Intel.
-if(CMAKE_CXX_COMPILER_IS_CLANG
+if(CMAKE_CXX_COMPILER_IS_CLANG OR CMAKE_CXX_COMPILER_IS_INTEL OR CMAKE_CXX_COMPILER_IS_GCC)
-   OR CMAKE_CXX_COMPILER_IS_INTEL
-   OR CMAKE_CXX_COMPILER_IS_GCC)
   set(CMAKE_CXX_STANDARD 11)
   set(CMAKE_CXX_STANDARD_REQUIRED YES)
   set(CMAKE_CXX_EXTENSIONS YES)

CMLibDisableInSourceBuild.cmake

@@ -13,10 +13,7 @@ if(${_source_realpath} STREQUAL ${_binary_realpath})
 endif()
 
 # Очистка от сгенерированных файлов
-file(
+file(GLOB_RECURSE _cmakelists_files RELATIVE ${_source_realpath} CMakeLists.txt)
-  GLOB_RECURSE _cmakelists_files
-  RELATIVE ${_source_realpath}
-  CMakeLists.txt)
 foreach(_it ${_cmakelists_files})
   get_filename_component(_file ${_it} REALPATH)
   get_filename_component(_dir ${_file} DIRECTORY)

CMLibDistCC.cmake

@@ -4,9 +4,7 @@ if(DISTCC_EXECUTABLE)
   foreach(LANG C CXX)
     if(NOT DEFINED CMAKE_${LANG}_COMPILER_LAUNCHER AND NOT CMAKE_${LANG}_COMPILER MATCHES ".*/distcc$")
       message(STATUS "Enabling distcc for ${LANG}")
-      set(CMAKE_${LANG}_COMPILER_LAUNCHER
+      set(CMAKE_${LANG}_COMPILER_LAUNCHER ${DISTCC_EXECUTABLE} CACHE STRING "")
-          ${DISTCC_EXECUTABLE}
-          CACHE STRING "")
     endif()
   endforeach()
 endif()

CMLibDocBreathe.cmake

@@ -1,11 +1,9 @@
-set(BREATHE_FOUND
+set(BREATHE_FOUND AUTO CACHE STRING "Enable Breathe documentation generator")
-    AUTO
-    CACHE STRING "Enable Breathe documentation generator")
 set_property(CACHE BREATHE_FOUND PROPERTY STRINGS ON OFF AUTO)
 
 find_package(Doxygen)
 find_package(Perl)
-set(Python_ADDITIONAL_VERSIONS 3.7 3.6 3.5 3.4 3.3 3.2)
+set(Python_ADDITIONAL_VERSIONS 3.8;3.7;3.6;3.5;3.4;3.3;3.2)
 find_package(PythonInterp)
 if(PYTHONINTERP_FOUND)
   find_package(Sphinx)
@@ -18,23 +16,17 @@ if(PYTHONINTERP_FOUND)
      AND SPHINX_EXECUTABLE
      AND breathe
      AND recommonmark)
-    set(BREATHE_FOUND
+    set(BREATHE_FOUND ON CACHE STRING "Breathe documentation generator enabled" FORCE)
-        ON
-        CACHE STRING "Breathe documentation generator enabled" FORCE)
   else()
-    set(BREATHE_FOUND
+    set(BREATHE_FOUND OFF CACHE STRING "Breathe documentation generator disabled" FORCE)
-        OFF
-        CACHE STRING "Breathe documentation generator disabled" FORCE)
   endif()
 else()
-  set(BREATHE_FOUND
+  set(BREATHE_FOUND OFF CACHE STRING "Breathe documentation generator disabled" FORCE)
-      OFF
-      CACHE STRING "Breathe documentation generator disabled" FORCE)
 endif()
 
-function(add_breathe_target)
+function(add_breathe target)
   set(options)
-  set(oneValueArgs TARGET_NAME COMMENT)
+  set(oneValueArgs COMMENT)
   set(multiValueArgs)
 
   cmake_parse_arguments(_BREATHE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
@@ -44,7 +36,6 @@ function(add_breathe_target)
     set(GENERATE_XML YES)
     set(GENERATE_HTML NO)
     set(GENERATE_LATEX NO)
-    set(GENERATE_SQLITE NO)
     set(CONF_FILE ${CMAKE_SOURCE_DIR}/cmake/doc/breathe-conf.py.in)
     set(DOXY_FILE ${CMAKE_SOURCE_DIR}/cmake/doc/Doxyfile.in)
 
@@ -52,21 +43,19 @@ function(add_breathe_target)
     configure_file(${DOXY_FILE} ${WORK_DIR}/Doxyfile @ONLY)
 
     add_custom_target(
-      ${_BREATHE_TARGET_NAME}
+      ${target}
       VERBATIM
       COMMAND ${SPHINX_EXECUTABLE} -q -b html -c ${WORK_DIR} -d ${WORK_DIR}/cache ${WORK_DIR}
               ${CMAKE_BINARY_DIR}/doc/breathe
-      COMMENT "Building ${_BREATHE_TARGET_NAME} documentation with Breathe")
+      COMMENT "Building ${target} documentation with Breathe")
 
     set(INDEX_MD_FILE ${CMAKE_SOURCE_DIR}/doc/breathe/index.md.in)
     if(EXISTS ${INDEX_MD_FILE})
       configure_file(${INDEX_MD_FILE} ${WORK_DIR}/index.md @ONLY)
       file(GLOB MD_FILES ${CMAKE_SOURCE_DIR}/doc/breathe/*.md)
       if(MD_FILES)
-        add_custom_command(
+        add_custom_command(TARGET ${target} PRE_BUILD
-          TARGET ${_BREATHE_TARGET_NAME}
+                           COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MD_FILES} ${WORK_DIR})
-          PRE_BUILD
-          COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MD_FILES} ${WORK_DIR})
       endif()
     endif()
 
@@ -75,16 +64,13 @@ function(add_breathe_target)
       configure_file(${INDEX_RST_FILE} ${WORK_DIR}/index.rst @ONLY)
       file(GLOB RST_FILES ${CMAKE_SOURCE_DIR}/doc/breathe/*.rst)
       if(RST_FILES)
-        add_custom_command(
+        add_custom_command(TARGET ${target} PRE_BUILD
-          TARGET ${_BREATHE_TARGET_NAME}
+                           COMMAND ${CMAKE_COMMAND} -E copy_if_different ${RST_FILES} ${WORK_DIR})
-          PRE_BUILD
-          COMMAND ${CMAKE_COMMAND} -E copy_if_different ${RST_FILES} ${WORK_DIR})
       endif()
     endif()
   else()
-    add_custom_target(
+    message(STATUS "CMLIB warning:")
-      ${_BREATHE_TARGET_NAME}
+    add_custom_target(${target} VERBATIM
-      VERBATIM
+                      COMMENT "  Breathe is not found. Skipping target ${target} build")
-      COMMENT "Breathe is not found. Skipping target ${_BREATHE_TARGET_NAME} build")
   endif()
 endfunction()

CMLibDocDoxygen.cmake

@@ -1,54 +1,43 @@
-set(DOXYGEN_FOUND
+set(DOXYGEN_FOUND AUTO CACHE STRING "Enable Doxygen documentation generator")
-    AUTO
-    CACHE STRING "Enable Doxygen documentation generator")
 set_property(CACHE DOXYGEN_FOUND PROPERTY STRINGS ON OFF AUTO)
 
 find_package(Doxygen)
 if(DOXYGEN_FOUND)
-  set(DOXYGEN_FOUND
+  set(DOXYGEN_FOUND ON CACHE STRING "Doxygen documentation generator enabled" FORCE)
-      ON
-      CACHE STRING "Doxygen documentation generator enabled" FORCE)
 else()
-  set(DOXYGEN_FOUND
+  set(DOXYGEN_FOUND OFF CACHE STRING "Doxygen documentation generator disabled" FORCE)
-      OFF
-      CACHE STRING "Doxygen documentation generator disabled" FORCE)
 endif()
 
-function(add_doxygen_target)
+function(add_doxygen target)
   set(options)
-  set(oneValueArgs TARGET_NAME SQLITE LATEX HTML)
+  set(oneValueArgs SQLITE LATEX HTML)
   set(multiValueArgs)
 
   cmake_parse_arguments(_DOXYGEN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
   if(DOXYGEN_FOUND)
-    set(GENERATE_XML NO)
+    set(GENERATE_XML YES)
     set(GENERATE_HTML NO)
     set(GENERATE_LATEX NO)
-    set(GENERATE_SQLITE YES)
     if(_DOXYGEN_HTML)
       set(GENERATE_HTML YES)
     endif()
     if(_DOXYGEN_LATEX)
       set(GENERATE_LATEX YES)
     endif()
-    if(_DOXYGEN_SQLITE)
-      set(GENERATE_SQLITE YES)
-    endif()
 
     set(WORK_DIR ${CMAKE_BINARY_DIR}/doc/doxygen)
     configure_file(${CMAKE_SOURCE_DIR}/cmake/doc/Doxyfile.in ${WORK_DIR}/Doxyfile @ONLY)
 
     add_custom_target(
-      ${_DOXYGEN_TARGET_NAME}
+      ${target}
       VERBATIM
       COMMAND "${CMAKE_COMMAND}" -E remove -f "${WORK_DIR}/doxygen_sqlite3.db"
       COMMAND ${DOXYGEN_EXECUTABLE} ${WORK_DIR}/Doxyfile
       WORKING_DIRECTORY ${WORK_DIR}
       COMMENT "Generating API documentation with Doxygen")
   else()
-    add_custom_target(
+    message(STATUS "CMLIB warning:")
-      ${_DOXYGEN_TARGET_NAME}
+    add_custom_target(${target} VERBATIM
-      VERBATIM
+                      COMMENT "  Doxygen is not found. Skipping target ${target} build")
-      COMMENT "Doxygen is not found. Skipping target ${_DOXYGEN_TARGET_NAME} build")
   endif()
 endfunction()

CMLibFlagRemove.cmake

@@ -35,9 +35,7 @@ macro(remove_flag_from_file _target _file _flag)
   if(NOT _cached_${_target}_cxx_flags)
     # Obtain and cache the target compiler options, then clear them.
     get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS)
-    set(_cached_${_target}_cxx_flags
+    set(_cached_${_target}_cxx_flags "${_target_cxx_flags}" CACHE INTERNAL "")
-        "${_target_cxx_flags}"
-        CACHE INTERNAL "")
     set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "")
     # Apply the target compile flags to each source file.
     foreach(_source_file ${_target_sources})
@@ -61,9 +59,7 @@ macro(remove_flag_from_file _target _file _flag)
       # This is the list that we'll be removing flags from.
       get_source_file_property(_source_file_cxx_flags ${_file} COMPILE_FLAGS)
       separate_arguments(_source_file_cxx_flags UNIX_COMMAND ${_source_file_cxx_flags})
-      set(_cached_${_target}_${_file}_cxx_flags
+      set(_cached_${_target}_${_file}_cxx_flags ${_source_file_cxx_flags} CACHE INTERNAL "")
-          ${_source_file_cxx_flags}
-          CACHE INTERNAL "")
     endif()
     # Remove the specified flag, then re-apply the rest.
     list(REMOVE_ITEM _cached_${_target}_${_file}_cxx_flags ${_flag})

CMLibFormatSources.cmake

@@ -1,7 +1,5 @@
-function(add_format_sources)
+function(add_format_sources target)
-  list(GET ARGN 0 _target)
   set(_sources ${ARGN})
-  list(REMOVE_AT _sources 0)
 
   if(NOT TARGET format-sources)
     add_custom_target(format-sources)
@@ -9,13 +7,19 @@ function(add_format_sources)
 
   find_program(UNCRUSTIFY_EXE NAMES uncrustify)
   if(UNCRUSTIFY_EXE)
-    list(APPEND UNCRUSTIFY_OPTS -lCPP --replace --no-backup --mtime)
+    list(
+      APPEND
+      UNCRUSTIFY_OPTS
+      -lCPP
+      --replace
+      --no-backup
+      --mtime)
     if(EXISTS ${CMAKE_SOURCE_DIR}/cmake/etc/uncrustify/default.cfg)
       list(APPEND UNCRUSTIFY_OPTS -c ${CMAKE_SOURCE_DIR}/cmake/etc/uncrustify/default.cfg)
     endif()
-    add_custom_target(format-sources-uncrustify-${_target} COMMAND ${UNCRUSTIFY_EXE} ${UNCRUSTIFY_OPTS}
+    add_custom_target(format-sources-uncrustify-${target} COMMAND ${UNCRUSTIFY_EXE} ${UNCRUSTIFY_OPTS}
                                                                    ${_sources})
-    add_dependencies(format-sources format-sources-uncrustify-${_target})
+    add_dependencies(format-sources format-sources-uncrustify-${target})
   else()
     message(STATUS "CMLIB warning:")
     message(STATUS "  uncrustify executable is not found")
@@ -24,8 +28,8 @@ function(add_format_sources)
   find_program(DOS2UNIX_EXE NAMES dos2unix)
   if(DOS2UNIX_EXE)
     list(APPEND DOS2UNIX_OPTS -k -r)
-    add_custom_target(format-sources-dos2unix-${_target} COMMAND ${DOS2UNIX_EXE} ${DOS2UNIX_OPTS} ${_sources})
+    add_custom_target(format-sources-dos2unix-${target} COMMAND ${DOS2UNIX_EXE} ${DOS2UNIX_OPTS} ${_sources})
-    add_dependencies(format-sources format-sources-dos2unix-${_target})
+    add_dependencies(format-sources format-sources-dos2unix-${target})
   else()
     message(STATUS "CMLIB warning:")
     message(STATUS "  dos2unix executable is not found")

CMLibGlobalFunctions.cmake

@@ -1,7 +1,5 @@
 function(canonical_string INV OUTV)
   string(TOUPPER ${INV} _arg_uppercase)
   string(REGEX REPLACE "[ -]" "_" _arg_fixed ${_arg_uppercase})
-  set(${OUTV}
+  set(${OUTV} ${_arg_fixed} PARENT_SCOPE)
-      ${_arg_fixed}
-      PARENT_SCOPE)
 endfunction()

CMLibLSBInfo.cmake

@@ -13,10 +13,7 @@ set(LSB_RELEASE "unknown")
 if(EXISTS /etc/mcst_version)
   set(LSB_DISTRIBUTOR_ID "ElbrusD")
   set(LSB_CODENAME "Jessie")
-  execute_process(
+  execute_process(COMMAND cat /etc/mcst_version OUTPUT_VARIABLE LSB_RELEASE OUTPUT_STRIP_TRAILING_WHITESPACE)
-    COMMAND cat /etc/mcst_version
-    OUTPUT_VARIABLE LSB_RELEASE
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
 else()
   find_program(_lsb_release_executable lsb_release)
   if(_lsb_release_executable)

CMLibLargeFiles.cmake

@@ -72,9 +72,7 @@ macro(cmlib_test_large_files VARIABLE)
                   COMPILE_DEFINITIONS "-D_FILE_OFFSET_BITS=64")
       if(FILE64_OK)
         message(STATUS "Checking for 64-bit off_t - present with _FILE_OFFSET_BITS=64")
-        set(_FILE_OFFSET_BITS
+        set(_FILE_OFFSET_BITS 64 CACHE INTERNAL "64-bit off_t requires _FILE_OFFSET_BITS=64")
-            64
-            CACHE INTERNAL "64-bit off_t requires _FILE_OFFSET_BITS=64")
       endif()
     endif()
 
@@ -84,9 +82,7 @@ macro(cmlib_test_large_files VARIABLE)
                   COMPILE_DEFINITIONS "-D_LARGE_FILES")
       if(FILE64_OK)
         message(STATUS "Checking for 64-bit off_t - present with _LARGE_FILES")
-        set(_LARGE_FILES
+        set(_LARGE_FILES 1 CACHE INTERNAL "64-bit off_t requires _LARGE_FILES")
-            1
-            CACHE INTERNAL "64-bit off_t requires _LARGE_FILES")
       endif()
     endif()
 
@@ -96,9 +92,7 @@ macro(cmlib_test_large_files VARIABLE)
                   COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE")
       if(FILE64_OK)
         message(STATUS "Checking for 64-bit off_t - present with _LARGEFILE_SOURCE")
-        set(_LARGEFILE_SOURCE
+        set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit off_t requires _LARGEFILE_SOURCE")
-            1
-            CACHE INTERNAL "64-bit off_t requires _LARGEFILE_SOURCE")
       endif()
     endif()
 
@@ -127,9 +121,7 @@ macro(cmlib_test_large_files VARIABLE)
           COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE")
         if(FSEEKO_COMPILE_OK)
           message(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
-          set(_LARGEFILE_SOURCE
+          set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit fseeko requires _LARGEFILE_SOURCE")
-              1
-              CACHE INTERNAL "64-bit fseeko requires _LARGEFILE_SOURCE")
         else()
           set(FILE64_OK 0)
           message(STATUS "64-bit off_t present but fseeko/ftello not found!")
@@ -142,32 +134,20 @@ macro(cmlib_test_large_files VARIABLE)
       try_compile(FILE64_OK "${CMAKE_BINARY_DIR}" "${CMLIB_MODULE_DIR}/tests/TestWindowsFSeek.c")
       if(FILE64_OK)
         message(STATUS "Checking for 64-bit off_t - present with _fseeki64")
-        set(HAVE__FSEEKI64
+        set(HAVE__FSEEKI64 1 CACHE INTERNAL "64-bit off_t requires _fseeki64")
-            1
-            CACHE INTERNAL "64-bit off_t requires _fseeki64")
       endif()
     endif()
 
     if(FSEEKO_COMPILE_OK)
-      set(${VARIABLE}
+      set(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
-          1
+      set(HAVE_FSEEKO 1 CACHE INTERNAL "64bit fseeko is available" FORCE)
-          CACHE INTERNAL "Result of test for large file support" FORCE)
-      set(HAVE_FSEEKO
-          1
-          CACHE INTERNAL "64bit fseeko is available" FORCE)
     elseif(HAVE__FSEEKI64)
-      set(${VARIABLE}
+      set(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
-          1
+      set(HAVE__FSEEKI64 1 CACHE INTERNAL "Windows 64-bit fseek" FORCE)
-          CACHE INTERNAL "Result of test for large file support" FORCE)
-      set(HAVE__FSEEKI64
-          1
-          CACHE INTERNAL "Windows 64-bit fseek" FORCE)
     else()
       check_type_size("long int" SIZEOF_LONG_INT)
       if(SIZEOF_LONG_INT EQUAL 8) #standard fseek is OK for 64bit
-        set(${VARIABLE}
+        set(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
-            1
-            CACHE INTERNAL "Result of test for large file support" FORCE)
       else()
         message(FATAL_ERROR "Checking for 64bit file support failed.")
       endif()

CMLibQtTranslation.cmake

@@ -1,55 +1,51 @@
-function(qt5_translation)
+function(qt5_translation outfiles)
-  find_package(
+  find_package(Qt5 COMPONENTS LinguistTools REQUIRED)
-    Qt5
-    COMPONENTS LinguistTools
-    REQUIRED)
 
   set(options)
-  set(oneValueArgs TARGET TS_DIR)
+  set(oneValueArgs BASE_NAME OUTPUT_DIR)
   set(multiValueArgs SOURCES LANGUAGES)
 
   cmake_parse_arguments(_QTTR "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-  set(_target ${_QTTR_TARGET})
+  set(_base_name ${_QTTR_BASE_NAME})
   set(_sources ${_QTTR_SOURCES})
-  set(_ts_dir ${_QTTR_TS_DIR})
+  set(_output_dir ${_QTTR_OUTPUT_DIR})
   set(_languages ${_QTTR_LANGUAGES})
 
   set(L10N_QRC_BODY "")
-  make_directory(${_ts_dir})
+  make_directory(${_output_dir})
 
   foreach(_lang ${_languages})
-    set(_ts "${_target}_${_lang}.ts")
+    set(_ts "${_base_name}_${_lang}.ts")
-    set(_qm "${_target}_${_lang}.qm")
+    set(_qm "${_base_name}_${_lang}.qm")
-    list(APPEND _ts_list ${_ts_dir}/${_ts})
+    list(APPEND _ts_list ${_output_dir}/${_ts})
-    list(APPEND _l10n_targets "${_target}_l10n_${_lang}")
+    list(APPEND _l10n_names "${_base_name}_l10n_${_lang}")
     string(APPEND L10N_QRC_BODY "<file alias=\"${_qm}\">${CMAKE_BINARY_DIR}/${_qm}</file>\n")
 
     add_custom_target(
-      ${_target}_l10n_${_lang}
+      ${_base_name}_l10n_${_lang} COMMAND ${Qt5_LUPDATE_EXECUTABLE} ${_sources} -ts ${_output_dir}/${_ts}
-      COMMAND ${Qt5_LUPDATE_EXECUTABLE} ${_sources} -ts ${_ts_dir}/${_ts} -target-language ${_lang}
+                                       -target-language ${_lang} DEPENDS ${_sources})
-      DEPENDS ${_sources})
 
-    if(NOT EXISTS "${_ts_dir}/${_ts}")
+    if(NOT EXISTS "${_output_dir}/${_ts}")
-      add_custom_target(${_ts} DEPENDS ${_target}_l10n_${_lang})
+      add_custom_target(${_ts} DEPENDS ${_base_name}_l10n_${_lang})
     else()
       add_custom_target(${_ts} COMMAND echo "Skipping lupdate for ${_ts}")
     endif()
 
     add_custom_command(
-      OUTPUT ${CMAKE_BINARY_DIR}/${_qm}
+      OUTPUT ${CMAKE_BINARY_DIR}/${_qm} COMMAND ${Qt5_LRELEASE_EXECUTABLE} ARGS ${_output_dir}/${_ts} -qm
-      COMMAND ${Qt5_LRELEASE_EXECUTABLE} ARGS ${_ts_dir}/${_ts} -qm ${CMAKE_BINARY_DIR}/${_qm}
+                                                ${CMAKE_BINARY_DIR}/${_qm} DEPENDS ${_ts} ${_sources})
-      DEPENDS ${_ts} ${_sources})
   endforeach()
 
-  configure_file(${CMLIB_MODULE_DIR}/qrc/l10n.qrc.in ${CMAKE_BINARY_DIR}/${_target}_l10n.qrc)
+  configure_file(${CMLIB_MODULE_DIR}/qrc/l10n.qrc.in ${CMAKE_BINARY_DIR}/${_base_name}_l10n.qrc)
-  qt5_add_resources(_qrc ${CMAKE_BINARY_DIR}/${_target}_l10n.qrc)
+  qt5_add_resources(${outfiles} ${CMAKE_BINARY_DIR}/${_base_name}_l10n.qrc)
-  add_custom_target(${_target}_qrc DEPENDS ${_qrc})
+  add_custom_target(${_base_name}_qrc DEPENDS ${_qrc})
-  add_custom_target(${_target}_l10n DEPENDS ${_l10n_targets})
+  add_custom_target(${_base_name}_l10n DEPENDS ${_l10n_targets})
   if(NOT TARGET l10n)
     add_custom_target(l10n)
   endif()
-  add_dependencies(l10n ${_target}_l10n)
+  add_dependencies(l10n ${_base_name}_l10n)
 
-  add_dependencies(${_target} ${_target}_qrc)
+  # add_dependencies(${_target} ${_target}_qrc)
-  target_sources(${_target} PUBLIC ${_qrc})
+  # target_sources(${_target} PUBLIC ${_qrc})
+  set(${outfiles} ${${outfiles}} PARENT_SCOPE)
 endfunction()