Makefile для загрузки (обновления) сторонних модулей

CMLibBuildTypes.cmake

@@ -6,7 +6,7 @@ if(CMAKE_CONFIGURATION_TYPES)
     list(APPEND CMAKE_CONFIGURATION_TYPES Profile)
   endif()
 else()
-  set(_allowed_build_types None Debug Release Profile)
+  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 Debug CACHE STRING "" FORCE)
@@ -44,6 +44,6 @@ elseif(CMAKE_BUILD_TYPE STREQUAL None)
   set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
   #  set(USE_CLANG_TIDY ON CACHE BOOL "Use clang-tidy")
   #  set(USE_CPPCHECK ON CACHE BOOL "Use cppcheck")
-  #  set(USE_PVS_STUDIO ON CACHE BOOL "Use PVS-Studio")
+  set(USE_PVS_STUDIO ON CACHE BOOL "Use PVS-Studio")
 endif()
 

CMLibCPackSources.cmake

@@ -3,7 +3,9 @@ set(CPACK_SOURCE_GENERATOR TXZ)
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
 set(CPACK_IGNORE_FILE "cmake/etc/cpack_ignore.txt")
 file(STRINGS ${CPACK_IGNORE_FILE} CPACK_SOURCE_IGNORE_FILES)
-set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${CPACK_IGNORE_FILE})
+set_property(DIRECTORY
+             APPEND
+             PROPERTY CMAKE_CONFIGURE_DEPENDS ${CPACK_IGNORE_FILE})
 include(CPack)
 add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source)
 

CMLibCodeAnalysisPvsStudio.cmake

@@ -0,0 +1,19 @@
+option(USE_PVS_STUDIO "Use PVS-Studio for static analysis" OFF)
+
+if(USE_PVS_STUDIO)
+  include(PVS-Studio)
+  find_program(PVS_STUDIO_ANALYZER_EXE NAMES pvs-studio-analyzer)
+  if(PVS_STUDIO_ANALYZER_EXE AND NOT TARGET pvs-global-checker)
+    pvs_studio_add_target(TARGET pvs-global-checker
+      ALL
+      RECURSIVE
+      HIDE_HELP
+      COMPILE_COMMANDS
+      OUTPUT FORMAT errorfile
+      MODE GA:1,2,3;64:1;OP:1,2;CS:1,2
+      LOG target.err)
+  else()
+    message(WARNING "PVS-Studio is not found")
+  endif()
+endif()
+

CMLibCommon.cmake

@@ -20,7 +20,6 @@ include(CMLibOrganizationName)
 set_organization_name()
 
 include(CMLibGlobalVariables)
-include(CMLibInstallInOpt)
 include(CMLibLSBInfo)
 include(CMLibCompiler)
 include(CMLibCompilerFlags)
@@ -29,6 +28,8 @@ include(CMLibCommonTargetProperties)
 include(CMLibCommonLibraryTarget)
 include(CMLibFlagRemove)
 include(CMLibBuildTypes)
+include(CMLibCodeAnalysisPvsStudio)
+include(cotire)
 
 include(CMLibQtTranslation)
 include(CMLibToday)

CMLibCommonLibraryTarget.cmake

@@ -1,25 +1,28 @@
 # Создание статической и динамической библиотеки из одинаковых объектных файлов
 function(add_common_library LIBNAME SOURCES)
   add_library(${LIBNAME} OBJECT ${SOURCES})
-  target_include_directories(${LIBNAME} PUBLIC
+  target_include_directories(
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    ${LIBNAME}
-    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
+    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include/${LIBNAME}>)
+           $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
+           $<INSTALL_INTERFACE:include/${LIBNAME}>)
   set_target_properties(${LIBNAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
   add_library(${LIBNAME}_shared SHARED $<TARGET_OBJECTS:${LIBNAME}>)
   get_property(_ver GLOBAL PROPERTY VERSION_STR)
   get_property(_sover GLOBAL PROPERTY VERSION_MAJOR)
-  set_target_properties(${LIBNAME}_shared PROPERTIES
+  set_target_properties(${LIBNAME}_shared
-    VERSION ${_ver}
+                        PROPERTIES VERSION ${_ver}
-    SOVERSION ${_sover}
+                                   SOVERSION ${_sover}
-    OUTPUT_NAME ${LIBNAME}
+                                   OUTPUT_NAME ${LIBNAME}
-    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR})
+                                   LIBRARY_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR})
 
   add_library(${LIBNAME}_static STATIC $<TARGET_OBJECTS:${LIBNAME}>)
-  set_target_properties(${LIBNAME}_static PROPERTIES
+  set_target_properties(${LIBNAME}_static
-    OUTPUT_NAME ${LIBNAME}
+                        PROPERTIES OUTPUT_NAME ${LIBNAME}
-    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR})
+                                   ARCHIVE_OUTPUT_DIRECTORY
-  configure_file(${CMLIB_MODULE_DIR}/pc/lib.pc.in ${CMAKE_BINARY_DIR}/${LIBNAME}.pc)
+                                   ${CMAKE_INSTALL_LIBDIR})
+  configure_file(${CMLIB_MODULE_DIR}/pc/lib.pc.in
+                 ${CMAKE_BINARY_DIR}/${LIBNAME}.pc)
 endfunction()
 

CMLibCommonTargetProperties.cmake

@@ -1,5 +1,4 @@
-set(COMMON_CXX_FEATURES
+set(COMMON_CXX_FEATURES cxx_alias_templates cxx_nullptr cxx_override)
-  cxx_alias_templates cxx_nullptr cxx_override)
 
 function(common_target_properties Name)
   get_target_property(__type ${Name} TYPE)
@@ -9,23 +8,30 @@ function(common_target_properties Name)
     set(__visibility INTERFACE)
   endif()
   target_compile_features(${Name} ${__visibility} ${COMMON_CXX_FEATURES})
-  target_include_directories(${Name} PUBLIC
+  target_include_directories(
-    $<INSTALL_INTERFACE:include>
+    ${Name}
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    PUBLIC $<INSTALL_INTERFACE:include>
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>)
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+           $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>)
   if(APPLE)
     target_compile_definitions(${Name} ${__visibility} Darwin)
   endif()
   if(NOT __interface)
     if(TARGET Qt5::Core)
-      target_compile_options(${Name} PUBLIC "${Qt5Core_EXECUTABLE_COMPILE_FLAGS}")
+      target_compile_options(${Name}
+                             PUBLIC "${Qt5Core_EXECUTABLE_COMPILE_FLAGS}")
       set_target_properties(${Name} PROPERTIES AUTOMOC TRUE AUTORCC TRUE)
     endif()
     if(TARGET Qt5::Widgets)
       set_target_properties(${Name} PROPERTIES AUTOUIC TRUE)
-      target_include_directories(${Name} PUBLIC
+      if(CMAKE_VERSION VERSION_LESS 3.7.99)
-        $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}_autogen/include>)
+        target_include_directories(
+          ${Name}
+          PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}_autogen/include>
+          )
+      endif()
     endif()
     if(CMAKE_CXX_COMPILER_IS_GCC AND NOT APPLE)
       set_target_properties(${Name} PROPERTIES LINK_FLAGS "-Wl,--no-as-needed")

CMLibCompiler.cmake

@@ -1,8 +1,8 @@
 # C compiler name
 if(CMAKE_C_COMPILER_ID STREQUAL "Intel")
   set(CMAKE_C_COMPILER_IS_INTEL ON)
-elseif(CMAKE_C_COMPILER_ID STREQUAL "Clang" OR
+elseif(CMAKE_C_COMPILER_ID STREQUAL "Clang"
-    CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
+       OR CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
   set(CMAKE_C_COMPILER_IS_CLANG ON)
 elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU")
   set(CMAKE_C_COMPILER_IS_GCC ON)
@@ -13,8 +13,8 @@ endif()
 # C++ compiler name
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
   set(CMAKE_CXX_COMPILER_IS_INTEL ON)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
-    CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+       OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
   set(CMAKE_CXX_COMPILER_IS_CLANG ON)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   set(CMAKE_CXX_COMPILER_IS_GCC ON)

CMLibCompilerFeaturesHPPGenerate.cmake

@@ -7,24 +7,12 @@ write_compiler_detection_header(
   FEATURES
   cxx_nullptr
   cxx_override
+  cxx_alignas
+  cxx_alignof
+  cxx_attributes
+  cxx_auto_type
+  cxx_constexpr
+  cxx_digit_separators
+  cxx_range_for
   )
 
-#  cxx_std_11
-#  cxx_alignas
-#  cxx_alignof
-#  cxx_attributes
-#  cxx_auto_type
-#  cxx_constexpr
-#  cxx_digit_separators
-#  cxx_range_for
-#  ALLOW_UNKNOWN_COMPILERS
-#  ALLOW_UNKNOWN_COMPILER_VERSIONS
-#install(FILES
-#  compiler_features.hpp
-#  DESTINATION include
-#  )
-
-#install(FILES
-#  ${support_files}
-#  DESTINATION include/compilers
-#  )

CMLibCompilerFlags.cmake

@@ -18,93 +18,98 @@ macro(CHECK_ENABLE_CXX_FLAG flag)
 endmacro()
 
 # Common configuration for GCC, clang and Intel.
-if(CMAKE_CXX_COMPILER_IS_CLANG OR CMAKE_CXX_COMPILER_IS_INTEL OR CMAKE_CXX_COMPILER_IS_GCC)
+if(CMAKE_CXX_COMPILER_IS_CLANG
+   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)
 
   if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    CHECK_ENABLE_CXX_FLAG(-Wall)
+    check_enable_cxx_flag(-Wall)
-    CHECK_ENABLE_CXX_FLAG(-Wextra)
+    check_enable_cxx_flag(-Wextra)
-    CHECK_ENABLE_CXX_FLAG(-Wnon-virtual-dtor)
+    check_enable_cxx_flag(-Wnon-virtual-dtor)
-    CHECK_ENABLE_CXX_FLAG(-Wnoexcept)
+    check_enable_cxx_flag(-Wnoexcept)
-    CHECK_ENABLE_CXX_FLAG(-Wlogical-op)
+    check_enable_cxx_flag(-Wlogical-op)
-    CHECK_ENABLE_CXX_FLAG(-Wconversion)
+    check_enable_cxx_flag(-Wconversion)
-    CHECK_ENABLE_CXX_FLAG(-Wdeprecated)
+    check_enable_cxx_flag(-Wdeprecated)
     # This limit is supposed to be at least 1024 in C++11, but for some reason
     # clang sets this to 256, and gcc to 900.
-    CHECK_ENABLE_CXX_FLAG(-ftemplate-depth=1024)
+    check_enable_cxx_flag(-ftemplate-depth=1024)
-    CHECK_ENABLE_CXX_FLAG(-Wold-style-cast)
+    check_enable_cxx_flag(-Wold-style-cast)
-    CHECK_ENABLE_CXX_FLAG(-Wdisabled-optimization)
+    check_enable_cxx_flag(-Wdisabled-optimization)
-    # This is useful when the compiler decides the template backtrace is too verbose.
+    # This is useful when the compiler decides the template backtrace is too
-    CHECK_ENABLE_CXX_FLAG(-ftemplate-backtrace-limit=0)
+    # verbose.
-    CHECK_ENABLE_CXX_FLAG(-fstack-protector-all)
+    check_enable_cxx_flag(-ftemplate-backtrace-limit=0)
+    check_enable_cxx_flag(-fstack-protector-all)
     # A few suggestion flags.
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-attribute=pure)
+    check_enable_cxx_flag(-Wsuggest-attribute=pure)
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-attribute=const)
+    check_enable_cxx_flag(-Wsuggest-attribute=const)
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-attribute=noreturn)
+    check_enable_cxx_flag(-Wsuggest-attribute=noreturn)
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-attribute=format)
+    check_enable_cxx_flag(-Wsuggest-attribute=format)
     # From GCC 5.
-    CHECK_ENABLE_CXX_FLAG(-Wodr)
+    check_enable_cxx_flag(-Wodr)
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-final-types)
+    check_enable_cxx_flag(-Wsuggest-final-types)
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-final-methods)
+    check_enable_cxx_flag(-Wsuggest-final-methods)
-    CHECK_ENABLE_CXX_FLAG(-Wsuggest-override)
+    check_enable_cxx_flag(-Wsuggest-override)
     # From GCC 6.
-    CHECK_ENABLE_CXX_FLAG(-Wshift-negative-value)
+    check_enable_cxx_flag(-Wshift-negative-value)
-    CHECK_ENABLE_CXX_FLAG(-Wshift-overflow=2)
+    check_enable_cxx_flag(-Wshift-overflow=2)
-    CHECK_ENABLE_CXX_FLAG(-Wduplicated-cond)
+    check_enable_cxx_flag(-Wduplicated-cond)
-    CHECK_ENABLE_CXX_FLAG(-Wnull-dereference)
+    check_enable_cxx_flag(-Wnull-dereference)
     # From GCC 7.
-    CHECK_ENABLE_CXX_FLAG(-Wrestrict)
+    check_enable_cxx_flag(-Wrestrict)
-    CHECK_ENABLE_CXX_FLAG(-Waligned-new)
+    check_enable_cxx_flag(-Waligned-new)
     # From GCC 8.
-    CHECK_ENABLE_CXX_FLAG(-Wcast-align=strict)
+    check_enable_cxx_flag(-Wcast-align=strict)
-    # This is supposed to produce a nice graphical visualization
+    # This is supposed to produce a nice graphical visualization of mismatching
-    # of mismatching template errors.
+    # template errors.
-    CHECK_ENABLE_CXX_FLAG(-fdiagnostics-show-template-tree)
+    check_enable_cxx_flag(-fdiagnostics-show-template-tree)
-    CHECK_ENABLE_CXX_FLAG(-fdiagnostics-show-option)
+    check_enable_cxx_flag(-fdiagnostics-show-option)
 
-    CHECK_ENABLE_CXX_FLAG(-pedantic)
+    check_enable_cxx_flag(-pedantic)
-    CHECK_ENABLE_CXX_FLAG(-Wcast-align)
+    check_enable_cxx_flag(-Wcast-align)
-    CHECK_ENABLE_CXX_FLAG(-Wcast-qual)
+    check_enable_cxx_flag(-Wcast-qual)
-    CHECK_ENABLE_CXX_FLAG(-Wctor-dtor-privacy)
+    check_enable_cxx_flag(-Wctor-dtor-privacy)
-    CHECK_ENABLE_CXX_FLAG(-Wdisabled-optimization)
+    check_enable_cxx_flag(-Wdisabled-optimization)
-    CHECK_ENABLE_CXX_FLAG(-Wformat=2)
+    check_enable_cxx_flag(-Wformat=2)
-    CHECK_ENABLE_CXX_FLAG(-Winit-self)
+    check_enable_cxx_flag(-Winit-self)
-    CHECK_ENABLE_CXX_FLAG(-Wmissing-include-dirs)
+    check_enable_cxx_flag(-Wmissing-include-dirs)
-    CHECK_ENABLE_CXX_FLAG(-Woverloaded-virtual)
+    check_enable_cxx_flag(-Woverloaded-virtual)
-    CHECK_ENABLE_CXX_FLAG(-Wredundant-decls)
+    check_enable_cxx_flag(-Wredundant-decls)
-    CHECK_ENABLE_CXX_FLAG(-Wsign-promo)
+    check_enable_cxx_flag(-Wsign-promo)
-    CHECK_ENABLE_CXX_FLAG(-Wstrict-overflow=5)
+    check_enable_cxx_flag(-Wstrict-overflow=5)
-    CHECK_ENABLE_CXX_FLAG(-Wundef)
+    check_enable_cxx_flag(-Wundef)
-    CHECK_ENABLE_CXX_FLAG(-Wno-unused)
+    check_enable_cxx_flag(-Wno-unused)
-    CHECK_ENABLE_CXX_FLAG(-Wno-variadic-macros)
+    check_enable_cxx_flag(-Wno-variadic-macros)
-    CHECK_ENABLE_CXX_FLAG(-Wno-parentheses)
+    check_enable_cxx_flag(-Wno-parentheses)
-    CHECK_ENABLE_CXX_FLAG(-Wstrict-null-sentinel)
+    check_enable_cxx_flag(-Wstrict-null-sentinel)
-    CHECK_ENABLE_CXX_FLAG(-Wshadow)
+    check_enable_cxx_flag(-Wshadow)
-    CHECK_ENABLE_CXX_FLAG(-Wshadow-all)
+    check_enable_cxx_flag(-Wshadow-all)
   endif()
 
   if(CMAKE_BUILD_TYPE STREQUAL "Release")
-    CHECK_ENABLE_CXX_FLAG(-flto)
+    check_enable_cxx_flag(-flto)
-    if(CMAKE_CXX_COMPILER_IS_GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "4.8")
+    if(CMAKE_CXX_COMPILER_IS_GCC
+       AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "4.8")
       # Doesn't work with GCC 4.7.2 in Astra Linux 1.5
-      CHECK_ENABLE_CXX_FLAG(-fno-fat-lto-objects)
+      check_enable_cxx_flag(-fno-fat-lto-objects)
     endif()
   endif()
 endif()
 
-if (CMAKE_CXX_COMPILER_IS_GCC)
+if(CMAKE_CXX_COMPILER_IS_GCC)
-  CHECK_ENABLE_CXX_FLAG(-fdiagnostics-color=auto)
+  check_enable_cxx_flag(-fdiagnostics-color=auto)
-  # The -Wmaybe-uninitialized flag is enabled by -Wall, but it is known
+  # The -Wmaybe-uninitialized flag is enabled by -Wall,
-  # to emit a lot of possibly spurious warnings. Let's just disable it.
+  # but it is known to emit a lot of possibly spurious warnings.
-  CHECK_ENABLE_CXX_FLAG(-Wno-maybe-uninitialized)
+  # Let's just disable it.
+  check_enable_cxx_flag(-Wno-maybe-uninitialized)
   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "5.999")
     # NOTE: GCC >= 6 seems to be wrongly warning about visibility attributes
     # in some situations:
     # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80947
     # Let's just disable the warning for now.
-    CHECK_ENABLE_CXX_FLAG(-Wno-attributes)
+    check_enable_cxx_flag(-Wno-attributes)
   endif()
 endif()
 

CMLibConfigHPPGenerate.cmake

@@ -5,5 +5,6 @@ function(cmlib_config_hpp_generate)
   get_property(VERSION_INT GLOBAL PROPERTY VERSION_INT)
   get_property(VERSION_STR GLOBAL PROPERTY VERSION_STR)
   get_property(ORGANIZATION_NAME GLOBAL PROPERTY ORGANIZATION_NAME)
-  configure_file(${CMLIB_MODULE_DIR}/hpp/config.hpp.in ${CMAKE_BINARY_DIR}/include/config.hpp)
+  configure_file(${CMLIB_MODULE_DIR}/hpp/config.hpp.in
+                 ${CMAKE_BINARY_DIR}/include/config.hpp)
 endfunction()

CMLibDisableInSourceBuild.cmake

@@ -9,7 +9,7 @@ get_filename_component(_source_realpath "${CMAKE_SOURCE_DIR}" REALPATH)
 get_filename_component(_binary_realpath "${CMAKE_BINARY_DIR}" REALPATH)
 
 if(${_source_realpath} STREQUAL ${_binary_realpath})
-   message(FATAL_ERROR "In-source builds are not allowed.")
+  message(FATAL_ERROR "In-source builds are not allowed.")
 endif()
 
 # Очистка от сгенерированных файлов
@@ -17,13 +17,11 @@ file(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)
-  file(REMOVE_RECURSE
+  file(REMOVE_RECURSE ${_dir}/CMakeFiles
-    ${_dir}/CMakeFiles
+                      ${_dir}/CMakeCache.txt
-    ${_dir}/CMakeCache.txt
+                      ${_dir}/cmake_install.cmake
-    ${_dir}/cmake_install.cmake
+                      ${_dir}/Makefile
-    ${_dir}/Makefile
+                      ${_dir}/build.ninja
-    ${_dir}/build.ninja
+                      ${_dir}/rules.ninja)
-    ${_dir}/rules.ninja
-    )
 endforeach()
 

CMLibFlagRemove.cmake

@@ -7,14 +7,14 @@
 # Pre: apply_global_cxx_flags_to_all_targets() must be invoked.
 #
 macro(remove_flag_from_target _target _flag)
-    get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS)
+  get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS)
-    if(_target_cxx_flags)
+  if(_target_cxx_flags)
-        list(REMOVE_ITEM _target_cxx_flags ${_flag})
+    list(REMOVE_ITEM _target_cxx_flags ${_flag})
-        set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "${_target_cxx_flags}")
+    set_target_properties(${_target}
-    endif()
+                          PROPERTIES COMPILE_OPTIONS "${_target_cxx_flags}")
+  endif()
 endmacro()
 
-
 #
 # Removes the specified compiler flag from the specified file.
 #   _target     - The target that _file belongs to
@@ -24,48 +24,57 @@ endmacro()
 # Pre: apply_global_cxx_flags_to_all_targets() must be invoked.
 #
 macro(remove_flag_from_file _target _file _flag)
-    get_target_property(_target_sources ${_target} SOURCES)
+  get_target_property(_target_sources ${_target} SOURCES)
-    # Check if a sync is required, in which case we'll force a rewrite of the cache variables.
+  # Check if a sync is required, in which case we'll force a rewrite of the cache variables.
-    if(_flag_sync_required)
+  if(_flag_sync_required)
-        unset(_cached_${_target}_cxx_flags CACHE)
+    unset(_cached_${_target}_cxx_flags CACHE)
-        unset(_cached_${_target}_${_file}_cxx_flags CACHE)
+    unset(_cached_${_target}_${_file}_cxx_flags CACHE)
-    endif()
+  endif()
-    get_target_property(_${_target}_cxx_flags ${_target} COMPILE_OPTIONS)
+  get_target_property(_${_target}_cxx_flags ${_target} COMPILE_OPTIONS)
-    # On first entry, cache the target compile flags and apply them to each source file
+  # On first entry, cache the target compile flags and apply them to each source file
-    # in the target.
+  # in the target.
-    if(NOT _cached_${_target}_cxx_flags)
+  if(NOT _cached_${_target}_cxx_flags)
-        # Obtain and cache the target compiler options, then clear them.
+    # Obtain and cache the target compiler options, then clear them.
-        get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS)
+    get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS)
-        set(_cached_${_target}_cxx_flags "${_target_cxx_flags}" CACHE INTERNAL "")
+    set(_cached_${_target}_cxx_flags "${_target_cxx_flags}" CACHE INTERNAL "")
-        set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "")
+    set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "")
-        # Apply the target compile flags to each source file.
+    # Apply the target compile flags to each source file.
-        foreach(_source_file ${_target_sources})
+    foreach(_source_file ${_target_sources})
-            # Check for pre-existing flags set by set_source_files_properties().
+      # Check for pre-existing flags set by set_source_files_properties().
-            get_source_file_property(_source_file_cxx_flags ${_source_file} COMPILE_FLAGS)
+      get_source_file_property(_source_file_cxx_flags ${_source_file}
-            if(_source_file_cxx_flags)
+                               COMPILE_FLAGS)
-                separate_arguments(_source_file_cxx_flags UNIX_COMMAND ${_source_file_cxx_flags})
+      if(_source_file_cxx_flags)
-                list(APPEND _source_file_cxx_flags "${_target_cxx_flags}")
+        separate_arguments(_source_file_cxx_flags UNIX_COMMAND
-            else()
+                           ${_source_file_cxx_flags})
-                set(_source_file_cxx_flags "${_target_cxx_flags}")
+        list(APPEND _source_file_cxx_flags "${_target_cxx_flags}")
-            endif()
+      else()
-            # Apply the compile flags to the current source file.
+        set(_source_file_cxx_flags "${_target_cxx_flags}")
-            string(REPLACE ";" " " _source_file_cxx_flags_string "${_source_file_cxx_flags}")
+      endif()
-            set_source_files_properties(${_source_file} PROPERTIES COMPILE_FLAGS "${_source_file_cxx_flags_string}")
+      # Apply the compile flags to the current source file.
-        endforeach()
+      string(REPLACE ";" " " _source_file_cxx_flags_string
-    endif()
+                     "${_source_file_cxx_flags}")
-    list(FIND _target_sources ${_file} _file_found_at)
+      set_source_files_properties(${_source_file} PROPERTIES COMPILE_FLAGS
-    if(_file_found_at GREATER -1)
+                                  "${_source_file_cxx_flags_string}")
-        if(NOT _cached_${_target}_${_file}_cxx_flags)
+    endforeach()
-            # Cache the compile flags for the specified file.
+  endif()
-            # This is the list that we'll be removing flags from.
+  list(FIND _target_sources ${_file} _file_found_at)
-            get_source_file_property(_source_file_cxx_flags ${_file} COMPILE_FLAGS)
+  if(_file_found_at GREATER -1)
-            separate_arguments(_source_file_cxx_flags UNIX_COMMAND ${_source_file_cxx_flags})
+    if(NOT _cached_${_target}_${_file}_cxx_flags)
-            set(_cached_${_target}_${_file}_cxx_flags ${_source_file_cxx_flags} CACHE INTERNAL "")
+      # Cache the compile flags for the specified file.
-        endif()
+      # This is the list that we'll be removing flags from.
-        # Remove the specified flag, then re-apply the rest.
+      get_source_file_property(_source_file_cxx_flags ${_file} COMPILE_FLAGS)
-        list(REMOVE_ITEM _cached_${_target}_${_file}_cxx_flags ${_flag})
+      separate_arguments(_source_file_cxx_flags UNIX_COMMAND
-        string(REPLACE ";" " " _cached_${_target}_${_file}_cxx_flags_string "${_cached_${_target}_${_file}_cxx_flags}")
+                         ${_source_file_cxx_flags})
-        set_source_files_properties(${_file} PROPERTIES COMPILE_FLAGS "${_cached_${_target}_${_file}_cxx_flags_string}")
+      set(_cached_${_target}_${_file}_cxx_flags ${_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})
+    string(REPLACE ";" " " _cached_${_target}_${_file}_cxx_flags_string
+                   "${_cached_${_target}_${_file}_cxx_flags}")
+    set_source_files_properties(
+      ${_file} PROPERTIES COMPILE_FLAGS
+      "${_cached_${_target}_${_file}_cxx_flags_string}")
+  endif()
 endmacro()
 

CMLibGlobalVariables.cmake

@@ -4,7 +4,6 @@ string(REGEX REPLACE "[ -]" "_" _project_name_fixed ${_project_name_uppercase})
 set(CMLIB_PROJECT_NAME_CANONICAL ${_project_name_fixed})
 
 # CMLIB_MODULE_DIR
-set(CMLIB_MODULE_DIR "")
 foreach(_m ${CMAKE_MODULE_PATH})
   if(EXISTS ${_m}/CMLibCommon.cmake)
     get_filename_component(CMLIB_MODULE_DIR ${_m}/CMLibCommon.cmake DIRECTORY)
@@ -12,3 +11,12 @@ foreach(_m ${CMAKE_MODULE_PATH})
   endif()
 endforeach()
 
+if(CMLIB_MODULE_DIR)
+  if(NOT DEFINED CMLIB_THIRDPARTY_DIR)
+    set(CMLIB_THIRDPARTY_DIR "${CMLIB_MODULE_DIR}/thirdparty")
+    list(APPEND CMAKE_MODULE_PATH ${CMLIB_THIRDPARTY_DIR})
+  endif()
+else()
+  message(FATAL_ERROR "CMLib directory not found.")
+endif()
+

CMLibInstallInOpt.cmake

@@ -1,6 +0,0 @@
-option(INSTALL_TO_OPT "Install to proprietary /opt hierarchy" FALSE)
-
-if(INSTALL_TO_OPT)
-  string(TOLOWER "/opt/${ORGANIZATION_NAME}/${PROJECT_NAME}" CMAKE_INSTALL_PREFIX)
-endif()
-

CMLibLSBInfo.cmake

@@ -6,13 +6,16 @@ find_program(_lsb_release_executable lsb_release)
 
 if(_lsb_release_executable)
   execute_process(COMMAND ${_lsb_release_executable} -sc
-    OUTPUT_VARIABLE LSB_CODENAME OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_VARIABLE LSB_CODENAME
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
 
   execute_process(COMMAND ${_lsb_release_executable} -sr
-    OUTPUT_VARIABLE LSB_RELEASE OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_VARIABLE LSB_RELEASE
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
 
   execute_process(COMMAND ${_lsb_release_executable} -si
-    OUTPUT_VARIABLE LSB_DISTRIBUTOR_ID OUTPUT_STRIP_TRAILING_WHITESPACE)
+                  OUTPUT_VARIABLE LSB_DISTRIBUTOR_ID
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
 else()
   set(LSB_DISTRIBUTOR_ID "unknown")
   set(LSB_RELEASE "unknown")

CMLibOrganizationName.cmake

@@ -6,7 +6,9 @@ function(set_organization_name)
     message(FATAL_ERROR "File ${ORGANIZATION_FILE} doesn't exist")
   endif()
   file(READ "${_organization_file}" _org)
-  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${_organization_file})
+  set_property(DIRECTORY
+               APPEND
+               PROPERTY CMAKE_CONFIGURE_DEPENDS ${_organization_file})
 
   if(NOT "${_org}" MATCHES "^([0-9A-Za-z ,.]+)\n")
     message(FATAL_ERROR "File ${_organization_file} has wrong format")

CMLibProjectVersion.cmake

@@ -7,7 +7,9 @@ function(set_project_version)
     message(FATAL_ERROR "File ${_version_file} doesn't exists")
   endif()
   file(READ "${_version_file}" _version)
-  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${_version_file})
+  set_property(DIRECTORY
+               APPEND
+               PROPERTY CMAKE_CONFIGURE_DEPENDS ${_version_file})
 
   if(NOT "${_version}" MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)\n")
     message(FATAL_ERROR "${_version_file} has wrong format")
@@ -18,8 +20,11 @@ function(set_project_version)
   set_property(GLOBAL PROPERTY VERSION_MAJOR ${CMAKE_MATCH_1})
   set_property(GLOBAL PROPERTY VERSION_MINOR ${CMAKE_MATCH_2})
   set_property(GLOBAL PROPERTY VERSION_PATCH ${CMAKE_MATCH_3})
-  math(EXPR _version_int "(${CMAKE_MATCH_1} << 16) + (${CMAKE_MATCH_2} << 8) + ${CMAKE_MATCH_3}")
+  math(EXPR _version_int
+       "(${CMAKE_MATCH_1} << 16) + (${CMAKE_MATCH_2} << 8) + ${CMAKE_MATCH_3}")
   set_property(GLOBAL PROPERTY VERSION_INT ${_version_int})
-  set_property(GLOBAL PROPERTY VERSION_STR "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
+  set_property(GLOBAL
+               PROPERTY VERSION_STR
+                        "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
 endfunction()
 

CMLibQtTranslation.cmake

@@ -29,18 +29,23 @@ function(qt_translation)
       <!DOCTYPE TS>
       <TS version=\"2.1\" language=\"${_lang}\"></TS>")
     endif()
-    string(APPEND L10N_QRC_BODY "<file alias=\"${_qm}\">${CMAKE_BINARY_DIR}/${_qm}</file>\n")
+    string(APPEND L10N_QRC_BODY
+           "<file alias=\"${_qm}\">${CMAKE_BINARY_DIR}/${_qm}</file>\n")
 
     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${_qm}
-      COMMAND ${Qt5_LRELEASE_EXECUTABLE} ARGS ${_ts_dir}/${_ts} -qm ${CMAKE_BINARY_DIR}/${_qm}
+                       COMMAND ${Qt5_LRELEASE_EXECUTABLE}
-      DEPENDS ${_ts_dir}/${_ts})
+                               ARGS ${_ts_dir}/${_ts} -qm
+                                    ${CMAKE_BINARY_DIR}/${_qm}
+                       DEPENDS ${_ts_dir}/${_ts})
   endforeach()
 
   add_custom_command(OUTPUT ${_ts_list}
-    COMMAND ${Qt5_LUPDATE_EXECUTABLE} ARGS ${_sources_list} -ts ${_ts_list}
+                     COMMAND ${Qt5_LUPDATE_EXECUTABLE}
-    DEPENDS ${_sources_list})
+                             ARGS ${_sources_list} -ts ${_ts_list}
+                     DEPENDS ${_sources_list})
 
-  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}/${_target}_l10n.qrc)
   qt5_add_resources(_qrc ${CMAKE_BINARY_DIR}/${_target}_l10n.qrc)
   add_custom_target(_qrc_target DEPENDS ${_qrc})
 

CMLibUninstall.cmake

@@ -1,9 +1,8 @@
 if(NOT TARGET uninstall)
-  configure_file(
+  configure_file("${CMLIB_MODULE_DIR}/CMLibUninstall.cmake.in"
-    "${CMLIB_MODULE_DIR}/CMLibUninstall.cmake.in"
+                 "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)
-    "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
-    IMMEDIATE @ONLY)
 
   add_custom_target(uninstall
-    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/cmake_uninstall.cmake)
+                    COMMAND ${CMAKE_COMMAND} -P
+                            ${CMAKE_BINARY_DIR}/cmake_uninstall.cmake)
 endif()

Makefile

@@ -0,0 +1,12 @@
+# To force update modules execute command:
+# make -B
+
+download: thirdparty/cotire.cmake thirdparty/PVS-Studio.cmake
+
+thirdparty/cotire.cmake:
+	wget -O thirdparty/cotire.cmake https://raw.githubusercontent.com/sakra/cotire/master/CMake/cotire.cmake
+
+thirdparty/PVS-Studio.cmake:
+	wget -O thirdparty/PVS-Studio.cmake https://raw.githubusercontent.com/viva64/pvs-studio-cmake-examples/master/PVS-Studio.cmake
+	dos2unix thirdparty/PVS-Studio.cmake
+

thirdparty/PVS-Studio.cmake

@@ -0,0 +1,546 @@
+# 2006-2008 (c) Viva64.com Team
+# 2008-2018 (c) OOO "Program Verification Systems"
+#
+# Version 12
+
+cmake_minimum_required(VERSION 2.8.12)
+cmake_policy(SET CMP0054 NEW)
+
+if (PVS_STUDIO_AS_SCRIPT)
+    # This code runs at build time.
+    # It executes pvs-studio-analyzer and propagates its return value.
+
+    set(in_cl_params FALSE)
+    set(additional_args)
+
+    foreach (arg ${PVS_STUDIO_COMMAND})
+        if (NOT in_cl_params)
+            if ("${arg}" STREQUAL "--cl-params")
+                set(in_cl_params TRUE)
+            endif ()
+        else ()
+            # A workaround for macOS frameworks (e.g. QtWidgets.framework)
+            # You can test this workaround on this project: https://github.com/easyaspi314/MidiEditor/tree/gba
+            if (APPLE AND "${arg}" MATCHES "^-I(.*)\\.framework$")
+                STRING(REGEX REPLACE "^-I(.*)\\.framework$" "\\1.framework" framework "${arg}")
+                if (IS_ABSOLUTE "${framework}")
+                    get_filename_component(framework "${framework}" DIRECTORY)
+                    list(APPEND additional_args "-iframework")
+                    list(APPEND additional_args "${framework}")
+                endif ()
+            endif ()
+        endif ()
+    endforeach ()
+
+    execute_process(COMMAND ${PVS_STUDIO_COMMAND} ${additional_args}
+                    ERROR_VARIABLE error
+                    RESULT_VARIABLE result)
+
+    set(stderr_type "")
+
+    if (result)
+        set(stderr_type FATAL_ERROR)
+    endif ()
+
+    if (result OR error)
+        message(${stderr_type} "${error}")
+    endif ()
+
+    return()
+endif ()
+
+if(__PVS_STUDIO_INCLUDED)
+    return()
+endif()
+set(__PVS_STUDIO_INCLUDED TRUE)
+
+set(PVS_STUDIO_SCRIPT "${CMAKE_CURRENT_LIST_FILE}")
+
+function (pvs_studio_log TEXT)
+    if (PVS_STUDIO_DEBUG)
+        message("PVS-Studio: ${TEXT}")
+    endif ()
+endfunction ()
+
+function (pvs_studio_relative_path VAR ROOT FILEPATH)
+    set("${VAR}" "${FILEPATH}" PARENT_SCOPE)
+    if ("${FILEPATH}" MATCHES "^/.*$" OR "${FILEPATH}" MATCHES "^.:/.*$")
+        file(RELATIVE_PATH RPATH "${ROOT}" "${FILEPATH}")
+        if (NOT "${RPATH}" MATCHES "^\\.\\..*$")
+            set("${VAR}" "${RPATH}" PARENT_SCOPE)
+        endif ()
+    endif ()
+endfunction ()
+
+function (pvs_studio_join_path VAR DIR1 DIR2)
+    if ("${DIR2}" MATCHES "^(/|~|.:/).*$" OR "${DIR1}" STREQUAL "")
+        set("${VAR}" "${DIR2}" PARENT_SCOPE)
+    else ()
+        set("${VAR}" "${DIR1}/${DIR2}" PARENT_SCOPE)
+    endif ()
+endfunction ()
+
+macro (pvs_studio_append_flags_from_property CXX C DIR PREFIX)
+    if (NOT "${PROPERTY}" STREQUAL "NOTFOUND" AND NOT "${PROPERTY}" STREQUAL "PROPERTY-NOTFOUND")
+        foreach (PROP ${PROPERTY})
+            pvs_studio_join_path(PROP "${DIR}" "${PROP}")
+
+            if (APPLE AND "${PREFIX}" STREQUAL "-I" AND IS_ABSOLUTE "${PROP}" AND "${PROP}" MATCHES "\\.framework$")
+                get_filename_component(FRAMEWORK "${PROP}" DIRECTORY)
+                list(APPEND "${CXX}" "-iframework")
+                list(APPEND "${CXX}" "${FRAMEWORK}")
+                list(APPEND "${C}" "-iframework")
+                list(APPEND "${C}" "${FRAMEWORK}")
+                pvs_studio_log("framework: ${FRAMEWORK}")
+            elseif (NOT "${PROP}" STREQUAL "")
+                list(APPEND "${CXX}" "${PREFIX}${PROP}")
+                list(APPEND "${C}" "${PREFIX}${PROP}")
+            endif()
+        endforeach ()
+    endif ()
+endmacro ()
+
+macro (pvs_studio_append_standard_flag FLAGS STANDARD)
+    if ("${STANDARD}" MATCHES "^(99|11|14|17)$")
+        if ("${PVS_STUDIO_PREPROCESSOR}" MATCHES "gcc|clang")
+            list(APPEND "${FLAGS}" "-std=c++${STANDARD}")
+        endif ()
+    endif ()
+endmacro ()
+
+function (pvs_studio_set_directory_flags DIRECTORY CXX C)
+    set(CXX_FLAGS "${${CXX}}")
+    set(C_FLAGS "${${C}}")
+
+    get_directory_property(PROPERTY DIRECTORY "${DIRECTORY}" INCLUDE_DIRECTORIES)
+    pvs_studio_append_flags_from_property(CXX_FLAGS C_FLAGS "${DIRECTORY}" "-I")
+
+    get_directory_property(PROPERTY DIRECTORY "${DIRECTORY}" COMPILE_DEFINITIONS)
+    pvs_studio_append_flags_from_property(CXX_FLAGS C_FLAGS "" "-D")
+
+    set("${CXX}" "${CXX_FLAGS}" PARENT_SCOPE)
+    set("${C}" "${C_FLAGS}" PARENT_SCOPE)
+endfunction ()
+
+function (pvs_studio_set_target_flags TARGET CXX C)
+    set(CXX_FLAGS "${${CXX}}")
+    set(C_FLAGS "${${C}}")
+
+    set(prop_incdirs "$<TARGET_PROPERTY:${TARGET},INCLUDE_DIRECTORIES>")
+    list(APPEND CXX_FLAGS "$<$<BOOL:${prop_incdirs}>:-I$<JOIN:${prop_incdirs},$<SEMICOLON>-I>>")
+    list(APPEND C_FLAGS "$<$<BOOL:${prop_incdirs}>:-I$<JOIN:${prop_incdirs},$<SEMICOLON>-I>>")
+
+    set(prop_compdefs "$<TARGET_PROPERTY:${TARGET},COMPILE_DEFINITIONS>")
+    list(APPEND CXX_FLAGS "$<$<BOOL:${prop_compdefs}>:-D$<JOIN:${prop_compdefs},$<SEMICOLON>-D>>")
+    list(APPEND C_FLAGS "$<$<BOOL:${prop_compdefs}>:-D$<JOIN:${prop_compdefs},$<SEMICOLON>-D>>")
+
+    set("${CXX}" "${CXX_FLAGS}" PARENT_SCOPE)
+    set("${C}" "${C_FLAGS}" PARENT_SCOPE)
+endfunction ()
+
+function (pvs_studio_set_source_file_flags SOURCE)
+    set(LANGUAGE "")
+
+    string(TOLOWER "${SOURCE}" SOURCE_LOWER)
+    if ("${LANGUAGE}" STREQUAL "" AND "${SOURCE_LOWER}" MATCHES "^.*\\.(c|cpp|cc|cx|cxx|cp|c\\+\\+)$")
+        if ("${SOURCE}" MATCHES "^.*\\.c$")
+            set(LANGUAGE C)
+        else ()
+            set(LANGUAGE CXX)
+        endif ()
+    endif ()
+
+    if ("${LANGUAGE}" STREQUAL "C")
+        set(CL_PARAMS ${PVS_STUDIO_C_FLAGS} ${PVS_STUDIO_TARGET_C_FLAGS} -DPVS_STUDIO)
+    elseif ("${LANGUAGE}" STREQUAL "CXX")
+        set(CL_PARAMS ${PVS_STUDIO_CXX_FLAGS} ${PVS_STUDIO_TARGET_CXX_FLAGS} -DPVS_STUDIO)
+    endif ()
+
+    set(PVS_STUDIO_LANGUAGE "${LANGUAGE}" PARENT_SCOPE)
+    set(PVS_STUDIO_CL_PARAMS "${CL_PARAMS}" PARENT_SCOPE)
+endfunction ()
+
+function (pvs_studio_analyze_file SOURCE SOURCE_DIR BINARY_DIR)
+    set(PLOGS ${PVS_STUDIO_PLOGS})
+    pvs_studio_set_source_file_flags("${SOURCE}")
+
+    get_filename_component(SOURCE "${SOURCE}" REALPATH)
+
+    get_source_file_property(PROPERTY "${SOURCE}" HEADER_FILE_ONLY)
+    if (PROPERTY)
+        return()
+    endif ()
+
+    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")
+    get_filename_component(LOG "${LOG}" REALPATH)
+    get_filename_component(PARENT_DIR "${LOG}" DIRECTORY)
+
+    if (EXISTS "${SOURCE}" AND NOT TARGET "${LOG}" AND NOT "${PVS_STUDIO_LANGUAGE}" STREQUAL "")
+        # A workaround to support implicit dependencies for ninja generators.
+        set(depPvsArg)
+        set(depCommandArg)
+        if (CMAKE_VERSION VERSION_GREATER 3.6 AND "${CMAKE_GENERATOR}" STREQUAL "Ninja")
+            pvs_studio_relative_path(relLog "${CMAKE_BINARY_DIR}" "${LOG}")
+            set(depPvsArg --dep-file "${LOG}.d" --dep-file-target "${relLog}")
+            set(depCommandArg DEPFILE "${LOG}.d")
+        endif ()
+
+        # https://public.kitware.com/Bug/print_bug_page.php?bug_id=14353
+        # https://public.kitware.com/Bug/file/5436/expand_command.cmake
+        #
+        # It is a workaround to expand generator expressions.
+        set(cmdline "${PVS_STUDIO_BIN}" analyze
+                    --output-file "${LOG}"
+                    --source-file "${SOURCE}"
+                    ${depPvsArg}
+                    ${PVS_STUDIO_ARGS}
+                    --cl-params "${PVS_STUDIO_CL_PARAMS}" "${SOURCE}")
+
+        string(REPLACE ";" "$<SEMICOLON>" cmdline "${cmdline}")
+        set(pvscmd "${CMAKE_COMMAND}"
+                   -D PVS_STUDIO_AS_SCRIPT=TRUE
+                   -D "PVS_STUDIO_COMMAND=${cmdline}"
+                   -P "${PVS_STUDIO_SCRIPT}"
+        )
+
+        add_custom_command(OUTPUT "${LOG}"
+                           COMMAND "${CMAKE_COMMAND}" -E make_directory "${PARENT_DIR}"
+                           COMMAND "${CMAKE_COMMAND}" -E remove_directory "${LOG}"
+                           COMMAND ${pvscmd}
+                           WORKING_DIRECTORY "${BINARY_DIR}"
+                           DEPENDS "${SOURCE}" "${PVS_STUDIO_CONFIG}"
+                           IMPLICIT_DEPENDS "${PVS_STUDIO_LANGUAGE}" "${SOURCE}"
+                           ${depCommandArg}
+                           VERBATIM
+                           COMMENT "Analyzing ${PVS_STUDIO_LANGUAGE} file ${SOURCE_RELATIVE}")
+        list(APPEND PLOGS "${LOG}")
+    endif ()
+    set(PVS_STUDIO_PLOGS "${PLOGS}" PARENT_SCOPE)
+endfunction ()
+
+function (pvs_studio_analyze_target TARGET DIR)
+    set(PVS_STUDIO_PLOGS "${PVS_STUDIO_PLOGS}")
+    set(PVS_STUDIO_TARGET_CXX_FLAGS "")
+    set(PVS_STUDIO_TARGET_C_FLAGS "")
+
+    get_target_property(PROPERTY "${TARGET}" SOURCES)
+    pvs_studio_relative_path(BINARY_DIR "${CMAKE_SOURCE_DIR}" "${DIR}")
+    if ("${BINARY_DIR}" MATCHES "^/.*$")
+        pvs_studio_join_path(BINARY_DIR "${CMAKE_BINARY_DIR}" "PVS-Studio/__${BINARY_DIR}")
+    else ()
+        pvs_studio_join_path(BINARY_DIR "${CMAKE_BINARY_DIR}" "${BINARY_DIR}")
+    endif ()
+
+    file(MAKE_DIRECTORY "${BINARY_DIR}")
+
+    pvs_studio_set_directory_flags("${DIR}" PVS_STUDIO_TARGET_CXX_FLAGS PVS_STUDIO_TARGET_C_FLAGS)
+    pvs_studio_set_target_flags("${TARGET}" PVS_STUDIO_TARGET_CXX_FLAGS PVS_STUDIO_TARGET_C_FLAGS)
+
+    if (NOT "${PROPERTY}" STREQUAL "NOTFOUND" AND NOT "${PROPERTY}" STREQUAL "PROPERTY-NOTFOUND")
+        foreach (SOURCE ${PROPERTY})
+            pvs_studio_join_path(SOURCE "${DIR}" "${SOURCE}")
+            pvs_studio_analyze_file("${SOURCE}" "${DIR}" "${BINARY_DIR}")
+        endforeach ()
+    endif ()
+
+    set(PVS_STUDIO_PLOGS "${PVS_STUDIO_PLOGS}" PARENT_SCOPE)
+endfunction ()
+
+set(PVS_STUDIO_RECURSIVE_TARGETS)
+set(PVS_STUDIO_RECURSIVE_TARGETS_NEW)
+
+macro(pvs_studio_get_recursive_targets TARGET)
+    get_target_property(libs "${TARGET}" LINK_LIBRARIES)
+    foreach (lib IN LISTS libs)
+        list(FIND PVS_STUDIO_RECURSIVE_TARGETS "${lib}" index)
+        if (TARGET "${lib}" AND "${index}" STREQUAL -1)
+            get_target_property(target_type "${lib}" TYPE)
+            if (NOT "${target_type}" STREQUAL "INTERFACE_LIBRARY")
+                list(APPEND PVS_STUDIO_RECURSIVE_TARGETS "${lib}")
+                list(APPEND PVS_STUDIO_RECURSIVE_TARGETS_NEW "${lib}")
+                pvs_studio_get_recursive_targets("${lib}")
+            endif ()
+        endif ()
+    endforeach ()
+endmacro()
+
+option(PVS_STUDIO_DISABLE OFF "Disable PVS-Studio targets")
+option(PVS_STUDIO_DEBUG OFF "Add debug info")
+
+# pvs_studio_add_target
+# Target options:
+# ALL                           add PVS-Studio target to default build (default: off)
+# TARGET target                 name of analysis target (default: pvs)
+# ANALYZE targets...            targets to analyze
+# RECURSIVE                     analyze target's dependencies (requires CMake 3.5+)
+# COMPILE_COMMANDS              use compile_commands.json instead of targets (specified by the 'ANALYZE' option) to determine files for analysis
+#                               (set CMAKE_EXPORT_COMPILE_COMMANDS, available only for Makefile and Ninja generators)
+#
+# Output options:
+# OUTPUT                        prints report to stdout
+# LOG path                      path to report (default: ${CMAKE_CURRENT_BINARY_DIR}/PVS-Studio.log)
+# FORMAT format                 format of report
+# MODE mode                     analyzers/levels filter (default: GA:1,2)
+# HIDE_HELP                     do not print help message
+#
+# Analyzer options:
+# PLATFORM name                 linux32/linux64 (default: linux64)
+# PREPROCESSOR name             preprocessor type: gcc/clang (default: auto detected)
+# LICENSE path                  path to PVS-Studio.lic (default: ~/.config/PVS-Studio/PVS-Studio.lic)
+# CONFIG path                   path to PVS-Studio.cfg
+# CFG_TEXT text                 embedded PVS-Studio.cfg
+# KEEP_COMBINED_PLOG            do not delete combined plog file *.pvs.raw for further processing with plog-converter
+#
+# Misc options:
+# DEPENDS targets..             additional target dependencies
+# SOURCES path...               list of source files to analyze
+# BIN path                      path to pvs-studio-analyzer (Unix) or CompilerCommandsAnalyzer.exe (Windows)
+# CONVERTER path                path to plog-converter (Unix) or HtmlGenerator.exe (Windows)
+# C_FLAGS flags...              additional C_FLAGS
+# CXX_FLAGS flags...            additional CXX_FLAGS
+# ARGS args...                  additional pvs-studio-analyzer/CompilerCommandsAnalyzer.exe flags
+function (pvs_studio_add_target)
+    macro (default VAR VALUE)
+        if ("${${VAR}}" STREQUAL "")
+            set("${VAR}" "${VALUE}")
+        endif ()
+    endmacro ()
+
+    set(PVS_STUDIO_SUPPORTED_PREPROCESSORS "gcc|clang|visualcpp")
+    if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+        set(DEFAULT_PREPROCESSOR "clang")
+    elseif (MSVC)
+        set(DEFAULT_PREPROCESSOR "visualcpp")
+    else ()
+        set(DEFAULT_PREPROCESSOR "gcc")
+    endif ()
+
+    set(OPTIONAL OUTPUT ALL RECURSIVE HIDE_HELP KEEP_COMBINED_PLOG COMPILE_COMMANDS)
+    set(SINGLE LICENSE CONFIG TARGET LOG FORMAT BIN CONVERTER PLATFORM PREPROCESSOR CFG_TEXT)
+    set(MULTI SOURCES C_FLAGS CXX_FLAGS ARGS DEPENDS ANALYZE MODE)
+    cmake_parse_arguments(PVS_STUDIO "${OPTIONAL}" "${SINGLE}" "${MULTI}" ${ARGN})
+
+    if ("${PVS_STUDIO_CONFIG}" STREQUAL "" OR NOT "${PVS_STUDIO_CFG_TEXT}" STREQUAL "")
+        set(PVS_STUDIO_EMPTY_CONFIG ON)
+    else ()
+        set(PVS_STUDIO_EMPTY_CONFIG OFF)
+    endif ()
+
+    default(PVS_STUDIO_CFG_TEXT "analysis-mode=31")
+    default(PVS_STUDIO_CONFIG "${CMAKE_BINARY_DIR}/PVS-Studio.cfg")
+    default(PVS_STUDIO_C_FLAGS "")
+    default(PVS_STUDIO_CXX_FLAGS "")
+    default(PVS_STUDIO_TARGET "pvs")
+    default(PVS_STUDIO_LOG "PVS-Studio.log")
+
+    set(PATHS)
+    if (WIN32)
+        set(ROOT "PROGRAMFILES(X86)")
+        set(ROOT "$ENV{${ROOT}}/PVS-Studio")
+        string(REPLACE \\ / ROOT "${ROOT}")
+
+        if (EXISTS "${ROOT}")
+            set(PATHS "${ROOT}")
+        endif ()
+
+        default(PVS_STUDIO_BIN "CompilerCommandsAnalyzer.exe")
+        default(PVS_STUDIO_CONVERTER "HtmlGenerator.exe")
+    else ()
+        default(PVS_STUDIO_BIN "pvs-studio-analyzer")
+        default(PVS_STUDIO_CONVERTER "plog-converter")
+    endif ()
+
+    find_program(PVS_STUDIO_BIN_PATH "${PVS_STUDIO_BIN}" ${PATHS})
+    set(PVS_STUDIO_BIN "${PVS_STUDIO_BIN_PATH}")
+
+    if (NOT EXISTS "${PVS_STUDIO_BIN}")
+        message(FATAL_ERROR "pvs-studio-analyzer is not found")
+    endif ()
+
+    find_program(PVS_STUDIO_CONVERTER_PATH "${PVS_STUDIO_CONVERTER}" ${PATHS})
+    set(PVS_STUDIO_CONVERTER "${PVS_STUDIO_CONVERTER_PATH}")
+
+    if (NOT EXISTS "${PVS_STUDIO_CONVERTER}")
+        message(FATAL_ERROR "plog-converter is not found")
+    endif ()
+
+    default(PVS_STUDIO_MODE "GA:1,2")
+    default(PVS_STUDIO_PREPROCESSOR "${DEFAULT_PREPROCESSOR}")
+    if (WIN32)
+        default(PVS_STUDIO_PLATFORM "x64")
+    else ()
+        default(PVS_STUDIO_PLATFORM "linux64")
+    endif ()
+
+    string(REPLACE ";" "+" PVS_STUDIO_MODE "${PVS_STUDIO_MODE}")
+
+    if (PVS_STUDIO_EMPTY_CONFIG)
+        set(PVS_STUDIO_CONFIG_COMMAND "${CMAKE_COMMAND}" -E echo "${PVS_STUDIO_CFG_TEXT}" > "${PVS_STUDIO_CONFIG}")
+    else ()
+        set(PVS_STUDIO_CONFIG_COMMAND "${CMAKE_COMMAND}" -E touch "${PVS_STUDIO_CONFIG}")
+    endif ()
+
+    add_custom_command(OUTPUT "${PVS_STUDIO_CONFIG}"
+                       COMMAND ${PVS_STUDIO_CONFIG_COMMAND}
+                       WORKING_DIRECTORY "${BINARY_DIR}"
+                       COMMENT "Generating PVS-Studio.cfg")
+
+    if (NOT "${PVS_STUDIO_PREPROCESSOR}" MATCHES "^${PVS_STUDIO_SUPPORTED_PREPROCESSORS}$")
+        message(FATAL_ERROR "Preprocessor ${PVS_STUDIO_PREPROCESSOR} isn't supported. Available options: ${PVS_STUDIO_SUPPORTED_PREPROCESSORS}.")
+    endif ()
+
+    pvs_studio_append_standard_flag(PVS_STUDIO_CXX_FLAGS "${CMAKE_CXX_STANDARD}")
+    pvs_studio_set_directory_flags("${CMAKE_CURRENT_SOURCE_DIR}" PVS_STUDIO_CXX_FLAGS PVS_STUDIO_C_FLAGS)
+
+    if (NOT "${PVS_STUDIO_LICENSE}" STREQUAL "")
+        pvs_studio_join_path(PVS_STUDIO_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}" "${PVS_STUDIO_LICENSE}")
+        list(APPEND PVS_STUDIO_ARGS --lic-file "${PVS_STUDIO_LICENSE}")
+    endif ()
+
+    list(APPEND PVS_STUDIO_ARGS --cfg "${PVS_STUDIO_CONFIG}"
+                                --platform "${PVS_STUDIO_PLATFORM}"
+                                --preprocessor "${PVS_STUDIO_PREPROCESSOR}")
+
+    if (NOT "${CMAKE_CXX_COMPILER}" STREQUAL "")
+        list(APPEND PVS_STUDIO_ARGS --cxx "${CMAKE_CXX_COMPILER}")
+    endif ()
+
+    if (NOT "${CMAKE_C_COMPILER}" STREQUAL "")
+        list(APPEND PVS_STUDIO_ARGS --cc "${CMAKE_C_COMPILER}")
+    endif ()
+
+    set(PVS_STUDIO_PLOGS "")
+
+    set(PVS_STUDIO_RECURSIVE_TARGETS_NEW)
+    if (${PVS_STUDIO_RECURSIVE})
+        foreach (TARGET IN LISTS PVS_STUDIO_ANALYZE)
+            list(APPEND PVS_STUDIO_RECURSIVE_TARGETS_NEW "${TARGET}")
+            pvs_studio_get_recursive_targets("${TARGET}")
+        endforeach ()
+    endif ()
+
+    set(inc_path)
+
+    foreach (TARGET ${PVS_STUDIO_ANALYZE})
+        set(DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+        string(FIND "${TARGET}" ":" DELIM)
+        if ("${DELIM}" GREATER "-1")
+            math(EXPR DELIMI "${DELIM}+1")
+            string(SUBSTRING "${TARGET}" "${DELIMI}" "-1" DIR)
+            string(SUBSTRING "${TARGET}" "0" "${DELIM}" TARGET)
+            pvs_studio_join_path(DIR "${CMAKE_CURRENT_SOURCE_DIR}" "${DIR}")
+        else ()
+            get_target_property(TARGET_SOURCE_DIR "${TARGET}" SOURCE_DIR)
+            if (EXISTS "${TARGET_SOURCE_DIR}")
+                set(DIR "${TARGET_SOURCE_DIR}")
+            endif ()
+        endif ()
+        pvs_studio_analyze_target("${TARGET}" "${DIR}")
+        list(APPEND PVS_STUDIO_DEPENDS "${TARGET}")
+
+        if ("${inc_path}" STREQUAL "")
+            set(inc_path "$<TARGET_PROPERTY:${TARGET},INCLUDE_DIRECTORIES>")
+        else ()
+            set(inc_path "${inc_path}$<SEMICOLON>$<TARGET_PROPERTY:${TARGET},INCLUDE_DIRECTORIES>")
+        endif ()
+    endforeach ()
+
+    foreach (TARGET ${PVS_STUDIO_RECURSIVE_TARGETS_NEW})
+        set(DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+        get_target_property(TARGET_SOURCE_DIR "${TARGET}" SOURCE_DIR)
+        if (EXISTS "${TARGET_SOURCE_DIR}")
+            set(DIR "${TARGET_SOURCE_DIR}")
+        endif ()
+        pvs_studio_analyze_target("${TARGET}" "${DIR}")
+        list(APPEND PVS_STUDIO_DEPENDS "${TARGET}")
+    endforeach ()
+
+    set(PVS_STUDIO_TARGET_CXX_FLAGS "")
+    set(PVS_STUDIO_TARGET_C_FLAGS "")
+    foreach (SOURCE ${PVS_STUDIO_SOURCES})
+        pvs_studio_analyze_file("${SOURCE}" "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
+    endforeach ()
+
+    if (PVS_STUDIO_COMPILE_COMMANDS)
+        set(COMPILE_COMMANDS_LOG "${PVS_STUDIO_LOG}.pvs.analyzer.raw")
+        if (NOT CMAKE_EXPORT_COMPILE_COMMANDS)
+            message(FATAL_ERROR "You should set CMAKE_EXPORT_COMPILE_COMMANDS to TRUE")
+        endif ()
+        add_custom_command(
+            OUTPUT "${COMPILE_COMMANDS_LOG}"
+            COMMAND "${PVS_STUDIO_BIN}" analyze -i
+                    --output-file "${COMPILE_COMMANDS_LOG}.always"
+                    ${PVS_STUDIO_ARGS}
+            COMMENT "Analyzing with PVS-Studio"
+            WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+            DEPENDS "${PVS_STUDIO_CONFIG}"
+        )
+        list(APPEND PVS_STUDIO_PLOGS_LOGS "${COMPILE_COMMANDS_LOG}.always")
+        list(APPEND PVS_STUDIO_PLOGS_DEPENDENCIES "${COMPILE_COMMANDS_LOG}")
+    endif ()
+
+    pvs_studio_relative_path(LOG_RELATIVE "${CMAKE_BINARY_DIR}" "${PVS_STUDIO_LOG}")
+    if (PVS_STUDIO_PLOGS OR PVS_STUDIO_COMPILE_COMMANDS)
+        if (WIN32)
+            string(REPLACE / \\ PVS_STUDIO_PLOGS "${PVS_STUDIO_PLOGS}")
+        endif ()
+        if (WIN32)
+            set(COMMANDS COMMAND type ${PVS_STUDIO_PLOGS} ${PVS_STUDIO_PLOGS_LOGS} > "${PVS_STUDIO_LOG}" 2>nul)
+        else ()
+            set(COMMANDS COMMAND cat ${PVS_STUDIO_PLOGS} ${PVS_STUDIO_PLOGS_LOGS} > "${PVS_STUDIO_LOG}")
+        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")
+            endif ()
+            list(APPEND COMMANDS
+                COMMAND "${CMAKE_COMMAND}" -E remove -f "${PVS_STUDIO_LOG}.pvs.raw"
+                COMMAND "${CMAKE_COMMAND}" -E rename "${PVS_STUDIO_LOG}" "${PVS_STUDIO_LOG}.pvs.raw"
+                COMMAND "${PVS_STUDIO_CONVERTER}" -t "${PVS_STUDIO_FORMAT}" "${PVS_STUDIO_LOG}.pvs.raw" -o "${PVS_STUDIO_LOG}" -a "${PVS_STUDIO_MODE}"
+                )
+            if(NOT PVS_STUDIO_KEEP_COMBINED_PLOG)
+                list(APPEND COMMANDS COMMAND "${CMAKE_COMMAND}" -E remove -f "${PVS_STUDIO_LOG}.pvs.raw")
+            endif()
+        endif ()
+    else ()
+        set(COMMANDS COMMAND "${CMAKE_COMMAND}" -E touch "${PVS_STUDIO_LOG}")
+        set(COMMENT "Generating ${LOG_RELATIVE}: no sources found")
+    endif ()
+
+    if (WIN32)
+        string(REPLACE / \\ PVS_STUDIO_LOG "${PVS_STUDIO_LOG}")
+    endif ()
+
+    add_custom_command(OUTPUT "${PVS_STUDIO_LOG}"
+                       ${COMMANDS}
+                       COMMENT "${COMMENT}"
+                       DEPENDS ${PVS_STUDIO_PLOGS} ${PVS_STUDIO_PLOGS_DEPENDENCIES}
+                       WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
+
+    if (PVS_STUDIO_ALL)
+        set(ALL "ALL")
+    else ()
+        set(ALL "")
+    endif ()
+
+    if (PVS_STUDIO_OUTPUT)
+        if (PVS_STUDIO_HIDE_HELP AND NOT WIN32)
+            set(COMMANDS COMMAND grep -v " error: Help:" ${PVS_STUDIO_LOG} 1>&2 || exit 0)
+        elseif (WIN32)
+            set(COMMANDS COMMAND type "${PVS_STUDIO_LOG}" 1>&2)
+        else ()
+            set(COMMANDS COMMAND cat "${PVS_STUDIO_LOG}" 1>&2)
+        endif()
+    else ()
+        set(COMMANDS "")
+    endif ()
+
+    add_custom_target("${PVS_STUDIO_TARGET}" ${ALL} ${COMMANDS} WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" DEPENDS ${PVS_STUDIO_DEPENDS} "${PVS_STUDIO_LOG}")
+
+    # A workaround to add implicit dependencies of source files from include directories
+    set_target_properties("${PVS_STUDIO_TARGET}" PROPERTIES INCLUDE_DIRECTORIES "${inc_path}")
+endfunction ()