2.4.34

Makefile

@@ -6,10 +6,14 @@ DEB_DIR:=$(BUILD_DIR)/deb/myxx-cmake-$(V)
 all: v deb pack
 
 v:
+	sed -i "s/\/[0-9][0-9.]\+/\/$V/g" $(TOP_DIR)/README.md
+	sed -i "s/[0-9][0-9.]\+tar/$V.tar/g" $(TOP_DIR)/README.md
+	sed -i "s/[0-9][0-9.]\+_all/$(V)_all/g" $(TOP_DIR)/README.md
 	sed -i "s/CMake.*REQUIRED/CMake $V REQUIRED/" $(TOP_DIR)/README.md
 	sed -i "s/VERSION \".*\"/VERSION \"$V\"/" $(TOP_DIR)/MyxxCMake/MyxxCMakeConfigVersion.cmake
 	sed -i "s/VERSION .* LANG/VERSION $V LANG/" $(TOP_DIR)/debian/CMakeLists.txt
 	sed -i "s/(.*)/($(V))/" $(TOP_DIR)/debian/changelog
+	git commit -a -m "$(V)"
 
 deb:
 	rm -rf $(DEB_DIR)
@@ -24,8 +28,9 @@ pack:
 	tar acf $(BUILD_DIR)/myxx-cmake-local-$(V).tar.xz MyxxCMake
 
 upload:
+#	git tag -d $(V)
 	git tag $(V)
-	tea r c --repo cmake/myxx -t $(V) --tag $(V) \
+	gitea-tea r c --repo cmake/myxx -t $(V) --tag $(V) \
 		-a $(BUILD_DIR)/myxx-cmake_$(V).dsc \
 		-a $(BUILD_DIR)/myxx-cmake_$(V).tar.xz \
 		-a $(BUILD_DIR)/myxx-cmake_$(V)_all.deb \

MyxxCMake/MyxxCMakeConfig.cmake

@@ -20,6 +20,8 @@ if(IS_DIRECTORY "${MYXX_CMAKE_SANITIZERS_DIR}")
 endif()
 find_package(Sanitizers REQUIRED)
 
+include(${MYXX_CMAKE_LIB_DIR}/WarningFlags.cmake)
+include(${MYXX_CMAKE_LIB_DIR}/SyntaxCheck.cmake)
 include(${MYXX_CMAKE_LIB_DIR}/Coverage.cmake)
 include(${MYXX_CMAKE_LIB_DIR}/AnalyzeApplyReplacements.cmake)
 include(${MYXX_CMAKE_LIB_DIR}/AnalyzeClangTidy.cmake)
@@ -37,17 +39,49 @@ function(myxx)
     return()
   endif()
 
-  get_property(targets DIRECTORY ${CMAKE_BINARY_DIR} PROPERTY BUILDSYSTEM_TARGETS)
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
-  foreach(iter ${targets})
+    return()
-    get_target_property(target_type ${iter} TYPE)
+  endif()
-    if(NOT ${target_type} STREQUAL "UTILITY")
+
-      myxx_code_coverage(${iter})
+  get_property(__targets DIRECTORY ${CMAKE_BINARY_DIR} PROPERTY BUILDSYSTEM_TARGETS)
-      myxx_analyze_clang_tidy(${iter})
+  foreach(__iter ${__targets})
-      myxx_analyze_clang_check(${iter})
+    get_target_property(__target_type ${__iter} TYPE)
-      myxx_analyze_clazy(${iter})
+
-      myxx_analyze_pvs_studio(${iter})
+    if((NOT ${__target_type} STREQUAL "UTILITY") AND
-      myxx_add_sanitizers(${iter})
+       (NOT ${__iter} MATCHES ".*_shared$" ) AND
+       (NOT ${__iter} MATCHES ".*_static$" )
+    )
+      myxx_analyze_pvs_studio(${__iter})
+      if(MYXX_CMAKE_CLANG_TIDY_FIX)
+        myxx_analyze_clang_tidy(${__iter} FIX)
+      else()
+        myxx_analyze_clang_tidy(${__iter})
+      endif()
+
+      if(MYXX_CMAKE_CLANG_TIDY_NAMING_FIX)
+        myxx_analyze_clang_tidy_naming(${__iter} FIX)
+      else()
+        myxx_analyze_clang_tidy_naming(${__iter})
+      endif()
+
+      if(MYXX_CMAKE_CLANG_CHECK_FIX)
+        myxx_analyze_clang_check(${__iter} FIX)
+      else()
+        myxx_analyze_clang_check(${__iter})
+      endif()
+
+      if(MYXX_CMAKE_CLAZY_FIX)
+        myxx_analyze_clazy(${__iter} FIX)
+      else()
+        myxx_analyze_clazy(${__iter})
+      endif()
+
+      if(NOT ${__target_type} STREQUAL "INTERFACE_LIBRARY")
+        myxx_code_coverage(${__iter})
+        myxx_add_sanitizers(${__iter})
+      endif()
     endif()
+
   endforeach()
 endfunction(myxx)
 

MyxxCMake/MyxxCMakeConfigVersion.cmake

@@ -1,4 +1,4 @@
-set(MYXX_CMAKE_PACKAGE_VERSION "2.0.4")
+set(MYXX_CMAKE_PACKAGE_VERSION "2.4.34")
 if(MYXX_CMAKE_PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
   set(PACKAGE_VERSION_COMPATIBLE FALSE)
 else()

MyxxCMake/lib/AnalyzeApplyReplacements.cmake

@@ -2,7 +2,7 @@ include_guard(GLOBAL)
 
 if(NOT CLANG_APPLY_REPLACEMENTS_NAME)
   set(CLANG_APPLY_REPLACEMENTS_NAMES clang-apply-replacements)
-  foreach(V RANGE 9 18)
+  foreach(V RANGE 9 19)
     list(INSERT CLANG_APPLY_REPLACEMENTS_NAMES 0 "clang-apply-replacements-${V}")
   endforeach()
   unset(V)

MyxxCMake/lib/AnalyzeClangCheck.cmake

@@ -2,7 +2,7 @@ include_guard(GLOBAL)
 
 if(NOT CLANG_CHECK_NAME)
   set(CLANG_CHECK_NAMES clang-check)
-  foreach(V RANGE 9 18)
+  foreach(V RANGE 9 19)
     list(INSERT CLANG_CHECK_NAMES 0 "clang-check-${V}")
   endforeach()
   unset(V)
@@ -13,14 +13,18 @@ endif()
 find_program(CLANG_CHECK_EXE NAMES ${CLANG_CHECK_NAMES})
 unset(CLANG_CHECK_NAMES)
 
-function(myxx_analyze_clang_check target)
+function(myxx_analyze_clang_check TARGET_NAME)
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+    return()
+  endif()
+
   if(NOT CLANG_CHECK_EXE)
     message(STATUS "MyxCMake: Clang Check analyzer is not found")
     return()
   endif()
 
-  if(TARGET ${target}-analyze-clang-check)
+  if(TARGET ${TARGET_NAME}-analyze-clang-check)
-    message(STATUS "MyxxCMake: target ${target}-analyze-clang-check already exists")
+    message(STATUS "MyxxCMake: target ${TARGET_NAME}-analyze-clang-check already exists")
     return()
   endif()
 
@@ -29,24 +33,24 @@ function(myxx_analyze_clang_check target)
   set(multiValueArgs EXTRA_ARGS)
   cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-  set(args --analyze --extra-arg=-Wno-unknown-warning-option ${EXTRA_ARGS})
+  set(__cmd_args --analyze --extra-arg=-Wno-unknown-warning-option ${EXTRA_ARGS})
-  get_target_property(sources ${target} SOURCES)
+  get_target_property(__sources ${TARGET_NAME} SOURCES)
-  foreach(iter ${sources})
+  foreach(iter ${__sources})
     string(FIND ${iter} ${CMAKE_BINARY_DIR} pos)
       if(pos EQUAL -1)
-        list(APPEND srcs ${iter})
+        list(APPEND __filtered_sources ${iter})
       endif()
   endforeach()
 
   if(ARG_FIX)
-    list(APPEND args "--fixit")
+    list(APPEND __cmd_args "--fixit")
   endif()
   if(NOT TARGET myxx-analyze-clang-check)
     add_custom_target(myxx-analyze-clang-check)
   endif()
-  add_custom_target(${target}-analyze-clang-check
+  add_custom_target(${TARGET_NAME}-analyze-clang-check
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-    COMMAND ${CLANG_CHECK_EXE} ${args} -p ${CMAKE_BINARY_DIR} ${srcs})
+    COMMAND ${CLANG_CHECK_EXE} ${__cmd_args} -p ${CMAKE_BINARY_DIR} ${__filtered_sources})
-  add_dependencies(${target}-analyze-clang-check ${target})
+  add_dependencies(${TARGET_NAME}-analyze-clang-check ${TARGET_NAME})
-  add_dependencies(myxx-analyze-clang-check ${target}-analyze-clang-check)
+  add_dependencies(myxx-analyze-clang-check ${TARGET_NAME}-analyze-clang-check)
 endfunction()

MyxxCMake/lib/AnalyzeClangTidy.cmake

@@ -2,7 +2,7 @@ include_guard(GLOBAL)
 
 if(NOT CLANG_TIDY_NAME)
   set(CLANG_TIDY_NAMES clang-tidy)
-  foreach(V RANGE 9 18)
+  foreach(V RANGE 9 19)
     list(INSERT CLANG_TIDY_NAMES 0 "clang-tidy-${V}")
   endforeach()
   unset(V)
@@ -13,14 +13,18 @@ endif()
 find_program(CLANG_TIDY_EXE NAMES ${CLANG_TIDY_NAMES})
 unset(CLANG_TIDY_NAMES)
 
-function(myxx_analyze_clang_tidy target)
+function(myxx_analyze_clang_tidy TARGET_NAME)
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+    return()
+  endif()
+
   if(NOT CLANG_TIDY_EXE)
     message(STATUS "MyxxCMake: Clang Tidy analyzer is not found")
     return()
   endif()
 
-  if(TARGET ${target}-analyze-clang-tidy)
+  if(TARGET ${TARGET_NAME}-analyze-clang-tidy)
-    message(STATUS "MyxxCMake: target ${target}-analyze-clang-tidy already exists")
+    message(STATUS "MyxxCMake: target ${TARGET_NAME}-analyze-clang-tidy already exists")
     return()
   endif()
 
@@ -29,24 +33,75 @@ function(myxx_analyze_clang_tidy target)
   set(multiValueArgs EXTRA_ARGS)
   cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-  set(args -extra-arg="-Wno-unknown-warning-option ${ARG_EXTRA_ARGS}")
+  set(__cmd_args -extra-arg="-Wno-unknown-warning-option ${ARG_EXTRA_ARGS}")
-  get_target_property(sources ${target} SOURCES)
+  get_target_property(__sources ${TARGET_NAME} SOURCES)
-  foreach(iter ${sources})
+  foreach(iter ${__sources})
     string(FIND ${iter} ${CMAKE_BINARY_DIR} pos)
       if(pos EQUAL -1)
-        list(APPEND srcs ${iter})
+        list(APPEND __filtered_sources ${iter})
       endif()
   endforeach()
 
   if(ARG_FIX)
-    list(APPEND args "-fix-errors")
+    list(APPEND __cmd_args "-fix-errors")
   endif()
   if(NOT TARGET myxx-analyze-clang-tidy)
     add_custom_target(myxx-analyze-clang-tidy)
   endif()
-  add_custom_target(${target}-analyze-clang-tidy
+  add_custom_target(${TARGET_NAME}-analyze-clang-tidy
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-    COMMAND ${CLANG_TIDY_EXE} ${args} -p ${CMAKE_BINARY_DIR} ${srcs})
+    COMMAND ${CLANG_TIDY_EXE} ${__cmd_args} -p ${CMAKE_BINARY_DIR} ${__filtered_sources})
-  add_dependencies(${target}-analyze-clang-tidy ${target})
+  add_dependencies(${TARGET_NAME}-analyze-clang-tidy ${TARGET_NAME})
-  add_dependencies(myxx-analyze-clang-tidy ${target}-analyze-clang-tidy)
+  add_dependencies(myxx-analyze-clang-tidy ${TARGET_NAME}-analyze-clang-tidy)
+endfunction()
+
+
+function(myxx_analyze_clang_tidy_naming TARGET_NAME)
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+    return()
+  endif()
+
+  if(NOT CLANG_TIDY_EXE)
+    message(STATUS "MyxxCMake: Clang Tidy analyzer is not found")
+    return()
+  endif()
+
+  set(options FIX)
+  set(oneValueArgs CONFIG)
+  set(multiValueArgs EXTRA_ARGS)
+  cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  if(NOT ARG_CONFIG)
+    set(ARG_CONFIG ${PROJECT_SOURCE_DIR}/.clang-tidy-naming)
+  endif()
+
+  if(NOT EXISTS ${ARG_CONFIG})
+    return()
+  endif()
+
+  if(TARGET ${TARGET_NAME}-analyze-clang-tidy-naming)
+    message(STATUS "MyxxCMake: target ${TARGET_NAME}-analyze-clang-tidy-naming already exists")
+    return()
+  endif()
+
+  set(__cmd_args -extra-arg="-Wno-unknown-warning-option ${ARG_EXTRA_ARGS}")
+  get_target_property(__sources ${TARGET_NAME} SOURCES)
+  foreach(__iter ${__sources})
+    string(FIND ${__iter} ${CMAKE_BINARY_DIR} __pos)
+      if(__pos EQUAL -1)
+        list(APPEND __filtered_sources ${__iter})
+      endif()
+  endforeach()
+
+  if(ARG_FIX)
+    list(APPEND __cmd_args "-fix-errors")
+  endif()
+  if(NOT TARGET myxx-analyze-clang-tidy-naming)
+    add_custom_target(myxx-analyze-clang-tidy-naming)
+  endif()
+  add_custom_target(${TARGET_NAME}-analyze-clang-tidy-naming
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    COMMAND ${CLANG_TIDY_EXE} ${__cmd_args} -p ${CMAKE_BINARY_DIR} ${__filtered_sources})
+  add_dependencies(${TARGET_NAME}-analyze-clang-tidy-naming ${TARGET_NAME})
+  add_dependencies(myxx-analyze-clang-tidy-naming ${TARGET_NAME}-analyze-clang-tidy-naming)
 endfunction()

MyxxCMake/lib/AnalyzeClazy.cmake

@@ -6,14 +6,18 @@ if(CLAZY_EXE AND CLANG_APPLY_REPLACEMENTS_EXE)
   option(MYXX_CMAKE_CLAZY_FIX "MyxCMake: perform fixes for Clazy" OFF)
 endif()
 
-function(myxx_analyze_clazy target)
+function(myxx_analyze_clazy TARGET_NAME)
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+    return()
+  endif()
+
   if(NOT CLAZY_EXE)
     message(STATUS "MyxCMake: Clazy standalone analyzer is not found")
     return()
   endif()
 
-  if(TARGET ${target}-analyze-clazy)
+  if(TARGET ${TARGET_NAME}-analyze-clazy)
-    message(STATUS "MyxxCMake: target ${target}-analyze-clazy already exists")
+    message(STATUS "MyxxCMake: target ${TARGET_NAME}-analyze-clazy already exists")
     return()
   endif()
 
@@ -23,17 +27,21 @@ function(myxx_analyze_clazy target)
   cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
   if(NOT ARG_CHECKS)
-    set(ARG_CHECKS "level2,container-inside-loop,heap-allocated-small-trivial-type,inefficient-qlist,isempty-vs-count,qt-keywords,unneeded-cast")
+    set(ARG_CHECKS
+      "level2,container-inside-loop,detaching-member,heap-allocated-small-trivial-type,\
+      isempty-vs-count,qproperty-type-mismatch,qstring-varargs,qt6-deprecated-api-fixes,\
+      qt6-fwd-fixes,qt6-qlatin1stringchar-to-u,qt-keywords,signal-with-return-value,\
+      thread-with-slots,tr-non-literal,unneeded-cast,use-chrono-in-qtimer")
   endif()
 
-  set(args -checks=${ARG_CHECKS}
+  set(__cmd_args -checks=${ARG_CHECKS}
-           -extra-arg=-Wno-unknown-warning-option
+      -extra-arg=-Wno-unknown-warning-option
-           -export-fixes=clazy-fixes-file.yaml)
+      -export-fixes=clazy-fixes-file.yaml)
-  get_target_property(sources ${target} SOURCES)
+  get_target_property(__sources ${TARGET_NAME} SOURCES)
-  foreach(iter ${sources})
+  foreach(__iter ${__sources})
-    string(FIND ${iter} ${CMAKE_BINARY_DIR} pos)
+    string(FIND ${__iter} ${CMAKE_BINARY_DIR} __pos)
-      if(pos EQUAL -1)
+      if(__pos EQUAL -1)
-        list(APPEND srcs ${iter})
+        list(APPEND __filtered_sources ${__iter})
       endif()
   endforeach()
 
@@ -42,15 +50,15 @@ function(myxx_analyze_clazy target)
   endif()
 
   if(ARG_FIX)
-    add_custom_target(${target}-analyze-clazy
+    add_custom_target(${TARGET_NAME}-analyze-clazy
       WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-      COMMAND ${CLAZY_EXE} ${args} -p ${CMAKE_BINARY_DIR} ${srcs}
+      COMMAND ${CLAZY_EXE} ${__cmd_args} -p ${CMAKE_BINARY_DIR} ${__filtered_sources}
       COMMAND ${CLANG_APPLY_REPLACEMENTS_EXE} ${CMAKE_BINARY_DIR})
   else()
-    add_custom_target(${target}-analyze-clazy
+    add_custom_target(${TARGET_NAME}-analyze-clazy
       WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-      COMMAND ${CLAZY_EXE} ${args} -p ${CMAKE_BINARY_DIR} ${srcs})
+      COMMAND ${CLAZY_EXE} ${__cmd_args} -p ${CMAKE_BINARY_DIR} ${__filtered_sources})
   endif()
-  add_dependencies(${target}-analyze-clazy ${target})
+  add_dependencies(${TARGET_NAME}-analyze-clazy ${TARGET_NAME})
-  add_dependencies(myxx-analyze-clazy ${target}-analyze-clazy)
+  add_dependencies(myxx-analyze-clazy ${TARGET_NAME}-analyze-clazy)
 endfunction()

MyxxCMake/lib/AnalyzePvsStudio.cmake

@@ -5,10 +5,15 @@ if(${CMAKE_VERSION} VERSION_LESS "3.17.0")
   set(MYXX_CMAKE_LIB_PVS_DIR_BACKPORT ${CMAKE_CURRENT_LIST_DIR})
 endif()
 
-function(myxx_analyze_pvs_studio target)
+function(myxx_analyze_pvs_studio TARGET_NAME)
   if(${CMAKE_VERSION} VERSION_LESS "3.17.0")
     set(CMAKE_CURRENT_FUNCTION_LIST_DIR ${MYXX_CMAKE_LIB_PVS_DIR_BACKPORT})
   endif()
+
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+    return()
+  endif()
+
   if(NOT PVS_STUDIO_ANALYZER_EXE)
     message(STATUS "MyxxCMake: pvs-studio-analyzer not found.")
     return()
@@ -31,29 +36,38 @@ function(myxx_analyze_pvs_studio target)
   endif()
 
   if(NOT ARG_MODE)
-    set(ARG_MODE "GA:1,2,3;64:1,2,3;OP:1,2,3;CS:1,2,3;OWASP:1,2,3")
+    set(ARG_MODE "GA:1,2,3;64:1,2;OP:1,2,3;CS:1,2;OWASP:1,2")
   endif()
 
-  pvs_studio_add_target(TARGET ${target}-analyze-pvs-studio
+  get_target_property(__target_sources ${TARGET_NAME} SOURCES)
-    ANALYZE ${target}
+  foreach(__iter ${__target_sources})
+    string(FIND ${__iter} ${CMAKE_BINARY_DIR} __pos)
+      if(__pos EQUAL -1)
+        list(APPEND __filtered_sources ${__iter})
+      endif()
+  endforeach()
+
+  pvs_studio_add_target(TARGET ${TARGET_NAME}-analyze-pvs-studio
+    ANALYZE ${TARGET_NAME}
+    COMPILE_COMMANDS
     HIDE_HELP
     OUTPUT
     FORMAT errorfile
     ARGS --exclude-path ${CMAKE_CURRENT_BINARY_DIR} ${ARG_ARGS}
     MODE ${ARG_MODE})
 
-  get_target_property(target_type ${target} TYPE)
+  get_target_property(__target_type ${TARGET_NAME} TYPE)
-  if(${target_type} STREQUAL INTERFACE_LIBRARY)
+  if(${__target_type} STREQUAL INTERFACE_LIBRARY)
-    set(target_type INTERFACE)
+    set(__target_type INTERFACE)
   else()
-    set(target_type PRIVATE)
+    set(__target_type PRIVATE)
   endif()
   if(MSVC)
-    target_compile_options(${target} BEFORE ${target_type} /FI ${ARG_HEADER})
+    target_compile_options(${TARGET_NAME} BEFORE ${__target_type} /FI ${ARG_HEADER})
   else() # GCC/Clang
-    target_compile_options(${target} BEFORE ${target_type} -include ${ARG_HEADER})
+    target_compile_options(${TARGET_NAME} BEFORE ${__target_type} -include ${ARG_HEADER})
   endif()
 
-  add_dependencies(${target}-analyze-pvs-studio ${target})
+  add_dependencies(${TARGET_NAME}-analyze-pvs-studio ${TARGET_NAME})
-  add_dependencies(myxx-analyze-pvs-studio ${target}-analyze-pvs-studio)
+  add_dependencies(myxx-analyze-pvs-studio ${TARGET_NAME}-analyze-pvs-studio)
 endfunction()

MyxxCMake/lib/Coverage.cmake

@@ -5,44 +5,48 @@ if(MYXX_CODE_COVERAGE)
   find_program(GENHTML_EXE NAMES genhtml)
 endif()
 
-function(myxx_code_coverage target)
+function(myxx_code_coverage TARGET_NAME)
   if(NOT MYXX_CODE_COVERAGE)
     return()
   endif()
 
+  if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+    return()
+  endif()
+
   set(options)
   set(oneValueArgs)
   set(multiValueArgs EXCLUDE)
   cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set_property(TARGET ${target} APPEND PROPERTY
+    set_property(TARGET ${TARGET_NAME} APPEND PROPERTY
         COMPILE_OPTIONS --coverage)
-    set_property(TARGET ${target} APPEND PROPERTY LINK_FLAGS --coverage)
+    set_property(TARGET ${TARGET_NAME} APPEND PROPERTY LINK_FLAGS --coverage)
   endif()
   if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set_property(TARGET ${target} APPEND PROPERTY
+    set_property(TARGET ${TARGET_NAME} APPEND PROPERTY
         COMPILE_OPTIONS -fprofile-instr-generate -fcoverage-mapping)
-    set_property(TARGET ${target} APPEND PROPERTY LINK_FLAGS --coverage)
+    set_property(TARGET ${TARGET_NAME} APPEND PROPERTY LINK_FLAGS --coverage)
   endif()
 
   if(LCOV_EXE)
-    add_custom_target(${target}-coverage
+    add_custom_target(${TARGET_NAME}-coverage
       WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-      COMMAND ${LCOV_EXE} --test-name ${target} --output "${target}.lcov"
+      COMMAND ${LCOV_EXE} --test-name ${TARGET_NAME} --output "${TARGET_NAME}.lcov"
               --capture
               --no-external
               --base-directory ${CMAKE_SOURCE_DIR}
               --directory ${CMAKE_BINARY_DIR}
               --exclude "/usr/\\\*"
               --exclude "${CMAKE_BINARY_DIR}/\\\*")
-    add_dependencies(${target}-coverage ${target})
+    add_dependencies(${TARGET_NAME}-coverage ${TARGET_NAME})
 
     if(GENHTML_EXE)
-      add_custom_target(${target}-coverage-report
+      add_custom_target(${TARGET_NAME}-coverage-report
         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-        COMMAND ${GENHTML_EXE} --output-directory "${target}-coverage-html" "${target}.lcov")
+        COMMAND ${GENHTML_EXE} --output-directory "${TARGET_NAME}-coverage-html" "${TARGET_NAME}.lcov")
-      add_dependencies(${target}-coverage-report ${target}-coverage)
+      add_dependencies(${TARGET_NAME}-coverage-report ${TARGET_NAME}-coverage)
     endif()
   endif()
 endfunction()

MyxxCMake/lib/SyntaxCheck.cmake

@@ -0,0 +1,18 @@
+include_guard(GLOBAL)
+
+option(MYXX_CMAKE_SYNTAX_CHECK_ONLY "only check syntax (-fsyntax-only)" OFF)
+if(MYXX_CMAKE_SYNTAX_CHECK_ONLY)
+  if (NOT ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR
+           (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")))
+    myx_message_warning("only clang and gcc support -fsyntax-only, using ${CMAKE_CXX_COMPILER_ID}")
+  else()
+    add_compile_options(-fsyntax-only)
+    set(CMAKE_CXX_COMPILE_OBJECT "${CMAKE_CXX_COMPILE_OBJECT} && touch <OBJECT>")
+    set(CMAKE_CXX_CREATE_SHARED_LIBRARY "touch <TARGET>")
+    set(CMAKE_CXX_CREATE_SHARED_MODULE "touch <TARGET>")
+    set(CMAKE_CXX_LINK_EXECUTABLE "touch <TARGET>")
+    set(CMAKE_CXX_ARCHIVE_CREATE "touch <TARGET>")
+    set(CMAKE_CXX_ARCHIVE_APPEND "touch <TARGET>")
+    set(CMAKE_CXX_ARCHIVE_FINISH "touch <TARGET>")
+  endif()
+endif()

MyxxCMake/lib/WarningFlags.cmake

@@ -0,0 +1,88 @@
+include_guard(GLOBAL)
+
+option(MYXX_CMAKE_WARNINGS_NORMAL "Normal level" ON)
+cmake_dependent_option(MYXX_CMAKE_WARNINGS_VERBOSE "Verbose level" OFF "MYXX_CMAKE_WARNINGS_NORMAL" OFF)
+
+if(MYXX_CMAKE_WARNINGS_NORMAL)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    check_enable_cxx_compiler_flag(-Wshadow)
+    check_enable_cxx_compiler_flag(-Wtautological-overlap-compare)
+    check_enable_cxx_compiler_flag(-Wtautological-compare)
+    check_enable_cxx_compiler_flag(-Wtautological-bitwise-compare)
+    check_enable_cxx_compiler_flag(-Wbitwise-conditional-parentheses)
+    check_enable_cxx_compiler_flag(-Wrange-loop-analysis)
+    check_enable_cxx_compiler_flag(-Wmisleading-indentation)
+    check_enable_cxx_compiler_flag(-Wc99-designator)
+    check_enable_cxx_compiler_flag(-Wreorder-init-list)
+    check_enable_cxx_compiler_flag(-Wsizeof-pointer-div)
+    check_enable_cxx_compiler_flag(-Wsizeof-array-div)
+    check_enable_cxx_compiler_flag(-Wxor-used-as-pow)
+    check_enable_cxx_compiler_flag(-Wfinal-dtor-non-final-class)
+  endif()
+
+  if((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR
+     (CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
+    check_enable_cxx_compiler_flag(-Wall)
+    check_enable_cxx_compiler_flag(-Wextra)
+    check_enable_cxx_compiler_flag(-Wnon-virtual-dtor)
+    check_enable_cxx_compiler_flag(-Wlogical-op)
+    check_enable_cxx_compiler_flag(-Wconversion)
+    check_enable_cxx_compiler_flag(-Wdeprecated)
+    check_enable_cxx_compiler_flag(-ftemplate-depth=1024)
+    check_enable_cxx_compiler_flag(-Wold-style-cast)
+    check_enable_cxx_compiler_flag(-Wdisabled-optimization)
+    check_enable_cxx_compiler_flag(-ftemplate-backtrace-limit=0)
+    check_enable_cxx_compiler_flag(-fstack-protector-all)
+    check_enable_cxx_compiler_flag(-Wodr)
+    check_enable_cxx_compiler_flag(-Wsuggest-final-types)
+    check_enable_cxx_compiler_flag(-Wsuggest-final-methods)
+    check_enable_cxx_compiler_flag(-Wsuggest-override)
+    check_enable_cxx_compiler_flag(-fdiagnostics-show-template-tree)
+
+    if(NOT MYXX_CMAKE_WARNINGS_VERBOSE)
+      check_enable_cxx_compiler_flag(-Wno-float-conversion)
+      if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "5.999")
+          check_enable_cxx_compiler_flag(-Wno-attributes)
+        endif()
+        check_enable_cxx_compiler_flag(-Wno-maybe-uninitialized)
+      endif()
+    endif()
+  endif()
+endif()
+
+if(MYXX_CMAKE_WARNINGS_VERBOSE)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    check_enable_cxx_compiler_flag(-Wpointer-to-int-cast)
+    check_enable_cxx_compiler_flag(-Wuninitialized-const-reference)
+    check_enable_cxx_compiler_flag(-Wunused-but-set-parameter)
+    check_enable_cxx_compiler_flag(-Wunused-but-set-variable)
+    check_enable_cxx_compiler_flag(-Wnull-pointer-subtraction)
+    check_enable_cxx_compiler_flag(-Wno-reserved-identifier)
+  endif()
+
+  if((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR
+     (CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
+    check_enable_cxx_compiler_flag(-Wshadow)
+    check_enable_cxx_compiler_flag(-Wpedantic)
+    check_enable_cxx_compiler_flag(-Wnoexcept)
+    check_enable_cxx_compiler_flag(-Wzero-as-null-pointer-constant)
+    # From GCC 6.
+    check_enable_cxx_compiler_flag(-Wshift-negative-value)
+    check_enable_cxx_compiler_flag(-Wshift-overflow=2)
+    check_enable_cxx_compiler_flag(-Wduplicated-cond)
+    check_enable_cxx_compiler_flag(-Wnull-dereference)
+    # From GCC 7.
+    check_enable_cxx_compiler_flag(-Wduplicated-branches)
+    check_enable_cxx_compiler_flag(-Wrestrict)
+    check_enable_cxx_compiler_flag(-Waligned-new)
+    # From GCC 8.
+    check_enable_cxx_compiler_flag(-Wcast-align=strict)
+    # From GCC 10.
+    check_enable_cxx_compiler_flag(-Wmismatched-tags)
+    check_enable_cxx_compiler_flag(-Wredundant-tags)
+    # From GCC 12.
+    check_enable_cxx_compiler_flag(-Warray-compare)
+    check_enable_cxx_compiler_flag(-Wmissing-requires)
+  endif()
+endif()

MyxxCMake/lib/pvs-studio/PVS-Studio.cmake

@@ -3,7 +3,7 @@
 # 2020-2022 (c) PVS-Studio LLC
 # Version 12
 
-cmake_minimum_required(VERSION 3.0.0)
+cmake_minimum_required(VERSION 3.6)
 cmake_policy(SET CMP0054 NEW)
 
 if (PVS_STUDIO_AS_SCRIPT)
@@ -59,7 +59,7 @@ function (pvs_studio_log TEXT)
 endfunction()
 
 function (pvs_studio_relative_path VAR ROOT FILEPATH)
-    if (WIN32)
+    if (CMAKE_HOST_WIN32)
         STRING(REGEX REPLACE "\\\\" "/" ROOT ${ROOT})
         STRING(REGEX REPLACE "\\\\" "/" FILEPATH ${FILEPATH})
     endif()
@@ -104,6 +104,8 @@ macro (pvs_studio_append_standard_flag FLAGS STANDARD)
     if ("${STANDARD}" MATCHES "^(99|11|14|17|20)$")
         if ("${PVS_STUDIO_PREPROCESSOR}" MATCHES "gcc|clang")
             list(APPEND "${FLAGS}" "-std=c++${STANDARD}")
+        elseif("${PVS_STUDIO_PREPROCESSOR}" MATCHES "visualcpp")
+            list(APPEND "${FLAGS}" "/std:c++${STANDARD}")
         endif()
     endif()
 endmacro()
@@ -183,7 +185,7 @@ function (pvs_studio_analyze_file SOURCE SOURCE_DIR BINARY_DIR)
     pvs_studio_relative_path(SOURCE_RELATIVE "${SOURCE_DIR}" "${SOURCE}")
     pvs_studio_join_path(SOURCE "${SOURCE_DIR}" "${SOURCE}")
 
-    set(LOG "${BINARY_DIR}/PVS-Studio/${SOURCE_RELATIVE}.plog")
+    set(LOG "${BINARY_DIR}/PVS-Studio/${TARGET}/${SOURCE_RELATIVE}.log")
     get_filename_component(LOG "${LOG}" REALPATH)
     get_filename_component(PARENT_DIR "${LOG}" DIRECTORY)
 
@@ -342,7 +344,7 @@ function (pvs_studio_add_target)
 
     set(PATHS)
 
-    if (WIN32)
+    if (CMAKE_HOST_WIN32)
         # The registry value is only read when you do some cache operation on it.
         # https://stackoverflow.com/questions/1762201/reading-registry-values-with-cmake
         GET_FILENAME_COMPONENT(ROOT "[HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\ProgramVerificationSystems\\PVS-Studio;installDir]" ABSOLUTE CACHE)
@@ -520,18 +522,38 @@ function (pvs_studio_add_target)
 
     pvs_studio_relative_path(LOG_RELATIVE "${CMAKE_BINARY_DIR}" "${PVS_STUDIO_LOG}")
     if (PVS_STUDIO_PLOGS OR PVS_STUDIO_COMPILE_COMMANDS)
-        if (WIN32)
+        if (CMAKE_HOST_WIN32)
             string(REPLACE / \\ PVS_STUDIO_PLOGS "${PVS_STUDIO_PLOGS}")
-        endif()
+            if (CMAKE_GENERATOR MATCHES "NMake")
-        if (WIN32)
+                set(COMMAND_TYPE_FILE "${CMAKE_BINARY_DIR}/PVSConcatAllLogs.cmd")
-            set(COMMANDS COMMAND type ${PVS_STUDIO_PLOGS} ${PVS_STUDIO_PLOGS_LOGS} > "${PVS_STUDIO_LOG}" 2>nul || cd .)
+
+                # The number of files that will be merged in one call to the type command
+                set(STEP_SIZE 30)
+                set(BEGIN 0)
+
+                list(APPEND PVS_STUDIO_PLOGS ${PVS_STUDIO_PLOGS_LOGS})
+                list(LENGTH PVS_STUDIO_PLOGS END)
+
+                # Creating a bat file to call the 'type' command
+                file(WRITE ${COMMAND_TYPE_FILE} "@echo off\nbreak > ${PVS_STUDIO_LOG}\n")
+
+                while(BEGIN LESS END)
+                    list(SUBLIST PVS_STUDIO_PLOGS ${BEGIN} ${STEP_SIZE} NEW_LIST)
+                    file(APPEND ${COMMAND_TYPE_FILE} "type ${NEW_LIST} >> ${PVS_STUDIO_LOG} 2>nul || cd .\n")
+                    math(EXPR BEGIN "${BEGIN} + ${STEP_SIZE}")
+                endwhile()
+
+                list(APPEND COMMANDS COMMAND call ${COMMAND_TYPE_FILE})
+            else()
+                set(COMMANDS COMMAND type ${PVS_STUDIO_PLOGS} ${PVS_STUDIO_PLOGS_LOGS} > "${PVS_STUDIO_LOG}" 2>nul || cd .)
+            endif()
         else()
             set(COMMANDS COMMAND cat ${PVS_STUDIO_PLOGS} ${PVS_STUDIO_PLOGS_LOGS} > "${PVS_STUDIO_LOG}" 2>/dev/null || true)
         endif()
         set(COMMENT "Generating ${LOG_RELATIVE}")
         if (NOT "${PVS_STUDIO_FORMAT}" STREQUAL "" OR PVS_STUDIO_OUTPUT)
             if ("${PVS_STUDIO_FORMAT}" STREQUAL "")
-                set(PVS_STUDIO_FORMAT "errorfile")
+              set(PVS_STUDIO_FORMAT "errorfile")
             endif()
             if (PVS_STUDIO_HIDE_HELP)
               set(PVS_STUDIO_CONVERTER_ARGS ${PVS_STUDIO_CONVERTER_ARGS} --noHelpMessages)
@@ -552,7 +574,7 @@ function (pvs_studio_add_target)
         set(COMMENT "Generating ${LOG_RELATIVE}: no sources found")
     endif()
 
-    if (WIN32)
+    if (CMAKE_HOST_WIN32)
         string(REPLACE / \\ PVS_STUDIO_LOG "${PVS_STUDIO_LOG}")
     endif()
 

MyxxCMake/lib/sanitizers/FindSanitizers.cmake

@@ -50,6 +50,10 @@ function(sanitizer_add_blacklist_file FILE)
 endfunction()
 
 function(myxx_add_sanitizers ...)
+    if(NOT ${PROJECT_BINARY_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+      return()
+    endif()
+
     # If no sanitizer is enabled, return immediately.
     if(NOT
        (SANITIZE_ADDRESS

README.md

@@ -1,19 +1,19 @@
-# Библиотека дополнительных функций для CMake
+# Библиотека дополнительных функций для сопровождения проекта на CMake
 
 ## Установка
 
-Скачать [здесь](../../../releases) пакет для Debian и установить
+Скачать [пакет](../../../releases/download/2.4.34/myxx-cmake_2.4.34_all.deb)
-его или архив `myxx-cmake-local` и распаковать его в каталог
+для Debian и установить его, выполнив команду `sudo dpkg -i myxx-cmake_2.4.34_all.deb`,
-`$HOME/.local/share/cmake`.
+или [архив](../../../releases/download/2.4.34/myxx-cmake-local-2.4.34.tar.xz)
+и распаковать его в каталог `$HOME/.local/share/cmake`.
 
 ## Использование
 
 Для работы в программном проекте должна использоваться библиотека
-[myx-cmake](../../../../myx), которая автоматически находит
+[myx-cmake](../../../../myx), которая автоматически находит эту библиотеку.
-эту библиотеку.
 
-Для подключения функций необходимо в конце описания проекта
+Для подключения функций библиотеки необходимо в конце описания
-(после создания целей, для которых нужно применить правила)
+проекта (после создания целей, для которых нужно применить правила)
 добавить строки:
 
 ```cmake

VERSION

@@ -1 +1 @@
-2.0.4
+2.4.34

debian/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.6 FATAL_ERROR)
-project(myxx-cmake VERSION 2.0.4 LANGUAGES)
+project(myxx-cmake VERSION 2.4.34 LANGUAGES)
 
 include(GNUInstallDirs)
 file(WRITE ${CMAKE_SOURCE_DIR}/MyxxCMake/MyxxCMakeConfigVersion.cmake

debian/changelog

@@ -1,4 +1,4 @@
-myxx-cmake (2.0.4) unstable; urgency=medium
+myxx-cmake (2.4.34) unstable; urgency=medium
 
   * New version.