Начало проекта

CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.0)
+project(myx-cmake VERSION 0.1.2)
+
+include(GNUInstallDirs)
+install(DIRECTORY MyxCMake DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake")
+

MyxCMake/MyxCMakeConfig.cmake

@@ -0,0 +1,54 @@
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW) # IN_LIST operator
+
+get_filename_component(MYX_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
+
+set(MYX_CMAKE_FUNCTIONS_DIR "${MYX_CMAKE_DIR}/functions")
+if(NOT IS_DIRECTORY "${MYX_CMAKE_FUNCTIONS_DIR}")
+  message(STATUS "MyxCMake: Functions directory is not found.")
+else()
+  if(NOT ${MYX_CMAKE_FUNCTIONS_DIR} IN_LIST CMAKE_MODULE_PATH)
+    list(INSERT CMAKE_MODULE_PATH 0 "${MYX_CMAKE_FUNCTIONS_DIR}")
+  endif()
+endif()
+
+set(MYX_CMAKE_THIRDPARTY_DIR "${MYX_CMAKE_DIR}/thirdparty")
+if(NOT IS_DIRECTORY "${MYX_CMAKE_THIRDPARTY_DIR}")
+  message(STATUS "MyxCMake: Thirdparty submodule is not found.")
+else()
+  if(NOT ${MYX_CMAKE_THIRDPARTY_DIR} IN_LIST CMAKE_MODULE_PATH)
+    list(INSERT CMAKE_MODULE_PATH 0 "${MYX_CMAKE_THIRDPARTY_DIR}")
+  endif()
+endif()
+
+set(MYX_CMAKE_SANITIZERS_DIR "${MYX_CMAKE_DIR}/sanitizers")
+if(NOT IS_DIRECTORY "${MYX_CMAKE_SANITIZERS_DIR}")
+  message(STATUS "MyxCMake: Sanitizers submodule is not found.")
+else()
+  if(NOT ${MYX_CMAKE_SANITIZERS_DIR} IN_LIST CMAKE_MODULE_PATH)
+    list(INSERT CMAKE_MODULE_PATH 0 "${MYX_CMAKE_SANITIZERS_DIR}")
+    find_package(Sanitizers)
+  endif()
+endif()
+
+set(MYX_CMAKE_FIND_DIR "${MYX_CMAKE_DIR}/find")
+if(NOT IS_DIRECTORY "${MYX_CMAKE_FIND_DIR}")
+  message(STATUS "MyxCMake: Custom find submodules are not found.")
+else()
+  if(NOT ${MYX_CMAKE_FIND_DIR} IN_LIST CMAKE_MODULE_PATH)
+    list(INSERT CMAKE_MODULE_PATH 0 "${MYX_CMAKE_FIND_DIR}")
+  endif()
+endif()
+
+set(MYX_CMAKE_MODULES_DIR "${MYX_CMAKE_DIR}/modules")
+if(NOT IS_DIRECTORY "${MYX_CMAKE_MODULES_DIR}")
+  message(FATAL_ERROR "MyxCMake: Requried modules directory is not found.")
+else()
+  if(NOT ${MYX_CMAKE_MODULES_DIR} IN_LIST CMAKE_MODULE_PATH)
+    list(INSERT CMAKE_MODULE_PATH 0 "${MYX_CMAKE_MODULES_DIR}")
+  endif()
+endif()
+
+include(MyxCMakeCommon)
+
+cmake_policy(POP)

MyxCMake/find/FindCgalWidget.cmake

@@ -0,0 +1,45 @@
+if(NOT CGAL_WIDGET_IS_EXTERNAL_PROJECT)
+  set(CGAL_WIDGET_PREFIX "" CACHE PATH "The path to the prefix of an cgal-widget installation")
+  set(CGAL_WIDGET_INCLUDE_DIR "" CACHE PATH "The path to the headers of an cgal-widget installation")
+  set(CGAL_WIDGET_LIBRARY_DIR "" CACHE PATH "The path to the library of an cgal-widget installation")
+
+  set(_search_paths "")
+  if(CGAL_WIDGET_INCLUDE_DIR AND EXISTS ${CGAL_WIDGET_INCLUDE_DIR})
+    list(APPEND _search_paths ${CGAL_WIDGET_INCLUDE_DIR})
+  endif()
+  if(CGAL_WIDGET_PREFIX AND EXISTS ${CGAL_WIDGET_PREFIX})
+    list(APPEND _search_paths "${CGAL_WIDGET_PREFIX}/include")
+  endif()
+  find_path(
+    CGAL_WIDGET_INCLUDE_DIRS
+    NAMES cgal-widget/cgal-widget.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(CGAL_WIDGET_LIBRARY_DIR AND EXISTS ${CGAL_WIDGET_LIBRARY_DIR})
+    list(APPEND _search_paths ${CGAL_WIDGET_LIBRARY_DIR})
+  endif()
+  if(CGAL_WIDGET_PREFIX AND EXISTS ${CGAL_WIDGET_PREFIX})
+    list(APPEND _search_paths "${CGAL_WIDGET_PREFIX}/lib")
+  endif()
+  find_library(
+    CGAL_WIDGET_LIBRARIES
+    NAMES preprocmath
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(CGAL_WIDGET_INCLUDE_DIRS AND CGAL_WIDGET_LIBRARIES)
+    set(CGAL_WIDGET_FOUND TRUE)
+  endif()
+
+  if(CGAL_WIDGET_FOUND)
+    if(NOT CGAL_WIDGET_FIND_QUIETLY)
+      message(STATUS "Found cgal-widget")
+    endif()
+    set(HAVE_CGAL_WIDGET 1)
+  elseif(CGAL_WIDGET_FOUND)
+    if(CGAL_WIDGET_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find cgal-widget")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindCgalWidgetThirdparty.cmake

@@ -0,0 +1,39 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(CGAL_WIDGET_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(CGAL_WIDGET_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(CGAL_WIDGET_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(CGAL_WIDGET_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(CGAL_WIDGET_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libcgal-widget.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  cgal-widget
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/cgal-widget
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(CgalWidgetThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} cgal-widget-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${CGAL_WIDGET_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(CGAL_WIDGET_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindFcProtocol.cmake

@@ -0,0 +1,32 @@
+if(NOT FC_PROTOCOL_IS_EXTERNAL_PROJECT)
+  set(FC_PROTOCOL_PREFIX "" CACHE PATH "The path to the prefix of an FC protocols installation")
+  set(FC_PROTOCOL_INCLUDE_DIR "" CACHE PATH "The path to the headers of an FC protocols installation")
+
+  set(_search_paths "")
+  if(EXISTS FC_PROTOCOL_INCLUDE_DIR)
+    list(APPEND _search_paths ${FC_PROTOCOL_INCLUDE_DIR})
+  endif()
+  if(EXISTS FC_PROTOCOL_PREFIX)
+    list(APPEND _search_paths "${FC_PROTOCOL_PREFIX}/include")
+  endif()
+  find_path(
+    FC_PROTOCOL_INCLUDE_DIRS
+    NAMES fc-protocol/hw/result.hpp
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(FC_PROTOCOL_INCLUDE_DIRS)
+    set(FC_PROTOCOL_FOUND TRUE)
+  endif()
+
+  if(FC_PROTOCOL_FOUND)
+    if(NOT FC_PROTOCOL_FIND_QUIETLY)
+      message(STATUS "Found FC protocol")
+    endif()
+    set(HAVE_FC_PROTOCOL 1)
+  elseif(FC_PROTOCOL_FOUND)
+    if(FC_PROTOCOL_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find FC protocol")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindFcProtocolThirdparty.cmake

@@ -0,0 +1,30 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(FC_PROTOCOL_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(FC_PROTOCOL_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(FC_PROTOCOL_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  fc-protocol
+  SOURCE_DIR  ${CMAKE_SOURCE_DIR}/thirdparty/fc-protocol
+  INSTALL_DIR ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS  ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+              <SOURCE_DIR>)
+if(FcProtocolThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND     true
+    INSTALL_COMMAND   ${CMAKE_MAKE_PROGRAM} fc-protocol-install-headers)
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(FC_PROTOCOL_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindFsp.cmake

@@ -0,0 +1,45 @@
+if(NOT FSP_IS_EXTERNAL_PROJECT)
+  set(FSP_PREFIX "" CACHE PATH "The path to the prefix of an libfsp installation")
+  set(FSP_INCLUDE_DIR "" CACHE PATH "The path to the headers of an libfsp installation")
+  set(FSP_LIBRARY_DIR "" CACHE PATH "The path to the library of an libfsp installation")
+
+  set(_search_paths "")
+  if(FSP_INCLUDE_DIR AND EXISTS ${FSP_INCLUDE_DIR})
+    list(APPEND _search_paths ${FSP_INCLUDE_DIR})
+  endif()
+  if(FSP_PREFIX AND EXISTS ${FSP_PREFIX})
+    list(APPEND _search_paths "${FSP_PREFIX}/include")
+  endif()
+  find_path(
+    FSP_INCLUDE_DIRS
+    NAMES fsp/mods.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(FSP_LIBRARY_DIR AND EXISTS ${FSP_LIBRARY_DIR})
+    list(APPEND _search_paths ${FSP_LIBRARY_DIR})
+  endif()
+  if(FSP_PREFIX AND EXISTS ${FSP_PREFIX})
+    list(APPEND _search_paths "${FSP_PREFIX}/lib")
+  endif()
+  find_library(
+    FSP_LIBRARIES
+    NAMES fsp
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(FSP_INCLUDE_DIRS AND FSP_LIBRARIES)
+    set(FSP_FOUND TRUE)
+  endif()
+
+  if(FSP_FOUND)
+    if(NOT FSP_FIND_QUIETLY)
+      message(STATUS "Found libfsp")
+    endif()
+    set(HAVE_FSP 1)
+  elseif(FSP_FOUND)
+    if(FSP_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libfsp")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindFspThirdparty.cmake

@@ -0,0 +1,43 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(FSP_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(FSP_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(FSP_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(FSP_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(FSP_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libfsp.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  libfsp
+  DEPENDS libpreprocmath libionobase myxlib
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/libfsp
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   -DPREPROCMATH_PREFIX=${CMAKE_BINARY_DIR}
+                   -DIONOBASE_PREFIX=${CMAKE_BINARY_DIR}
+                   -DMYXLIB_PREFIX=${CMAKE_BINARY_DIR}
+                   <SOURCE_DIR>)
+if(FspThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} fsp-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${FSP_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(FSP_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindGEOS.cmake

@@ -0,0 +1,183 @@
+# Find GEOS
+# ~~~~~~~~~
+# Copyright (c) 2008, Mateusz Loskot <mateusz@loskot.net>
+# (based on FindGDAL.cmake by Magnus Homann)
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
+# CMake module to search for GEOS library
+#
+# If it's found it sets GEOS_FOUND to TRUE
+# and following variables are set:
+#    GEOS_INCLUDE_DIR
+#    GEOS_LIBRARY
+#
+
+IF(EXISTS ${CMAKE_SOURCE_DIR}/cmake/MacPlistMacros.cmake)
+  INCLUDE (${CMAKE_SOURCE_DIR}/cmake/MacPlistMacros.cmake)
+ENDIF()
+
+IF(WIN32)
+
+  IF (MINGW)
+    FIND_PATH(GEOS_INCLUDE_DIR geos_c.h /usr/local/include /usr/include c:/msys/local/include)
+    FIND_LIBRARY(GEOS_LIBRARY NAMES geos_c PATHS /usr/local/lib /usr/lib c:/msys/local/lib)
+  ENDIF (MINGW)
+
+  IF (MSVC)
+    FIND_PATH(GEOS_INCLUDE_DIR geos_c.h $ENV{LIB_DIR}/include $ENV{INCLUDE})
+    FIND_LIBRARY(GEOS_LIBRARY NAMES geos geos_c_i geos_c PATHS
+      "$ENV{LIB_DIR}/lib"
+      $ENV{LIB}
+      )
+  ENDIF (MSVC)
+
+ELSE(WIN32)
+
+ IF(UNIX)
+    # try to use framework on mac
+    # want clean framework path, not unix compatibility path
+    IF (APPLE)
+      IF (CMAKE_FIND_FRAMEWORK MATCHES "FIRST"
+          OR CMAKE_FRAMEWORK_PATH MATCHES "ONLY"
+          OR NOT CMAKE_FIND_FRAMEWORK)
+        SET (CMAKE_FIND_FRAMEWORK_save ${CMAKE_FIND_FRAMEWORK} CACHE STRING "" FORCE)
+        SET (CMAKE_FIND_FRAMEWORK "ONLY" CACHE STRING "" FORCE)
+        FIND_LIBRARY(GEOS_LIBRARY GEOS)
+        IF (GEOS_LIBRARY)
+          # they're all the same in a framework
+          SET (GEOS_INCLUDE_DIR ${GEOS_LIBRARY}/Headers CACHE PATH "Path to a file.")
+          # set GEOS_CONFIG to make later test happy, not used here, may not exist
+          SET (GEOS_CONFIG ${GEOS_LIBRARY}/unix/bin/geos-config CACHE FILEPATH "Path to a program.")
+          # version in info.plist
+          GET_VERSION_PLIST (${GEOS_LIBRARY}/Resources/Info.plist GEOS_VERSION)
+          IF (NOT GEOS_VERSION)
+            MESSAGE (FATAL_ERROR "Could not determine GEOS version from framework.")
+          ENDIF (NOT GEOS_VERSION)
+          STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" GEOS_VERSION_MAJOR "${GEOS_VERSION}")
+          STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" GEOS_VERSION_MINOR "${GEOS_VERSION}")
+          IF (GEOS_VERSION_MAJOR LESS 3)
+            MESSAGE (FATAL_ERROR "GEOS version is too old (${GEOS_VERSION}). Use 3.0.0 or higher.")
+          ENDIF (GEOS_VERSION_MAJOR LESS 3)
+        ENDIF (GEOS_LIBRARY)
+        SET (CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_save} CACHE STRING "" FORCE)
+      ENDIF ()
+    ENDIF (APPLE)
+
+    IF(CYGWIN)
+      FIND_LIBRARY(GEOS_LIBRARY NAMES geos_c PATHS /usr/lib /usr/local/lib)
+    ENDIF(CYGWIN)
+
+    IF (NOT GEOS_INCLUDE_DIR OR NOT GEOS_LIBRARY OR NOT GEOS_CONFIG)
+      # didn't find OS X framework, and was not set by user
+      SET(GEOS_CONFIG_PREFER_PATH "$ENV{GEOS_HOME}/bin" CACHE STRING "preferred path to GEOS (geos-config)")
+      FIND_PROGRAM(GEOS_CONFIG geos-config
+          ${GEOS_CONFIG_PREFER_PATH}
+          /usr/local/bin/
+          /usr/bin/
+          )
+      #MESSAGE("DBG GEOS_CONFIG ${GEOS_CONFIG}")
+
+      IF (GEOS_CONFIG)
+
+        EXEC_PROGRAM(${GEOS_CONFIG}
+            ARGS --version
+            OUTPUT_VARIABLE GEOS_VERSION)
+        STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" GEOS_VERSION_MAJOR "${GEOS_VERSION}")
+        STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" GEOS_VERSION_MINOR "${GEOS_VERSION}")
+
+        IF (GEOS_VERSION_MAJOR LESS 3 OR (GEOS_VERSION_MAJOR EQUAL 3 AND GEOS_VERSION_MINOR LESS 3) )
+          MESSAGE (FATAL_ERROR "GEOS version is too old (${GEOS_VERSION}). Use 3.3.0 or higher.")
+        ENDIF (GEOS_VERSION_MAJOR LESS 3 OR (GEOS_VERSION_MAJOR EQUAL 3 AND GEOS_VERSION_MINOR LESS 3) )
+
+        # set INCLUDE_DIR to prefix+include
+        EXEC_PROGRAM(${GEOS_CONFIG}
+            ARGS --prefix
+            OUTPUT_VARIABLE GEOS_PREFIX)
+
+        FIND_PATH(GEOS_INCLUDE_DIR
+            geos_c.h
+            ${GEOS_PREFIX}/include
+            /usr/local/include
+            /usr/include
+            )
+
+        ## extract link dirs for rpath
+        EXEC_PROGRAM(${GEOS_CONFIG}
+            ARGS --libs
+            OUTPUT_VARIABLE GEOS_CONFIG_LIBS )
+
+        ## split off the link dirs (for rpath)
+        ## use regular expression to match wildcard equivalent "-L*<endchar>"
+        ## with <endchar> is a space or a semicolon
+        STRING(REGEX MATCHALL "[-][L]([^ ;])+"
+            GEOS_LINK_DIRECTORIES_WITH_PREFIX
+            "${GEOS_CONFIG_LIBS}" )
+        #MESSAGE("DBG  GEOS_LINK_DIRECTORIES_WITH_PREFIX=${GEOS_LINK_DIRECTORIES_WITH_PREFIX}")
+
+        ## remove prefix -L because we need the pure directory for LINK_DIRECTORIES
+
+        IF (GEOS_LINK_DIRECTORIES_WITH_PREFIX)
+          STRING(REGEX REPLACE "[-][L]" "" GEOS_LINK_DIRECTORIES ${GEOS_LINK_DIRECTORIES_WITH_PREFIX} )
+        ENDIF (GEOS_LINK_DIRECTORIES_WITH_PREFIX)
+
+        ### XXX - mloskot: geos-config --libs does not return -lgeos_c, so set it manually
+        ## split off the name
+        ## use regular expression to match wildcard equivalent "-l*<endchar>"
+        ## with <endchar> is a space or a semicolon
+        #STRING(REGEX MATCHALL "[-][l]([^ ;])+"
+        #  GEOS_LIB_NAME_WITH_PREFIX
+        #  "${GEOS_CONFIG_LIBS}" )
+        #MESSAGE("DBG  GEOS_CONFIG_LIBS=${GEOS_CONFIG_LIBS}")
+        #MESSAGE("DBG  GEOS_LIB_NAME_WITH_PREFIX=${GEOS_LIB_NAME_WITH_PREFIX}")
+        SET(GEOS_LIB_NAME_WITH_PREFIX -lgeos_c CACHE STRING INTERNAL)
+
+        ## remove prefix -l because we need the pure name
+
+        IF (GEOS_LIB_NAME_WITH_PREFIX)
+          STRING(REGEX REPLACE "[-][l]" "" GEOS_LIB_NAME ${GEOS_LIB_NAME_WITH_PREFIX} )
+        ENDIF (GEOS_LIB_NAME_WITH_PREFIX)
+        #MESSAGE("DBG  GEOS_LIB_NAME=${GEOS_LIB_NAME}")
+
+        IF (APPLE)
+          IF (NOT GEOS_LIBRARY)
+            # work around empty GEOS_LIBRARY left by framework check
+            # while still preserving user setting if given
+            # ***FIXME*** need to improve framework check so below not needed
+            SET(GEOS_LIBRARY ${GEOS_LINK_DIRECTORIES}/lib${GEOS_LIB_NAME}.dylib CACHE STRING INTERNAL FORCE)
+          ENDIF (NOT GEOS_LIBRARY)
+        ELSE (APPLE)
+          FIND_LIBRARY(GEOS_LIBRARY NAMES ${GEOS_LIB_NAME} PATHS ${GEOS_LIB_DIRECTORIES}/lib)
+        ENDIF (APPLE)
+        #MESSAGE("DBG  GEOS_LIBRARY=${GEOS_LIBRARY}")
+
+      ELSE(GEOS_CONFIG)
+        MESSAGE("FindGEOS.cmake: geos-config not found. Please set it manually. GEOS_CONFIG=${GEOS_CONFIG}")
+      ENDIF(GEOS_CONFIG)
+    ENDIF(NOT GEOS_INCLUDE_DIR OR NOT GEOS_LIBRARY OR NOT GEOS_CONFIG)
+  ENDIF(UNIX)
+ENDIF(WIN32)
+
+IF(GEOS_INCLUDE_DIR AND NOT GEOS_VERSION)
+  FILE(READ ${GEOS_INCLUDE_DIR}/geos_c.h VERSIONFILE)
+  STRING(REGEX MATCH "#define GEOS_VERSION \"[0-9]+\\.[0-9]+\\.[0-9]+(dev)?\"" GEOS_VERSION ${VERSIONFILE})
+  STRING(REGEX MATCH "[0-9]+\\.[0-9]\\.[0-9]+" GEOS_VERSION ${GEOS_VERSION})
+ENDIF(GEOS_INCLUDE_DIR AND NOT GEOS_VERSION)
+
+IF (GEOS_INCLUDE_DIR AND GEOS_LIBRARY)
+   SET(GEOS_FOUND TRUE)
+ENDIF (GEOS_INCLUDE_DIR AND GEOS_LIBRARY)
+
+IF (GEOS_FOUND)
+
+   IF (NOT GEOS_FIND_QUIETLY)
+      MESSAGE(STATUS "Found GEOS: ${GEOS_LIBRARY} (${GEOS_VERSION})")
+   ENDIF (NOT GEOS_FIND_QUIETLY)
+
+ELSE (GEOS_FOUND)
+
+   MESSAGE(GEOS_INCLUDE_DIR=${GEOS_INCLUDE_DIR})
+   MESSAGE(GEOS_LIBRARY=${GEOS_LIBRARY})
+   MESSAGE(FATAL_ERROR "Could not find GEOS")
+
+ENDIF (GEOS_FOUND)

MyxCMake/find/FindImitator.cmake

@@ -0,0 +1,45 @@
+if(NOT IMITATOR_IS_EXTERNAL_PROJECT)
+  set(IMITATOR_PREFIX "" CACHE PATH "The path to the prefix of an libimitator installation")
+  set(IMITATOR_INCLUDE_DIR "" CACHE PATH "The path to the headers of an libimitator installation")
+  set(IMITATOR_LIBRARY_DIR "" CACHE PATH "The path to the library of an libimitator installation")
+
+  set(_search_paths "")
+  if(IMITATOR_INCLUDE_DIR AND EXISTS ${IMITATOR_INCLUDE_DIR})
+    list(APPEND _search_paths ${IMITATOR_INCLUDE_DIR})
+  endif()
+  if(IMITATOR_PREFIX AND EXISTS ${IMITATOR_PREFIX})
+    list(APPEND _search_paths "${IMITATOR_PREFIX}/include")
+  endif()
+  find_path(
+    IMITATOR_INCLUDE_DIRS
+    NAMES imitator/imitator.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(IMITATOR_LIBRARY_DIR AND EXISTS ${IMITATOR_LIBRARY_DIR})
+    list(APPEND _search_paths ${IMITATOR_LIBRARY_DIR})
+  endif()
+  if(IMITATOR_PREFIX AND EXISTS ${IMITATOR_PREFIX})
+    list(APPEND _search_paths "${IMITATOR_PREFIX}/lib")
+  endif()
+  find_library(
+    IMITATOR_LIBRARIES
+    NAMES imitator
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(IMITATOR_INCLUDE_DIRS AND IMITATOR_LIBRARIES)
+    set(IMITATOR_FOUND TRUE)
+  endif()
+
+  if(IMITATOR_FOUND)
+    if(NOT IMITATOR_FIND_QUIETLY)
+      message(STATUS "Found libimitator")
+    endif()
+    set(HAVE_IMITATOR 1)
+  elseif(IMITATOR_FOUND)
+    if(IMITATOR_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libimitator")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindImitatorThirdparty.cmake

@@ -0,0 +1,41 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(IMITATOR_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(IMITATOR_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(IMITATOR_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(IMITATOR_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(IMITATOR_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libimitator.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  libimitator
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/libimitator
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   -DPREPROCMATH_PREFIX=${CMAKE_BINARY_DIR}
+                   -DMYXLIB_PREFIX=${CMAKE_BINARY_DIR}
+                   <SOURCE_DIR>)
+if(ImitatorThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} imitator-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${IMITATOR_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(IMITATOR_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindIonobase.cmake

@@ -0,0 +1,46 @@
+if(NOT IONOBASE_IS_EXTERNAL_PROJECT)
+  set(IONOBASE_PREFIX "" CACHE PATH "The path to the prefix of an libionobase installation")
+  set(IONOBASE_INCLUDE_DIR "" CACHE PATH "The path to the headers of an libionobase installation")
+  set(IONOBASE_LIBRARY_DIR "" CACHE PATH "The path to the library of an libionobase installation")
+
+  set(_search_paths "")
+  if(IONOBASE_INCLUDE_DIR AND EXISTS ${IONOBASE_INCLUDE_DIR})
+    list(APPEND _search_paths ${IONOBASE_INCLUDE_DIR})
+  endif()
+  if(IONOBASE_PREFIX AND EXISTS ${IONOBASE_PREFIX})
+    list(APPEND _search_paths "${IONOBASE_PREFIX}/include")
+  endif()
+  find_path(
+    IONOBASE_INCLUDE_DIRS
+    NAMES interchfor.h
+    PATH_SUFFIXES ionobase
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(IONOBASE_LIBRARY_DIR AND EXISTS ${IONOBASE_LIBRARY_DIR})
+    list(APPEND _search_paths ${IONOBASE_LIBRARY_DIR})
+  endif()
+  if(IONOBASE_PREFIX AND EXISTS ${IONOBASE_PREFIX})
+    list(APPEND _search_paths "${IONOBASE_PREFIX}/lib")
+  endif()
+  find_library(
+    IONOBASE_LIBRARIES
+    NAMES ionobase
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(IONOBASE_INCLUDE_DIRS AND IONOBASE_LIBRARIES)
+    set(IONOBASE_FOUND TRUE)
+  endif()
+
+  if(IONOBASE_FOUND)
+    if(NOT IONOBASE_FIND_QUIETLY)
+      message(STATUS "Found libionobase")
+    endif()
+    set(HAVE_IONOBASE 1)
+  elseif(IONOBASE_FOUND)
+    if(IONOBASE_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libionobase")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindIonobaseThirdparty.cmake

@@ -0,0 +1,39 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(IONOBASE_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(IONOBASE_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}/ionobase
+    CACHE PATH "" FORCE)
+set(IONOBASE_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}/ionobase
+    CACHE PATH "" FORCE)
+set(IONOBASE_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(IONOBASE_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libionobase.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  libionobase
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/libionobase
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(IonobaseThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} ionobase-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${IONOBASE_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(IONOBASE_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindMPFR.cmake

@@ -0,0 +1,32 @@
+# Copyright (c) 2008-2010 Kent State University
+# Copyright (c) 2011-2012 Texas A&M University
+#
+# This file is distributed under the MIT License. See the accompanying file
+# LICENSE.txt or http://www.opensource.org/licenses/mit-license.php for terms
+# and conditions.
+
+# NOTE: MPFR prefix is understood to be the path to the root of the MPFR
+# installation library.
+
+set(MPFR_PREFIX "" CACHE PATH "The path to the prefix of an MPFR installation")
+
+find_path(MPFR_INCLUDE_DIRS mpfr.h
+  PATHS ${MPFR_PREFIX}/include)
+
+find_library(MPFR_LIBRARIES NAMES mpfr
+  PATHS ${MPFR_PREFIX}/lib)
+
+if(MPFR_INCLUDE_DIRS AND MPFR_LIBRARIES)
+  set(MPFR_FOUND TRUE)
+endif()
+
+if(MPFR_FOUND)
+  if(NOT MPFR_FIND_QUIETLY)
+    MESSAGE(STATUS "Found MPFR: ${MPFR_LIBRARIES}")
+  endif()
+  set(HAVE_MPFR 1)
+elseif(MPFR_FOUND)
+  if(MPFR_FIND_REQUIRED)
+    message(FATAL_ERROR "Could not find MPFR")
+  endif()
+endif()

MyxCMake/find/FindMPFRCppThirdparty.cmake

@@ -0,0 +1,15 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+if(MPFR_FOUND)
+  ExternalProject_Add(
+    mpfrcpp
+    SOURCE_DIR ${CMAKE_SOURCE_DIR}/thirdparty/mpreal
+    INSTALL_DIR ${CMAKE_BINARY_DIR}/include
+    CONFIGURE_COMMAND true
+    BUILD_COMMAND true
+    INSTALL_COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/mpreal.h <INSTALL_DIR>)
+endif()
+
+set(MPFRCPP_PREFIX  ${CMAKE_BINARY_DIR} CACHE FILEPATH "" FORCE)
+set(MPFRCPP_INCLUDE_DIRS ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "" FORCE)

MyxCMake/find/FindMathGL.cmake

@@ -0,0 +1,41 @@
+set(MATHGP_PREFIX "" CACHE PATH "The path to the prefix of an MathGL installation")
+
+find_path(MATHGL_INCLUDE_DIR NAMES mgl2/mgl.h
+  PATHS
+  ${MPFR_PREFIX}/include
+  /opt/local/include
+  /usr/include
+  /usr/local/include
+  )
+
+find_library(MATHGL_LIBRARIES NAMES mgl mgl
+  PATHS
+  ${MPFR_PREFIX}/lib
+  /opt/local/include
+  /usr/include
+  /usr/local/include
+  )
+
+find_library(MATHGL_QT5_LIBRARIES NAMES mgl-qt5
+  PATHS
+  ${MPFR_PREFIX}/lib
+  /opt/local/include
+  /usr/include
+  /usr/local/include
+  )
+
+if(MATHGL_INCLUDE_DIR AND MATHGL_LIBRARIES)
+  get_filename_component(MATHGL_LIBRARY_DIR ${MATHGL_LIBRARIES} PATH)
+  set(MATHGL_FOUND TRUE)
+endif()
+
+if(MATHGL_FOUND)
+  if(NOT MATHGL_FIND_QUIETLY)
+    MESSAGE(STATUS "Found MathGL: ${MATHGL_LIBRARIES}")
+  endif()
+  set(HAVE_MATHGL 1)
+elseif(MATHGL_FOUND)
+  if(MATHGL_FIND_REQUIRED)
+    message(FATAL_ERROR "Could not find MATHGL")
+  endif()
+endif()

MyxCMake/find/FindMyxNotifications.cmake

@@ -0,0 +1,45 @@
+if(NOT MYX_NOTIFICATIONS_IS_EXTERNAL_PROJECT)
+  set(MYX_NOTIFICATIONS_PREFIX "" CACHE PATH "The path to the prefix of an myx-notifications installation")
+  set(MYX_NOTIFICATIONS_INCLUDE_DIR "" CACHE PATH "The path to the headers of an myx-notifications installation")
+  set(MYX_NOTIFICATIONS_LIBRARY_DIR "" CACHE PATH "The path to the library of an myx-notifications installation")
+
+  set(_search_paths "")
+  if(MYX_NOTIFICATIONS_INCLUDE_DIR AND EXISTS ${MYX_NOTIFICATIONS_INCLUDE_DIR})
+    list(APPEND _search_paths ${MYX_NOTIFICATIONS_INCLUDE_DIR})
+  endif()
+  if(MYX_NOTIFICATIONS_PREFIX AND EXISTS ${MYX_NOTIFICATIONS_PREFIX})
+    list(APPEND _search_paths "${MYX_NOTIFICATIONS_PREFIX}/include")
+  endif()
+  find_path(
+    MYX_NOTIFICATIONS_INCLUDE_DIRS
+    NAMES myx/notifications/widget.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(MYX_NOTIFICATIONS_LIBRARY_DIR AND EXISTS ${MYX_NOTIFICATIONS_LIBRARY_DIR})
+    list(APPEND _search_paths ${MYX_NOTIFICATIONS_LIBRARY_DIR})
+  endif()
+  if(MYX_NOTIFICATIONS_PREFIX AND EXISTS ${MYX_NOTIFICATIONS_PREFIX})
+    list(APPEND _search_paths "${MYX_NOTIFICATIONS_PREFIX}/lib")
+  endif()
+  find_library(
+    MYX_NOTIFICATIONS_LIBRARIES
+    NAMES myx-notifications
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(MYX_NOTIFICATIONS_INCLUDE_DIRS AND MYX_NOTIFICATIONS_LIBRARIES)
+    set(MYX_NOTIFICATIONS_FOUND TRUE)
+  endif()
+
+  if(MYX_NOTIFICATIONS_FOUND)
+    if(NOT MYX_NOTIFICATIONS_FIND_QUIETLY)
+      message(STATUS "Found myx-notifications")
+    endif()
+    set(HAVE_MYX_NOTIFICATIONS 1)
+  elseif(MYX_NOTIFICATIONS_FOUND)
+    if(MYX_NOTIFICATIONS_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find myx-notifications")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindMyxNotificationsThirdparty.cmake

@@ -0,0 +1,39 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(MYX_NOTIFICATIONS_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(MYX_NOTIFICATIONS_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYX_NOTIFICATIONS_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYX_NOTIFICATIONS_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(MYX_NOTIFICATIONS_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-notifications.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  myx-notifications
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/myx-notifications
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(MyxNotificationsThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} myx-notifications-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${MYX_NOTIFICATIONS_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(MYX_NOTIFICATIONS_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindMyxQPing.cmake

@@ -0,0 +1,45 @@
+if(NOT MYX_QPING_IS_EXTERNAL_PROJECT)
+  set(MYX_QPING_PREFIX "" CACHE PATH "The path to the prefix of an myx-qping installation")
+  set(MYX_QPING_INCLUDE_DIR "" CACHE PATH "The path to the headers of an myx-qping installation")
+  set(MYX_QPING_LIBRARY_DIR "" CACHE PATH "The path to the library of an myx-qping installation")
+
+  set(_search_paths "")
+  if(MYX_QPING_INCLUDE_DIR AND EXISTS ${MYX_QPING_INCLUDE_DIR})
+    list(APPEND _search_paths ${MYX_QPING_INCLUDE_DIR})
+  endif()
+  if(MYX_QPING_PREFIX AND EXISTS ${MYX_QPING_PREFIX})
+    list(APPEND _search_paths "${MYX_QPING_PREFIX}/include")
+  endif()
+  find_path(
+    MYX_QPING_INCLUDE_DIRS
+    NAMES myx/qping/ping.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(MYX_QPING_LIBRARY_DIR AND EXISTS ${MYX_QPING_LIBRARY_DIR})
+    list(APPEND _search_paths ${MYX_QPING_LIBRARY_DIR})
+  endif()
+  if(MYX_QPING_PREFIX AND EXISTS ${MYX_QPING_PREFIX})
+    list(APPEND _search_paths "${MYX_QPING_PREFIX}/lib")
+  endif()
+  find_library(
+    MYX_QPING_LIBRARIES
+    NAMES myx-qping
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(MYX_QPING_INCLUDE_DIRS AND MYX_QPING_LIBRARIES)
+    set(MYX_QPING_FOUND TRUE)
+  endif()
+
+  if(MYX_QPING_FOUND)
+    if(NOT MYX_QPING_FIND_QUIETLY)
+      message(STATUS "Found myx-qping")
+    endif()
+    set(HAVE_MYX_QPING 1)
+  elseif(MYX_QPING_FOUND)
+    if(MYX_QPING_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find myx-qping")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindMyxQPingThirdparty.cmake

@@ -0,0 +1,39 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(MYX_QPING_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(MYX_QPING_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYX_QPING_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYX_QPING_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(MYX_QPING_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-qping.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  myx-qping
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/myx-qping
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(MyxQPingThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} myx-qping-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${MYX_QPING_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(MYX_QPING_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindMyxRedis.cmake

@@ -0,0 +1,45 @@
+if(NOT MYX_REDIS_IS_EXTERNAL_PROJECT)
+  set(MYX_REDIS_PREFIX "" CACHE PATH "The path to the prefix of an myx-redis installation")
+  set(MYX_REDIS_INCLUDE_DIR "" CACHE PATH "The path to the headers of an myx-redis installation")
+  set(MYX_REDIS_LIBRARY_DIR "" CACHE PATH "The path to the library of an myx-redis installation")
+
+  set(_search_paths "")
+  if(MYX_REDIS_INCLUDE_DIR AND EXISTS ${MYX_REDIS_INCLUDE_DIR})
+    list(APPEND _search_paths ${MYX_REDIS_INCLUDE_DIR})
+  endif()
+  if(MYX_REDIS_PREFIX AND EXISTS ${MYX_REDIS_PREFIX})
+    list(APPEND _search_paths "${MYX_REDIS_PREFIX}/include")
+  endif()
+  find_path(
+    MYX_REDIS_INCLUDE_DIRS
+    NAMES myx/redis/sync_client.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(MYX_REDIS_LIBRARY_DIR AND EXISTS ${MYX_REDIS_LIBRARY_DIR})
+    list(APPEND _search_paths ${MYX_REDIS_LIBRARY_DIR})
+  endif()
+  if(MYX_REDIS_PREFIX AND EXISTS ${MYX_REDIS_PREFIX})
+    list(APPEND _search_paths "${MYX_REDIS_PREFIX}/lib")
+  endif()
+  find_library(
+    MYX_REDIS_LIBRARIES
+    NAMES myx-redis
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(MYX_REDIS_INCLUDE_DIRS AND MYX_REDIS_LIBRARIES)
+    set(MYX_REDIS_FOUND TRUE)
+  endif()
+
+  if(MYX_REDIS_FOUND)
+    if(NOT MYX_REDIS_FIND_QUIETLY)
+      message(STATUS "Found myx-redis")
+    endif()
+    set(HAVE_MYX_REDIS 1)
+  elseif(MYX_REDIS_FOUND)
+    if(MYX_REDIS_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find myx-redis")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindMyxRedisThirdparty.cmake

@@ -0,0 +1,39 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(MYX_REDIS_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(MYX_REDIS_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYX_REDIS_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYX_REDIS_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(MYX_REDIS_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-redis.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  myx-redis
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/myx-redis
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(MyxRedisThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} myx-redis-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${MYX_REDIS_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(MYX_REDIS_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindMyxlib.cmake

@@ -0,0 +1,78 @@
+#[=======================================================================[.rst:
+FindMyxlib
+--------
+
+Поиск библиотеки Myxlib
+
+Входные переменные
+^^^^^^^^^^^^^^^^^^
+
+``MYXLIB_PREFIX``
+  корневой каталог установленной библиотеки.
+``MYXLIB_INCLUDE_DIR``
+  каталог, в котором производится поиск заголовочных файлов.
+``MYXLIB_LIBRARY_DIR``
+  каталог, в котором производится поиск библиотек.
+
+Выходные переменные
+^^^^^^^^^^^^^^^^^^^
+
+``MYXLIB_FOUND``
+  true, если MYXLIB найдена
+``MYXLIB_INCLUDE_DIRS``
+  каталог с найденными заголовочными файлами
+``MYXLIB_LIBRARIES``
+  каталог с найденными библиотеками
+
+#]=======================================================================]
+
+if(NOT MYXLIB_IS_EXTERNAL_PROJECT)
+  set(MYXLIB_PREFIX "" CACHE PATH "The path to the prefix of an myxlib installation")
+  set(MYXLIB_INCLUDE_DIR "" CACHE PATH "The path to the headers of an myxlib installation")
+  set(MYXLIB_LIBRARY_DIR "" CACHE PATH "The path to the library of an myxlib installation")
+
+  set(_search_paths "")
+  if(MYXLIB_INCLUDE_DIR AND EXISTS ${MYXLIB_INCLUDE_DIR})
+    list(APPEND _search_paths ${MYXLIB_INCLUDE_DIR})
+  endif()
+  if(MYXLIB_PREFIX AND EXISTS ${MYXLIB_PREFIX})
+    list(APPEND _search_paths "${MYXLIB_PREFIX}/include")
+  endif()
+  find_path(
+    MYXLIB_INCLUDE_DIRS
+    NAMES myx/core/config.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(MYXLIB_LIBRARY_DIR AND EXISTS ${MYXLIB_LIBRARY_DIR})
+    list(APPEND _search_paths ${MYXLIB_LIBRARY_DIR})
+  endif()
+  if(MYXLIB_PREFIX AND EXISTS ${MYXLIB_PREFIX})
+    list(APPEND _search_paths "${MYXLIB_PREFIX}/lib")
+  endif()
+  find_library(
+    MYXLIB_QT_LIBRARIES
+    NAMES myx-qt
+    PATHS ${_search_paths})
+  find_library(
+    MYXLIB_FILESYSTEM_LIBRARIES
+    NAMES myx-filesystem
+    PATHS ${_search_paths})
+  unset(_search_paths)
+  set(MYXLIB_LIBRARIES ${MYXLIB_QT_LIBRARIES} ${MYXLIB_FILESYSTEM_LIBRARIES})
+
+  if(MYXLIB_INCLUDE_DIRS AND MYXLIB_LIBRARIES)
+    set(MYXLIB_FOUND TRUE)
+  endif()
+
+  if(MYXLIB_FOUND)
+    if(NOT MYXLIB_FIND_QUIETLY)
+      message(STATUS "Found myxlib")
+    endif()
+    set(HAVE_MYXLIB 1)
+  elseif(MYXLIB_FOUND)
+    if(MYXLIB_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find myxlib")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindMyxlibThirdparty.cmake

@@ -0,0 +1,46 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(MYXLIB_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(MYXLIB_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYXLIB_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(MYXLIB_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(MYXLIB_QT_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-qt.a
+    CACHE FILEPATH "" FORCE)
+set(MYXLIB_FILESYSTEM_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-filesystem.a
+    CACHE FILEPATH "" FORCE)
+set(MYXLIB_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-qt.a
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libmyx-filesystem.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  myxlib
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/myxlib
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(MyxlibThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} myxlib-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${MYXLIB_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(MYXLIB_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindPreproc.cmake

@@ -0,0 +1,45 @@
+if(NOT PREPROC_IS_EXTERNAL_PROJECT)
+  set(PREPROC_PREFIX "" CACHE PATH "The path to the prefix of an libpreproc installation")
+  set(PREPROC_INCLUDE_DIR "" CACHE PATH "The path to the headers of an libpreproc installation")
+  set(PREPROC_LIBRARY_DIR "" CACHE PATH "The path to the library of an libpreproc installation")
+
+  set(_search_paths "")
+  if(PREPROC_INCLUDE_DIR AND EXISTS ${PREPROC_INCLUDE_DIR})
+    list(APPEND _search_paths ${PREPROC_INCLUDE_DIR})
+  endif()
+  if(PREPROC_PREFIX AND EXISTS ${PREPROC_PREFIX})
+    list(APPEND _search_paths "${PREPROC_PREFIX}/include")
+  endif()
+  find_path(
+    PREPROC_INCLUDE_DIRS
+    NAMES preproc/mark.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(PREPROC_LIBRARY_DIR AND EXISTS ${PREPROC_LIBRARY_DIR})
+    list(APPEND _search_paths ${PREPROC_LIBRARY_DIR})
+  endif()
+  if(PREPROC_PREFIX AND EXISTS ${PREPROC_PREFIX})
+    list(APPEND _search_paths "${PREPROC_PREFIX}/lib")
+  endif()
+  find_library(
+    PREPROC_LIBRARIES
+    NAMES preproc
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(PREPROC_INCLUDE_DIRS AND PREPROC_LIBRARIES)
+    set(PREPROC_FOUND TRUE)
+  endif()
+
+  if(PREPROC_FOUND)
+    if(NOT PREPROC_FIND_QUIETLY)
+      message(STATUS "Found libpreproc")
+    endif()
+    set(HAVE_PREPROC 1)
+  elseif(PREPROC_FOUND)
+    if(PREPROC_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libpreproc")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindPreprocThirdparty.cmake

@@ -0,0 +1,41 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(PREPROC_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(PREPROC_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(PREPROC_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(PREPROC_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(PREPROC_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libpreproc.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  libpreproc
+  DEPENDS libpreprocmath
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/libpreproc
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   -DPREPROCMATH_PREFIX=${CMAKE_BINARY_DIR}
+                   <SOURCE_DIR>)
+if(PreprocThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} preproc-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${PREPROC_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(PREPROC_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindPreprocmath.cmake

@@ -0,0 +1,45 @@
+if(NOT PREPROCMATH_IS_EXTERNAL_PROJECT)
+  set(PREPROCMATH_PREFIX "" CACHE PATH "The path to the prefix of an libpreprocmath installation")
+  set(PREPROCMATH_INCLUDE_DIR "" CACHE PATH "The path to the headers of an libpreprocmath installation")
+  set(PREPROCMATH_LIBRARY_DIR "" CACHE PATH "The path to the library of an libpreprocmath installation")
+
+  set(_search_paths "")
+  if(PREPROCMATH_INCLUDE_DIR AND EXISTS ${PREPROCMATH_INCLUDE_DIR})
+    list(APPEND _search_paths ${PREPROCMATH_INCLUDE_DIR})
+  endif()
+  if(PREPROCMATH_PREFIX AND EXISTS ${PREPROCMATH_PREFIX})
+    list(APPEND _search_paths "${PREPROCMATH_PREFIX}/include")
+  endif()
+  find_path(
+    PREPROCMATH_INCLUDE_DIRS
+    NAMES preprocmath/params.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(PREPROCMATH_LIBRARY_DIR AND EXISTS ${PREPROCMATH_LIBRARY_DIR})
+    list(APPEND _search_paths ${PREPROCMATH_LIBRARY_DIR})
+  endif()
+  if(PREPROCMATH_PREFIX AND EXISTS ${PREPROCMATH_PREFIX})
+    list(APPEND _search_paths "${PREPROCMATH_PREFIX}/lib")
+  endif()
+  find_library(
+    PREPROCMATH_LIBRARIES
+    NAMES preprocmath
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(PREPROCMATH_INCLUDE_DIRS AND PREPROCMATH_LIBRARIES)
+    set(PREPROCMATH_FOUND TRUE)
+  endif()
+
+  if(PREPROCMATH_FOUND)
+    if(NOT PREPROCMATH_FIND_QUIETLY)
+      message(STATUS "Found libpreprocmath")
+    endif()
+    set(HAVE_PREPROCMATH 1)
+  elseif(PREPROCMATH_FOUND)
+    if(PREPROCMATH_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libpreprocmath")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindPreprocmathThirdparty.cmake

@@ -0,0 +1,39 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(PREPROCMATH_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(PREPROCMATH_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(PREPROCMATH_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(PREPROCMATH_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(PREPROCMATH_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libpreprocmath.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  libpreprocmath
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/libpreprocmath
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   <SOURCE_DIR>)
+if(PreprocmathThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} preprocmath-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${PREPROCMATH_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(PREPROCMATH_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindProj.cmake

@@ -0,0 +1,76 @@
+# Find Proj
+# ~~~~~~~~~
+# Copyright (c) 2007, Martin Dobias <wonder.sk at gmail.com>
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
+# CMake module to search for Proj library
+#
+# If it's found it sets PROJ_FOUND to TRUE
+# and following variables are set:
+#    PROJ_INCLUDE_DIR
+#    PROJ_LIBRARY
+
+# FIND_PATH and FIND_LIBRARY normally search standard locations
+# before the specified paths. To search non-standard paths first,
+# FIND_* is invoked first with specified paths and NO_DEFAULT_PATH
+# and then again with no specified paths to search the default
+# locations. When an earlier FIND_* succeeds, subsequent FIND_*s
+# searching for the same item do nothing.
+
+# try to use framework on mac
+# want clean framework path, not unix compatibility path
+IF (APPLE)
+  IF (CMAKE_FIND_FRAMEWORK MATCHES "FIRST"
+      OR CMAKE_FRAMEWORK_PATH MATCHES "ONLY"
+      OR NOT CMAKE_FIND_FRAMEWORK)
+    SET (CMAKE_FIND_FRAMEWORK_save ${CMAKE_FIND_FRAMEWORK} CACHE STRING "" FORCE)
+    SET (CMAKE_FIND_FRAMEWORK "ONLY" CACHE STRING "" FORCE)
+    #FIND_PATH(PROJ_INCLUDE_DIR PROJ/proj_api.h)
+    FIND_LIBRARY(PROJ_LIBRARY PROJ)
+    IF (PROJ_LIBRARY)
+      # FIND_PATH doesn't add "Headers" for a framework
+      SET (PROJ_INCLUDE_DIR ${PROJ_LIBRARY}/Headers CACHE PATH "Path to a file.")
+    ENDIF (PROJ_LIBRARY)
+    SET (CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_save} CACHE STRING "" FORCE)
+  ENDIF ()
+ENDIF (APPLE)
+
+FIND_PATH(PROJ_INCLUDE_DIR proj_api.h
+  "$ENV{INCLUDE}"
+  "$ENV{LIB_DIR}/include"
+  )
+
+FIND_LIBRARY(PROJ_LIBRARY NAMES proj_i proj PATHS
+  "$ENV{LIB}"
+  "$ENV{LIB_DIR}/lib"
+  )
+
+IF (PROJ_INCLUDE_DIR AND PROJ_LIBRARY)
+   SET(PROJ_FOUND TRUE)
+ENDIF (PROJ_INCLUDE_DIR AND PROJ_LIBRARY)
+
+
+IF (PROJ_FOUND)
+   # This macro checks if the symbol exists
+   include(CheckLibraryExists)
+   check_library_exists("${PROJ_LIBRARY}" proj_info "" PROJ_HAS_INFO)
+
+   IF (NOT PROJ_FIND_QUIETLY)
+     IF (PROJ_HAS_INFO)
+       FILE(READ ${PROJ_INCLUDE_DIR}/proj.h proj_version)
+       STRING(REGEX REPLACE "^.*PROJ_VERSION_MAJOR +([0-9]+).*$" "\\1" PROJ_VERSION_MAJOR "${proj_version}")
+       STRING(REGEX REPLACE "^.*PROJ_VERSION_MINOR +([0-9]+).*$" "\\1" PROJ_VERSION_MINOR "${proj_version}")
+       STRING(REGEX REPLACE "^.*PROJ_VERSION_PATCH +([0-9]+).*$" "\\1" PROJ_VERSION_PATCH "${proj_version}")
+       STRING(CONCAT PROJ_VERSION_STR "(" ${PROJ_VERSION_MAJOR} "." ${PROJ_VERSION_MINOR} "." ${PROJ_VERSION_PATCH} ")")
+     ENDIF (PROJ_HAS_INFO)
+     MESSAGE(STATUS "Found Proj: ${PROJ_LIBRARY} ${PROJ_VERSION_STR}")
+   ENDIF (NOT PROJ_FIND_QUIETLY)
+
+ELSE (PROJ_FOUND)
+
+   IF (PROJ_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find Proj")
+   ENDIF (PROJ_FIND_REQUIRED)
+
+ENDIF (PROJ_FOUND)

MyxCMake/find/FindPythonModule.cmake

@@ -0,0 +1,45 @@
+# Find a Python module
+# Found at http://www.cmake.org/pipermail/cmake/2011-January/041666.html
+# To use do: find_python_module(NumPy REQUIRED)
+# Reports also version of package, but you can't currently enforce a specific version to be
+# searched for...
+
+include(FindPackageHandleStandardArgs)
+function(find_python_module module)
+  # Fail if Python interpreter not known
+  if(NOT PYTHON_EXECUTABLE)
+    message(FATAL_ERROR "Use find_package(PythonInterp) first!")
+  endif()
+  string(TOLOWER ${module} _module_lower)
+  if(NOT ${_module_lower})
+    if(ARGC GREATER 1 AND ARGV1 STREQUAL "REQUIRED")
+      set(${module}_FIND_REQUIRED TRUE)
+    endif()
+    # Find module location
+    execute_process(
+      COMMAND
+        ${PYTHON_EXECUTABLE} "-c" "import re, ${_module_lower}; print(re.compile('/__init__.py.*').sub('',${_module_lower}.__file__))"
+      RESULT_VARIABLE _${module}_status
+      OUTPUT_VARIABLE _${module}_location
+      ERROR_QUIET
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      )
+    if(NOT _${module}_status)
+      set(${module} ${_${module}_location} CACHE STRING "Location of Python module ${module}")
+    endif()
+    # Find module version
+    execute_process(
+      COMMAND
+        ${PYTHON_EXECUTABLE} "-c" "import re, ${_module_lower}; print(re.compile('/__init__.py.*').sub('',${_module_lower}.__version__))"
+      OUTPUT_VARIABLE _${module}_ver
+      ERROR_QUIET
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      )
+  endif()
+
+  find_package_handle_standard_args(${module}
+    FOUND_VAR ${module}_FOUND
+    REQUIRED_VARS ${module}
+    VERSION_VAR _${module}_ver
+    )
+endfunction()

MyxCMake/find/FindQGIS.cmake

@@ -0,0 +1,248 @@
+## Once run this will define:
+##
+## QGIS_FOUND            = system has QGIS lib
+##
+## QGIS_CORE_LIBRARY     = full path to the CORE library
+## QGIS_GUI_LIBRARY      = full path to the GUI library
+## QGIS_ANALYSIS_LIBRARY = full path to the ANALYSIS library
+## QGIS_PLUGIN_DIR       = full path to where QGIS plugins are installed
+## QGIS_INCLUDE_DIR      = where to find headers
+## QGIS_UI_INCLUDE_DIR   = where to find ui_* generated headers
+##
+## QGIS_VERSION          = version as defined in qgsconfig.h, as major.minor.patch
+##
+## Definitions or ENV variables affecting search locations
+##
+## OSGEO4W_ROOT          = [A-Z]:/path/to/OSGeo4W/install/root
+##                               (^ use forward slashes!)
+## OSGEO4W_QGIS_SUBDIR   = qgis[-rel|-ltr][-dev], in OSGEO4W_ROOT/apps/
+## QGIS_MAC_PATH         = /path/to/any/QGIS.app/Contents
+## QGIS_BUILD_PATH       = [A-Z:]/path/to/QGIS/build/directory
+##
+## Tim Sutton
+## Larry Shaffer (2017-01-31)
+
+#MESSAGE("Searching for QGIS")
+IF(WIN32)
+  # OSGEO4W_QGIS_SUBDIR relative install: qgis[-rel|-ltr][-dev], etc.
+  IF (NOT OSGEO4W_QGIS_SUBDIR OR "${OSGEO4W_QGIS_SUBDIR}" STREQUAL "")
+    IF (NOT "$ENV{OSGEO4W_QGIS_SUBDIR}" STREQUAL "")
+      SET (OSGEO4W_QGIS_SUBDIR $ENV{OSGEO4W_QGIS_SUBDIR})
+    ELSE ()
+      SET (OSGEO4W_QGIS_SUBDIR qgis)
+    ENDIF ()
+  ENDIF ()
+
+  #MESSAGE("Searching for QGIS in $ENV{PROGRAMFILES}/QGIS")
+  IF (MINGW)
+    FIND_PATH(QGIS_PLUGIN_DIR
+      NAMES libofflineeditingplugin.dll
+      PATHS
+        "$ENV{PROGRAMFILES}/QGIS/plugins"
+    )
+    FIND_PATH(QGIS_INCLUDE_DIR
+      NAMES qgsapplication.h
+      PATHS
+        "$ENV{PROGRAMFILES}/QGIS/include"
+    )
+    FIND_LIBRARY(QGIS_CORE_LIBRARY
+      NAMES qgis_core
+      PATHS
+        "$ENV{PROGRAMFILES}/QGIS/"
+    )
+    FIND_LIBRARY(QGIS_GUI_LIBRARY
+      NAMES qgis_gui
+      PATHS
+        "$ENV{PROGRAMFILES}/QGIS/"
+    )
+  ENDIF (MINGW)
+
+  IF (MSVC)
+    FIND_PATH(QGIS_PLUGIN_DIR
+      NAMES offlineeditingplugin.dll
+      PATHS
+        "$ENV{OSGEO4W_ROOT}/apps/${OSGEO4W_QGIS_SUBDIR}/plugins"
+        "$ENV{PROGRAMFILES}/QGIS/plugins"
+    )
+    FIND_PATH(QGIS_INCLUDE_DIR
+      NAMES qgsapplication.h
+      PATHS
+        "$ENV{INCLUDE}"
+        "$ENV{LIB_DIR}/include/qgis"
+        "$ENV{OSGEO4W_ROOT}/include"
+        "$ENV{OSGEO4W_ROOT}/apps/${OSGEO4W_QGIS_SUBDIR}/include"
+        "$ENV{PROGRAMFILES}/QGIS/include"
+    )
+    FIND_LIBRARY(QGIS_CORE_LIBRARY
+      NAMES qgis_core
+      PATHS
+        "$ENV{LIB_DIR}/lib/"
+        "$ENV{LIB}"
+        "$ENV{OSGEO4W_ROOT}/lib"
+        "$ENV{OSGEO4W_ROOT}/apps/${OSGEO4W_QGIS_SUBDIR}/lib"
+        "$ENV{PROGRAMFILES}/QGIS/lib"
+    )
+    FIND_LIBRARY(QGIS_GUI_LIBRARY
+      NAMES qgis_gui
+      PATHS
+        "$ENV{LIB_DIR}"
+        "$ENV{LIB}"
+        "$ENV{OSGEO4W_ROOT}/lib"
+        "$ENV{OSGEO4W_ROOT}/apps/${OSGEO4W_QGIS_SUBDIR}/lib"
+        "$ENV{PROGRAMFILES}/QGIS/lib"
+    )
+    FIND_LIBRARY(QGIS_ANALYSIS_LIBRARY
+      NAMES qgis_analysis
+      PATHS
+        "$ENV{LIB_DIR}"
+        "$ENV{LIB}"
+        "$ENV{OSGEO4W_ROOT}/lib"
+        "$ENV{OSGEO4W_ROOT}/apps/${OSGEO4W_QGIS_SUBDIR}/lib"
+        "$ENV{PROGRAMFILES}/QGIS/lib"
+    )
+  ENDIF (MSVC)
+ELSE(WIN32)
+  IF(UNIX)
+    #MESSAGE("Searching for QGIS in /usr/bin; /usr/local/bin")
+    FIND_PATH(QGIS_PLUGIN_DIR
+      NAMES libofflineeditingplugin.so
+      PATHS
+        ${QGIS_BUILD_PATH}/PlugIns/qgis
+        ${QGIS_MAC_PATH}/PlugIns/qgis
+        ${QGIS_PREFIX_PATH}/lib/qgis/plugins/
+        /usr/lib64/qgis/plugins
+        /usr/lib/qgis
+        /usr/lib/qgis/plugins
+        /usr/local/lib/qgis/plugins
+        "$ENV{LIB_DIR}/lib/qgis/plugins"
+        "$ENV{LIB_DIR}/lib/qgis"
+    )
+    FIND_PATH(QGIS_INCLUDE_DIR
+      NAMES qgis.h
+      PATHS
+        ${QGIS_BUILD_PATH}/output/lib/qgis_core.framework/Headers
+        ${QGIS_MAC_PATH}/Frameworks/qgis_core.framework/Headers
+        {QGIS_PREFIX_PATH}/include/qgis
+        /usr/include/qgis
+        /usr/local/include/qgis
+        /Library/Frameworks/qgis_core.framework/Headers
+        "$ENV{LIB_DIR}/include/qgis"
+    )
+    FIND_PATH(QGIS_UI_INCLUDE_DIR
+      NAMES ui_qgscredentialdialog.h
+      PATHS
+        ${QGIS_BUILD_PATH}/src/ui
+        ${QGIS_MAC_PATH}/Frameworks/qgis_gui.framework/Headers
+        {QGIS_PREFIX_PATH}/include/qgis
+        /usr/include/qgis
+        /usr/local/include/qgis
+        /Library/Frameworks/qgis_gui.framework/Headers
+        "$ENV{LIB_DIR}/include/qgis"
+    )
+    # also get other frameworks' headers folders on OS X
+    IF (APPLE)
+      FIND_PATH(QGIS_GUI_INCLUDE_DIR
+        NAMES qgsguiutils.h
+        PATHS
+          ${QGIS_BUILD_PATH}/output/lib
+          ${QGIS_MAC_PATH}/Frameworks
+          /Library/Frameworks
+          PATH_SUFFIXES qgis_gui.framework/Headers
+      )
+      FIND_PATH(QGIS_ANALYSIS_INCLUDE_DIR
+        NAMES qgsinterpolator.h
+        PATHS
+          ${QGIS_BUILD_PATH}/output/lib
+          ${QGIS_MAC_PATH}/Frameworks
+          /Library/Frameworks
+          PATH_SUFFIXES qgis_analysis.framework/Headers
+      )
+      SET(QGIS_INCLUDE_DIR
+        ${QGIS_INCLUDE_DIR}
+        ${QGIS_GUI_INCLUDE_DIR}
+        ${QGIS_ANALYSIS_INCLUDE_DIR}
+        ${QGIS_UI_INCLUDE_DIR}
+      )
+    ENDIF (APPLE)
+
+    FIND_LIBRARY(QGIS_CORE_LIBRARY
+      NAMES qgis_core
+      PATHS
+        ${QGIS_BUILD_PATH}/output/lib
+        ${QGIS_MAC_PATH}/Frameworks
+        ${QGIS_MAC_PATH}/lib
+        ${QGIS_PREFIX_PATH}/lib/
+        /usr/lib64
+        /usr/lib
+        /usr/local/lib
+        /Library/Frameworks
+        "$ENV{LIB_DIR}/lib/"
+    )
+    FIND_LIBRARY(QGIS_GUI_LIBRARY
+      NAMES qgis_gui
+      PATHS
+        ${QGIS_BUILD_PATH}/output/lib
+        ${QGIS_MAC_PATH}/Frameworks
+        ${QGIS_MAC_PATH}/lib
+        ${QGIS_PREFIX_PATH}/lib/
+        /usr/lib64
+        /usr/lib
+        /usr/local/lib
+        /Library/Frameworks
+        "$ENV{LIB_DIR}/lib/"
+    )
+    FIND_LIBRARY(QGIS_ANALYSIS_LIBRARY
+      NAMES qgis_analysis
+      PATHS
+        ${QGIS_BUILD_PATH}/output/lib
+        ${QGIS_MAC_PATH}/Frameworks
+        ${QGIS_MAC_PATH}/lib
+        ${QGIS_PREFIX_PATH}/lib/
+        /usr/lib64
+        /usr/lib
+        /usr/local/lib
+        /Library/Frameworks
+        "$ENV{LIB_DIR}/lib/"
+    )
+  ENDIF(UNIX)
+ENDIF(WIN32)
+
+IF (QGIS_INCLUDE_DIR)
+  SET(QGIS_VERSION QGIS_VERSION-NOTFOUND)
+  FIND_FILE(_qgsconfig_h qgsconfig.h PATHS ${QGIS_INCLUDE_DIR})
+  IF (_qgsconfig_h)
+    FILE(READ ${_qgsconfig_h} _qgsconfig)
+    IF (_qgsconfig)
+      # version defined like #define VERSION "2.14.8-Essen"
+      FILE(STRINGS "${_qgsconfig_h}" _qgsversion_str REGEX "^#define VERSION .*$")
+      STRING(REGEX REPLACE "^#define VERSION +\"([0-9]+\\.[0-9]+\\.[0-9]+).*$" "\\1" _qgsversion "${_qgsversion_str}")
+      IF (_qgsversion)
+        SET(QGIS_VERSION ${_qgsversion})
+      ELSE ()
+        MESSAGE(WARNING "No QGIS version determined: failed to parse qgsconfig.h")
+      ENDIF ()
+    ELSE()
+      MESSAGE(WARNING "No QGIS version determined: failed to read qgsconfig.h")
+    ENDIF ()
+  ELSE ()
+    MESSAGE(WARNING "No QGIS version determined: failed to find qgsconfig.h")
+  ENDIF ()
+ENDIF ()
+
+IF (QGIS_INCLUDE_DIR AND QGIS_CORE_LIBRARY AND QGIS_GUI_LIBRARY AND QGIS_ANALYSIS_LIBRARY)
+   SET(QGIS_FOUND TRUE)
+ENDIF ()
+
+IF (QGIS_FOUND)
+   IF (NOT QGIS_FIND_QUIETLY)
+     MESSAGE(STATUS "Found QGIS: ${QGIS_VERSION}")
+     MESSAGE(STATUS "Found QGIS core: ${QGIS_CORE_LIBRARY}")
+     MESSAGE(STATUS "Found QGIS gui: ${QGIS_GUI_LIBRARY}")
+     MESSAGE(STATUS "Found QGIS analysis: ${QGIS_ANALYSIS_LIBRARY}")
+     MESSAGE(STATUS "Found QGIS plugins directory: ${QGIS_PLUGIN_DIR}")
+   ENDIF (NOT QGIS_FIND_QUIETLY)
+ELSE (QGIS_FOUND)
+   IF (QGIS_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find QGIS")
+   ENDIF (QGIS_FIND_REQUIRED)
+ENDIF (QGIS_FOUND)

MyxCMake/find/FindQGLViewer.cmake

@@ -0,0 +1,75 @@
+# - Try to find QGLViewer
+# Once done this will define
+#
+#  QGLVIEWER_FOUND - system has QGLViewer
+#  QGLVIEWER_INCLUDE_DIR - the QGLViewer include directory
+#  QGLVIEWER_LIBRARIES - Link these to use QGLViewer
+#  QGLVIEWER_DEFINITIONS - Compiler switches required for using QGLViewer
+#
+
+# first look in user defined locations
+find_path(QGLVIEWER_INCLUDE_DIR
+          NAMES QGLViewer/qglviewer.h
+          NO_DEFAULT_PATH
+          PATHS ENV QGLVIEWERROOT
+                /usr/local/include
+         )
+
+find_library(QGLVIEWER_LIBRARY_RELEASE
+             NAMES qglviewer-qt5 qglviewer QGLViewer-qt5 QGLViewer QGLViewer2-qt5 QGLViewer2
+             NO_DEFAULT_PATH
+             PATHS ENV QGLVIEWERROOT
+                   ENV LD_LIBRARY_PATH
+                   ENV LIBRARY_PATH
+                   /usr/local/lib
+             PATH_SUFFIXES QGLViewer QGLViewer/release
+            )
+
+find_library(QGLVIEWER_LIBRARY_DEBUG
+             NAMES dqglviewer dQGLViewer-qt5 dQGLViewer dQGLViewer2-qt5 dQGLViewer2 QGLViewerd2-qt5 QGLViewerd2
+             NO_DEFAULT_PATH
+             PATHS /usr/local/lib
+                   ENV QGLVIEWERROOT
+                   ENV LD_LIBRARY_PATH
+                   ENV LIBRARY_PATH
+             PATH_SUFFIXES QGLViewer QGLViewer/debug
+            )
+
+#now try the standard paths
+if (NOT QGLVIEWER_INCLUDE_DIR OR NOT QGLVIEWER_LIBRARY_RELEASE OR NOT QGLVIEWER_LIBRARY_DEBUG)
+find_path(QGLVIEWER_INCLUDE_DIR
+          NAMES QGLViewer/qglviewer.h)
+
+find_library(QGLVIEWER_LIBRARY_RELEASE
+             NAMES qglviewer-qt5 qglviewer QGLViewer-qt5 QGLViewer QGLViewer2-qt5 QGLViewer2)
+
+find_library(QGLVIEWER_LIBRARY_DEBUG
+             NAMES dqglviewer dQGLViewer-qt5 dQGLViewer dQGLViewer2-qt5 dQGLViewer2 QGLViewerd2-qt5 QGLViewerd2)
+
+endif()
+
+if(QGLVIEWER_LIBRARY_RELEASE)
+  if(QGLVIEWER_LIBRARY_DEBUG)
+    set(QGLVIEWER_LIBRARIES_ optimized ${QGLVIEWER_LIBRARY_RELEASE} debug ${QGLVIEWER_LIBRARY_DEBUG})
+  else()
+    set(QGLVIEWER_LIBRARIES_ ${QGLVIEWER_LIBRARY_RELEASE})
+  endif()
+
+  set(QGLVIEWER_LIBRARIES ${QGLVIEWER_LIBRARIES_} CACHE FILEPATH "The QGLViewer library")
+
+endif()
+
+IF(QGLVIEWER_INCLUDE_DIR AND QGLVIEWER_LIBRARIES)
+   SET(QGLVIEWER_FOUND TRUE)
+ENDIF(QGLVIEWER_INCLUDE_DIR AND QGLVIEWER_LIBRARIES)
+
+IF(QGLVIEWER_FOUND)
+  IF(NOT QGLViewer_FIND_QUIETLY)
+    MESSAGE(STATUS "Found QGLViewer: ${QGLVIEWER_LIBRARIES}")
+  ENDIF(NOT QGLViewer_FIND_QUIETLY)
+ELSE(QGLVIEWER_FOUND)
+  IF(QGLViewer_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find QGLViewer")
+  ENDIF(QGLViewer_FIND_REQUIRED)
+ENDIF(QGLVIEWER_FOUND)
+

MyxCMake/find/FindQuadmath.cmake

@@ -0,0 +1,50 @@
+# Module that checks whether the compiler supports the
+# quadruple precision floating point math
+#
+# Sets the following variables:
+# QUADMATH_FOUND
+# QUADMATH_LIBRARIES
+#
+# perform tests
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
+include(CMakePushCheckState)
+include(CheckCXXCompilerFlag)
+
+if(NOT DEFINED USE_QUADMATH OR USE_QUADMATH)
+  if(NOT DEFINED HAVE_EXTENDED_NUMERIC_LITERALS)
+    check_cxx_compiler_flag("-Werror -fext-numeric-literals" HAVE_EXTENDED_NUMERIC_LITERALS)
+  endif()
+
+  if (HAVE_EXTENDED_NUMERIC_LITERALS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fext-numeric-literals")
+  endif()
+
+  cmake_push_check_state(RESET)
+  list(APPEND CMAKE_REQUIRED_LIBRARIES "quadmath")
+  CHECK_CXX_SOURCE_COMPILES("
+#include <quadmath.h>
+
+int main(void){
+    __float128 foo = sqrtq(123.456);
+    foo = FLT128_MIN;
+}" QUADMATH_FOUND)
+  cmake_pop_check_state()
+
+  if (QUADMATH_FOUND)
+    set(QUADMATH_LIBRARIES "quadmath")
+    set(QUADMATH_FOUND "${QUADMATH_FOUND}")
+    set(HAVE_QUADMATH 1)
+  endif()
+endif()
+
+if (USE_QUADMATH AND NOT QUADMATH_FOUND)
+  message(FATAL_ERROR "Quadruple precision math support was explicitly requested but is unavailable!")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Quadmath
+  DEFAULT_MSG
+  QUADMATH_LIBRARIES
+  QUADMATH_FOUND
+  )

MyxCMake/find/FindQwt.cmake

@@ -0,0 +1,57 @@
+# Find Qwt
+# ~~~~~~~~
+# Copyright (c) 2010, Tim Sutton <tim at linfiniti.com>
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
+# Once run this will define:
+#
+# QWT_FOUND       = system has QWT lib
+# QWT_LIBRARY     = full path to the QWT library
+# QWT_INCLUDE_DIR = where to find headers
+#
+
+
+set(QWT_LIBRARY_NAMES qwt-qt5 qwt6-qt5 qwt qwt6)
+
+find_library(QWT_LIBRARY
+  NAMES ${QWT_LIBRARY_NAMES}
+  PATHS
+    /usr/lib
+    /usr/local/lib
+    /usr/local/lib/qt5
+    "$ENV{LIB_DIR}/lib"
+    "$ENV{LIB}"
+)
+
+set(_qwt_fw)
+if(QWT_LIBRARY MATCHES "/qwt.*\\.framework")
+  string(REGEX REPLACE "^(.*/qwt.*\\.framework).*$" "\\1" _qwt_fw "${QWT_LIBRARY}")
+endif()
+
+FIND_PATH(QWT_INCLUDE_DIR NAMES qwt.h PATHS
+  "${_qwt_fw}/Headers"
+  /usr/include
+  /usr/include/qt5
+  /usr/local/include
+  /usr/local/include/qt5
+  "$ENV{LIB_DIR}/include"
+  "$ENV{INCLUDE}"
+  PATH_SUFFIXES qwt-qt5 qwt qwt6
+)
+
+IF (QWT_INCLUDE_DIR AND QWT_LIBRARY)
+  SET(QWT_FOUND TRUE)
+ENDIF (QWT_INCLUDE_DIR AND QWT_LIBRARY)
+
+IF (QWT_FOUND)
+  FILE(READ ${QWT_INCLUDE_DIR}/qwt_global.h qwt_header)
+  STRING(REGEX REPLACE "^.*QWT_VERSION_STR +\"([^\"]+)\".*$" "\\1" QWT_VERSION_STR "${qwt_header}")
+  IF (NOT QWT_FIND_QUIETLY)
+    MESSAGE(STATUS "Found Qwt: ${QWT_LIBRARY} (${QWT_VERSION_STR})")
+  ENDIF (NOT QWT_FIND_QUIETLY)
+ELSE (QWT_FOUND)
+  IF (QWT_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find Qwt")
+  ENDIF (QWT_FIND_REQUIRED)
+ENDIF (QWT_FOUND)

MyxCMake/find/FindQwtPlot3D.cmake

@@ -0,0 +1,55 @@
+# Find QwtPlot3D
+# ~~~~~~~~~~~~~
+# Once run this will define:
+#
+# QWTPLOT3D_FOUND       = system has QwtPlot3D lib
+# QWTPLOT3D_LIBRARY     = full path to the QwtPlot3D library
+# QWTPLOT3D_INCLUDE_DIR = where to find headers
+#
+
+
+set(QWTPLOT3D_LIBRARY_NAMES qwtplot3d-qt5)
+
+find_library(QWTPLOT3D_LIBRARY
+  NAMES ${QWTPLOT3D_LIBRARY_NAMES}
+  PATHS
+    /usr/lib
+    /usr/local/lib
+    /usr/local/lib/qt5
+    "$ENV{LIB_DIR}/lib"
+    "$ENV{LIB}"
+)
+
+set(_qwt_fw)
+if(QWTPLOT3D_LIBRARY MATCHES "/qwt.*\\.framework")
+  string(REGEX REPLACE "^(.*/qwt.*\\.framework).*$" "\\1" _qwt_fw "${QWTPLOT3D_LIBRARY}")
+endif()
+
+FIND_PATH(QWTPLOT3D_INCLUDE_DIR NAMES qwt3d_plot.h PATHS
+  "${_qwt_fw}/Headers"
+  /usr/include
+  /usr/include/qt5
+  /usr/local/include
+  /usr/local/include/qt5
+  "$ENV{LIB_DIR}/include"
+  "$ENV{INCLUDE}"
+  PATH_SUFFIXES qwtplot3d
+)
+
+IF (QWTPLOT3D_INCLUDE_DIR AND QWTPLOT3D_LIBRARY)
+  SET(QWTPLOT3D_FOUND TRUE)
+ENDIF (QWTPLOT3D_INCLUDE_DIR AND QWTPLOT3D_LIBRARY)
+
+IF (QWTPLOT3D_FOUND)
+  FILE(READ ${QWTPLOT3D_INCLUDE_DIR}/qwt3d_global.h qwt_header)
+  STRING(REGEX REPLACE "^.*QWT3D_MAJOR_VERSION +([0-9]+).*$" "\\1" QWT3D_MAJOR_VERSION "${qwt_header}")
+  STRING(REGEX REPLACE "^.*QWT3D_MINOR_VERSION +([0-9]+).*$" "\\1" QWT3D_MINOR_VERSION "${qwt_header}")
+  STRING(REGEX REPLACE "^.*QWT3D_PATCH_VERSION +([0-9]+).*$" "\\1" QWT3D_PATCH_VERSION "${qwt_header}")
+  IF (NOT QWTPLOT3D_FIND_QUIETLY)
+    MESSAGE(STATUS "Found QwtPlot3D: ${QWTPLOT3D_LIBRARY} (${QWT3D_MAJOR_VERSION}.${QWT3D_MINOR_VERSION}.${QWT3D_PATCH_VERSION})")
+  ENDIF (NOT QWTPLOT3D_FIND_QUIETLY)
+ELSE (QWTPLOT3D_FOUND)
+  IF (QWTPLOT3D_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find QwtPlot3D")
+  ENDIF (QWTPLOT3D_FIND_REQUIRED)
+ENDIF (QWTPLOT3D_FOUND)

MyxCMake/find/FindQwtPolar.cmake

@@ -0,0 +1,53 @@
+# Find QwtPolar
+# ~~~~~~~~~~~~~
+# Once run this will define:
+#
+# QWTPOLAR_FOUND       = system has QWTPOLAR lib
+# QWTPOLAR_LIBRARY     = full path to the QWTPOLAR library
+# QWTPOLAR_INCLUDE_DIR = where to find headers
+#
+
+
+set(QWTPOLAR_LIBRARY_NAMES qwtpolar)
+
+find_library(QWTPOLAR_LIBRARY
+  NAMES ${QWTPOLAR_LIBRARY_NAMES}
+  PATHS
+    /usr/lib
+    /usr/local/lib
+    /usr/local/lib/qt5
+    "$ENV{LIB_DIR}/lib"
+    "$ENV{LIB}"
+)
+
+set(_qwt_fw)
+if(QWTPOLAR_LIBRARY MATCHES "/qwt.*\\.framework")
+  string(REGEX REPLACE "^(.*/qwt.*\\.framework).*$" "\\1" _qwt_fw "${QWTPOLAR_LIBRARY}")
+endif()
+
+FIND_PATH(QWTPOLAR_INCLUDE_DIR NAMES qwt_polar.h PATHS
+  "${_qwt_fw}/Headers"
+  /usr/include
+  /usr/include/qt5
+  /usr/local/include
+  /usr/local/include/qt5
+  "$ENV{LIB_DIR}/include"
+  "$ENV{INCLUDE}"
+  PATH_SUFFIXES qwt-qt5 qwt qwt6
+)
+
+IF (QWTPOLAR_INCLUDE_DIR AND QWTPOLAR_LIBRARY)
+  SET(QWTPOLAR_FOUND TRUE)
+ENDIF (QWTPOLAR_INCLUDE_DIR AND QWTPOLAR_LIBRARY)
+
+IF (QWTPOLAR_FOUND)
+  FILE(READ ${QWTPOLAR_INCLUDE_DIR}/qwt_polar_global.h qwt_header)
+  STRING(REGEX REPLACE "^.*QWT_POLAR_VERSION_STR +\"([^\"]+)\".*$" "\\1" QWT_POLAR_VERSION_STR "${qwt_header}")
+  IF (NOT QWTPOLAR_FIND_QUIETLY)
+    MESSAGE(STATUS "Found QwtPolar: ${QWTPOLAR_LIBRARY} (${QWT_POLAR_VERSION_STR})")
+  ENDIF (NOT QWTPOLAR_FIND_QUIETLY)
+ELSE (QWTPOLAR_FOUND)
+  IF (QWTPOLAR_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find QwtPolar")
+  ENDIF (QWTPOLAR_FIND_REQUIRED)
+ENDIF (QWTPOLAR_FOUND)

MyxCMake/find/FindSignalView.cmake

@@ -0,0 +1,45 @@
+if(NOT SIGNALVIEW_IS_EXTERNAL_PROJECT)
+  set(SIGNALVIEW_PREFIX "" CACHE PATH "The path to the prefix of an libsignalview installation")
+  set(SIGNALVIEW_INCLUDE_DIR "" CACHE PATH "The path to the headers of an libsignalview installation")
+  set(SIGNALVIEW_LIBRARY_DIR "" CACHE PATH "The path to the library of an libsignalview installation")
+
+  set(_search_paths "")
+  if(SIGNALVIEW_INCLUDE_DIR AND EXISTS ${SIGNALVIEW_INCLUDE_DIR})
+    list(APPEND _search_paths ${SIGNALVIEW_INCLUDE_DIR})
+  endif()
+  if(SIGNALVIEW_PREFIX AND EXISTS ${SIGNALVIEW_PREFIX})
+    list(APPEND _search_paths "${SIGNALVIEW_PREFIX}/include")
+  endif()
+  find_path(
+    SIGNALVIEW_INCLUDE_DIRS
+    NAMES signalview/wndSignalView.hpp
+    PATHS ${_search_paths})
+
+  set(_search_paths "")
+  if(SIGNALVIEW_LIBRARY_DIR AND EXISTS ${SIGNALVIEW_LIBRARY_DIR})
+    list(APPEND _search_paths ${SIGNALVIEW_LIBRARY_DIR})
+  endif()
+  if(SIGNALVIEW_PREFIX AND EXISTS ${SIGNALVIEW_PREFIX})
+    list(APPEND _search_paths "${SIGNALVIEW_PREFIX}/lib")
+  endif()
+  find_library(
+    SIGNALVIEW_LIBRARIES
+    NAMES signalview
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(SIGNALVIEW_INCLUDE_DIRS AND SIGNALVIEW_LIBRARIES)
+    set(SIGNALVIEW_FOUND TRUE)
+  endif()
+
+  if(SIGNALVIEW_FOUND)
+    if(NOT SIGNALVIEW_FIND_QUIETLY)
+      message(STATUS "Found libsignalview")
+    endif()
+    set(HAVE_SIGNALVIEW 1)
+  elseif(SIGNALVIEW_FOUND)
+    if(SIGNALVIEW_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libsignalview")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindSignalViewThirdparty.cmake

@@ -0,0 +1,41 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+set(SIGNALVIEW_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(SIGNALVIEW_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(SIGNALVIEW_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(SIGNALVIEW_LIBRARY_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    CACHE PATH "" FORCE)
+set(SIGNALVIEW_LIBRARIES
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/libsignalview.a
+    CACHE FILEPATH "" FORCE)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  libsignalview
+  DEPENDS libpreprocmath
+  SOURCE_DIR       ${CMAKE_SOURCE_DIR}/thirdparty/libsignalview
+  INSTALL_DIR      ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS       ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+                   -DPREPROCMATH_PREFIX=${CMAKE_BINARY_DIR}
+                   <SOURCE_DIR>)
+if(SignalViewThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND    true
+    INSTALL_COMMAND  ${CMAKE_MAKE_PROGRAM} signalview-install-headers)
+else()
+  list(APPEND _ext_project_args
+    BUILD_BYPRODUCTS ${SIGNALVIEW_LIBRARIES})
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(SIGNALVIEW_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on

MyxCMake/find/FindSphinx.cmake

@@ -0,0 +1,38 @@
+# - This module looks for Sphinx
+# Find the Sphinx documentation generator
+#
+# This modules defines
+#  SPHINX_EXECUTABLE
+#  SPHINX_FOUND
+
+#=============================================================================
+# Copyright 2002-2009 Kitware, Inc.
+# Copyright 2009-2011 Peter Colberg
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file COPYING-CMAKE-SCRIPTS for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+find_program(SPHINX_EXECUTABLE NAMES sphinx-build
+  HINTS
+  $ENV{SPHINX_DIR}
+  HINTS ${SPHINX_ROOT}/bin
+  PATH_SUFFIXES bin
+  DOC "Sphinx documentation generator"
+)
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(Sphinx DEFAULT_MSG
+  SPHINX_EXECUTABLE
+)
+
+mark_as_advanced(
+  SPHINX_EXECUTABLE
+)

MyxCMake/find/FindVeerProtocols.cmake

@@ -0,0 +1,32 @@
+if(NOT VEER_PROTOCOLS_IS_EXTERNAL_PROJECT)
+  set(VEER_PROTOCOLS_PREFIX "" CACHE PATH "The path to the prefix of veer protocols installation")
+  set(VEER_PROTOCOLS_INCLUDE_DIR "" CACHE PATH "The path to the headers of veer protocols installation")
+
+  set(_search_paths "")
+  if(EXISTS VEER_PROTOCOLS_INCLUDE_DIR)
+    list(APPEND _search_paths ${VEER_PROTOCOLS_INCLUDE_DIR})
+  endif()
+  if(EXISTS VEER_PROTOCOLS_PREFIX)
+    list(APPEND _search_paths ${VEER_PROTOCOLS_PREFIX}/include)
+  endif()
+  find_path(
+    VEER_PROTOCOLS_INCLUDE_DIRS
+    NAMES veer/common/ports.hpp
+    PATHS ${_search_paths})
+  unset(_search_paths)
+
+  if(VEER_PROTOCOLS_INCLUDE_DIRS)
+    set(VEER_PROTOCOLS_FOUND TRUE)
+  endif()
+
+  if(VEER_PROTOCOLS_FOUND)
+    if(NOT VEER_PROTOCOLS_FIND_QUIETLY)
+      message(STATUS "Found veer protocols")
+    endif()
+    set(HAVE_VEER_PROTOCOLS 1)
+  elseif(VEER_PROTOCOLS_FOUND)
+    if(VEER_PROTOCOLS_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find veer protocols")
+    endif()
+  endif()
+endif()

MyxCMake/find/FindVeerProtocolsThirdparty.cmake

@@ -0,0 +1,30 @@
+# Подключение внешних проектов
+include(ExternalProject)
+
+# cmake-format: off
+list(APPEND _ext_project_args
+  veer-protocols
+  SOURCE_DIR  ${CMAKE_SOURCE_DIR}/thirdparty/veer-protocols
+  INSTALL_DIR ${CMAKE_BINARY_DIR}
+  CMAKE_ARGS  ${CMLIB_EXT_PROJ_DEFAULT_ARGS}
+              <SOURCE_DIR>)
+if(VeerProtocolsThirdparty_FIND_COMPONENTS STREQUAL "headers")
+  list(APPEND _ext_project_args
+    BUILD_COMMAND     true
+    INSTALL_COMMAND   ${CMAKE_MAKE_PROGRAM} veer-protocols-install-headers)
+endif()
+ExternalProject_Add(${_ext_project_args})
+unset(_ext_project_args)
+
+set(VEER_PROTOCOLS_IS_EXTERNAL_PROJECT ON CACHE BOOL "" FORCE)
+# cmake-format: on
+
+set(VEER_PROTOCOLS_PREFIX
+    ${CMAKE_BINARY_DIR}
+    CACHE FILEPATH "" FORCE)
+set(VEER_PROTOCOLS_INCLUDE_DIR
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)
+set(VEER_PROTOCOLS_INCLUDE_DIRS
+    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}
+    CACHE PATH "" FORCE)

MyxCMake/functions/MyxCMakeGenerateGitInfoHeader.cmake

@@ -0,0 +1,19 @@
+function(myx_cmake_generate_git_info_header)
+  set(output_file ${CMAKE_BINARY_DIR}/include/myx_cmake_git_info.hpp)
+  if(MYX_CMAKE_GENERATED_HEADERS_PATH)
+    set(output_file ${MYX_CMAKE_GENERATED_HEADERS_PATH}/myx_cmake_git_info.hpp)
+  elseif(ARGV0)
+    set(output_file ${ARGV0})
+  endif()
+
+# cmake-format: off
+  if(NOT TARGET myx-cmake-git-info-header)
+    add_custom_target(myx-cmake-git-info-header ALL
+      ${CMAKE_COMMAND} -DMYX_CMAKE_PROJECT_NAME_UPPER=${MYX_CMAKE_PROJECT_NAME_UPPER}
+                       -DMYX_CMAKE_MODULE_DIR=${MYX_CMAKE_MODULE_DIR}
+                       -DMYX_CMAKE_GIT_INFO_FILE=${output_file} -P ${CMAKE_CURRENT_LIST_DIR}/MyxCMakeGitInfo.cmake
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+  endif()
+# cmake-format: on
+endfunction()
+

MyxCMake/functions/MyxCMakeGeneratePrivateConfigHeader.cmake

@@ -0,0 +1,14 @@
+function(myx_cmake_generate_private_config_header)
+  include(${CMAKE_CURRENT_LIST_DIR}/MyxCMakeLargeFiles.cmake)
+  myx_cmake_test_large_files(HAVE_LARGEFILES)
+
+  set(output_file ${CMAKE_BINARY_DIR}/include/myx_cmake_private_config.hpp)
+  if(MYX_CMAKE_GENERATED_HEADERS_PATH)
+    set(output_file ${CMLIB_GENERATED_HEADERS_PATH}/myx_cmake_private_config.hpp)
+  elseif(ARGV0)
+    set(output_file ${ARGV0})
+  endif()
+
+  get_property(PROJECT_VERSION_INT GLOBAL PROPERTY PROJECT_VERSION_INT)
+  configure_file(${CMAKE_CURRENT_LIST_DIR}/hpp/myx_cmake_private_config.hpp.in ${output_file})
+endfunction()

MyxCMake/functions/MyxCMakeGitInfo.cmake

@@ -0,0 +1,25 @@
+set(MYX_CMAKE_GIT_REV "N/A")
+set(MYX_CMAKE_GIT_DIFF "")
+set(MYX_CMAKE_GIT_TAG "N/A")
+set(MYX_CMAKE_GIT_BRANCH "N/A")
+
+find_program(GIT_EXECUTABLE git)
+if(GIT_EXECUTABLE)
+  execute_process(COMMAND git log --pretty=format:'%h' -n 1 OUTPUT_VARIABLE MYX_CMAKE_GIT_REV ERROR_QUIET)
+
+  # Check whether we got any revision (which isn't always the case,
+  # e.g. when someone downloaded a zip file from Github instead of a checkout)
+  if(NOT "${MYX_CMAKE_GIT_REV}" STREQUAL "")
+    execute_process(COMMAND bash -c "git diff --quiet --exit-code || echo +" OUTPUT_VARIABLE MYX_CMAKE_GIT_DIFF)
+    execute_process(COMMAND git describe --exact-match --tags OUTPUT_VARIABLE MYX_CMAKE_GIT_TAG ERROR_QUIET)
+    execute_process(COMMAND git rev-parse --abbrev-ref HEAD OUTPUT_VARIABLE MYX_CMAKE_GIT_BRANCH)
+
+    string(STRIP "${MYX_CMAKE_GIT_REV}" MYX_CMAKE_GIT_REV)
+    string(SUBSTRING "${MYX_CMAKE_GIT_REV}" 1 7 MYX_CMAKE_GIT_REV)
+    string(STRIP "${MYX_CMAKE_GIT_DIFF}" MYX_CMAKE_GIT_DIFF)
+    string(STRIP "${MYX_CMAKE_GIT_TAG}" MYX_CMAKE_GIT_TAG)
+    string(STRIP "${MYX_CMAKE_GIT_BRANCH}" MYX_CMAKE_GIT_BRANCH)
+  endif()
+endif()
+
+configure_file(${CMAKE_CURRENT_LIST_DIR}/hpp/mux_cmake_git_info.hpp.in ${MYX_CMAKE_GIT_VERSION_FILE})

MyxCMake/functions/MyxCMakeHighPrecisionMath.cmake

@@ -0,0 +1,11 @@
+find_package(Quadmath)
+if(QUADMATH_FOUND)
+  add_definitions(-DHAVE_QUADMATH=1)
+else()
+  find_package(MPFR)
+  if(MPFR_FOUND)
+    find_package(MPFRCppThirdparty)
+  else()
+    message(FATAL_ERROR "Nor Quadmath, nor MPFR found.")
+  endif()
+endif()

MyxCMake/functions/MyxCMakeLargeFiles.cmake

@@ -0,0 +1,158 @@
+#
+# This file is part of the GROMACS molecular simulation package.
+#
+# Copyright (c) 2009,2010,2012,2014,2019, by the GROMACS development team, led by
+# Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
+# and including many others, as listed in the AUTHORS file in the
+# top-level source directory and at http://www.gromacs.org.
+#
+# GROMACS is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public License
+# as published by the Free Software Foundation; either version 2.1
+# of the License, or (at your option) any later version.
+#
+# GROMACS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with GROMACS; if not, see
+# http://www.gnu.org/licenses, or write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+#
+# If you want to redistribute modifications to GROMACS, please
+# consider that scientific software is very special. Version
+# control is crucial - bugs must be traceable. We will be happy to
+# consider code for inclusion in the official distribution, but
+# derived work must not be called official GROMACS. Details are found
+# in the README & COPYING files - if they are missing, get the
+# official version at http://www.gromacs.org.
+#
+# To help us fund GROMACS development, we humbly ask that you cite
+# the research papers on the package. Check out http://www.gromacs.org.
+
+# Forked from Gromacs
+
+# - Define macro to check large file support
+#
+#  myx_cmake_test_large_files(VARIABLE)
+#
+#  VARIABLE will be set to true if off_t is 64 bits, and fseeko/ftello present.
+#  This macro will also set defines necessary enable large file support, for instance
+#  _LARGE_FILES
+#  _LARGEFILE_SOURCE
+#  _FILE_OFFSET_BITS 64
+#  HAVE_FSEEKO
+#  HAVE__FSEEKI64
+#
+#  However, it is YOUR job to make sure these defines are set in a cmakedefine so they
+#  end up in a config.h file that is included in your source if necessary!
+
+include(CheckTypeSize)
+
+macro(myx_cmake_test_large_files VARIABLE)
+  if(NOT DEFINED ${VARIABLE})
+
+    # On most platforms it is probably overkill to first test the flags for 64-bit off_t,
+    # and then separately fseeko. However, in the future we might have 128-bit filesystems
+    # (ZFS), so it might be dangerous to indiscriminately set e.g. _FILE_OFFSET_BITS=64.
+
+    message(STATUS "Checking for 64-bit off_t")
+
+    # First check without any special flags
+    try_compile(FILE64_OK "${CMAKE_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/largefiles/TestFileOffsetBits.c")
+    if(FILE64_OK)
+      message(STATUS "Checking for 64-bit off_t - present")
+    endif()
+
+    if(NOT FILE64_OK)
+      # Test with _FILE_OFFSET_BITS=64
+      try_compile(FILE64_OK "${CMAKE_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/largefiles/TestFileOffsetBits.c"
+                  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 64 CACHE INTERNAL "64-bit off_t requires _FILE_OFFSET_BITS=64")
+      endif()
+    endif()
+
+    if(NOT FILE64_OK)
+      # Test with _LARGE_FILES
+      try_compile(FILE64_OK "${CMAKE_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/largefiles/TestFileOffsetBits.c"
+                  COMPILE_DEFINITIONS "-D_LARGE_FILES")
+      if(FILE64_OK)
+        message(STATUS "Checking for 64-bit off_t - present with _LARGE_FILES")
+        set(_LARGE_FILES 1 CACHE INTERNAL "64-bit off_t requires _LARGE_FILES")
+      endif()
+    endif()
+
+    if(NOT FILE64_OK)
+      # Test with _LARGEFILE_SOURCE
+      try_compile(FILE64_OK "${CMAKE_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/largefiles/TestFileOffsetBits.c"
+                  COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE")
+      if(FILE64_OK)
+        message(STATUS "Checking for 64-bit off_t - present with _LARGEFILE_SOURCE")
+        set(_LARGEFILE_SOURCE 1 CACHE INTERNAL "64-bit off_t requires _LARGEFILE_SOURCE")
+      endif()
+    endif()
+
+    if(NOT FILE64_OK)
+      message(STATUS "Checking for 64-bit off_t - not present")
+    else()
+      # 64-bit off_t found. Now check that ftello/fseeko is available.
+
+      # Set the flags we might have determined to be required above
+      configure_file("${CMAKE_CURRENT_LIST_DIR}/largefiles/TestLargeFiles.c.in"
+                     "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
+
+      message(STATUS "Checking for fseeko/ftello")
+      # Test if ftello/fseeko are available
+      try_compile(FSEEKO_COMPILE_OK "${CMAKE_BINARY_DIR}"
+                  "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
+      if(FSEEKO_COMPILE_OK)
+        message(STATUS "Checking for fseeko/ftello - present")
+      endif()
+
+      if(NOT FSEEKO_COMPILE_OK)
+        # glibc 2.2 neds _LARGEFILE_SOURCE for fseeko (but not 64-bit off_t...)
+        try_compile(
+          FSEEKO_COMPILE_OK "${CMAKE_BINARY_DIR}"
+          "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c"
+          COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE")
+        if(FSEEKO_COMPILE_OK)
+          message(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
+          set(_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!")
+        endif()
+      endif()
+    endif()
+
+    # cmake-lint: disable=C0103
+    if(NOT FILE64_OK)
+      # now check for Windows stuff
+      try_compile(FILE64_OK "${CMAKE_BINARY_DIR}" "${CMAKE_CURRENT_LIST_DIR}/largefiles/TestWindowsFSeek.c")
+      if(FILE64_OK)
+        message(STATUS "Checking for 64-bit off_t - present with _fseeki64")
+        set(HAVE__FSEEKI64 1 CACHE INTERNAL "64-bit off_t requires _fseeki64")
+      endif()
+    endif()
+
+    if(FSEEKO_COMPILE_OK)
+      set(${VARIABLE} 1 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} 1 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} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
+      else()
+        message(FATAL_ERROR "Checking for 64bit file support failed.")
+      endif()
+    endif()
+
+  endif()
+endmacro(myx_cmake_test_large_files VARIABLE)

MyxCMake/functions/MyxCMakeQtTranslation.cmake

@@ -0,0 +1,58 @@
+function(myx_cmake_qt5_translation outfiles)
+  find_package(Qt5 COMPONENTS LinguistTools REQUIRED)
+
+  set(options)
+  set(oneValueArgs BASE_NAME OUTPUT_DIR)
+  set(multiValueArgs SOURCES LANGUAGES)
+
+  cmake_parse_arguments(_QTTR "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+  set(_base_name ${_QTTR_BASE_NAME})
+  set(_sources ${_QTTR_SOURCES})
+  set(_output_dir ${_QTTR_OUTPUT_DIR})
+  set(_languages ${_QTTR_LANGUAGES})
+
+  set(L10N_QRC_BODY "")
+  make_directory(${_output_dir})
+
+  foreach(lang ${_languages})
+    set(_ts "${_base_name}_${lang}.ts")
+    set(_qm "${_base_name}_${lang}.qm")
+    list(APPEND _ts_list ${_output_dir}/${_ts})
+    list(APPEND _l10n_names_list "${_base_name}_l10n_${lang}")
+    string(APPEND L10N_QRC_BODY "<file alias=\"${_qm}\">${CMAKE_BINARY_DIR}/${_qm}</file>\n")
+
+    add_custom_target(
+      ${_base_name}_l10n_${lang} COMMAND ${Qt5_LUPDATE_EXECUTABLE} ${_sources} -ts ${_output_dir}/${_ts}
+                                         -target-language ${lang} DEPENDS ${_sources})
+
+    if(NOT EXISTS "${_output_dir}/${_ts}")
+      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} COMMAND ${Qt5_LRELEASE_EXECUTABLE} ARGS ${_output_dir}/${_ts} -qm
+                                                ${CMAKE_BINARY_DIR}/${_qm} DEPENDS ${_ts} ${_sources})
+  endforeach()
+
+  #  configure_file(${CMLIB_MODULE_DIR}/qrc/l10n.qrc.in ${CMAKE_BINARY_DIR}/${_base_name}_l10n.qrc)
+  file(WRITE ${CMAKE_BINARY_DIR}/${_base_name}_l10n.qrc
+    "<RCC>\n"
+    "  <qresource prefix="/qm">\n"
+    "    ${L10N_QRC_BODY}\n"
+    "  </qresource>\n"
+    "</RCC>\n"
+    )
+  qt5_add_resources(${outfiles} ${CMAKE_BINARY_DIR}/${_base_name}_l10n.qrc)
+  add_custom_target(${_base_name}_qrc DEPENDS ${_qrc})
+  add_custom_target(${_base_name}_l10n DEPENDS ${_l10n_names_list})
+  if(NOT TARGET l10n)
+    add_custom_target(l10n)
+  endif()
+  add_dependencies(l10n ${_base_name}_l10n)
+
+  # add_dependencies(${_target} ${_target}_qrc)
+  # target_sources(${_target} PUBLIC ${_qrc})
+  set(${outfiles} ${${outfiles}} PARENT_SCOPE)
+endfunction()

MyxCMake/functions/MyxCMakeRemoveFlag.cmake

@@ -0,0 +1,73 @@
+# https://stackoverflow.com/a/49216539
+#
+# Removes the specified compile flag from the specified target.
+#   _target     - The target to remove the compile flag from
+#   _flag       - The compile flag to remove
+#
+# Pre: apply_global_cxx_flags_to_all_targets() must be invoked.
+#
+# cmake-lint: disable=C0103
+macro(myx_cmake_remove_flag_from_target _target _flag)
+  get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS)
+  if(_target_cxx_flags)
+    list(REMOVE_ITEM _target_cxx_flags ${_flag})
+    set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "${_target_cxx_flags}")
+  endif()
+endmacro()
+
+#
+# Removes the specified compiler flag from the specified file.
+#   _target     - The target that _file belongs to
+#   _file       - The file to remove the compiler flag from
+#   _flag       - The compiler flag to remove.
+#
+# Pre: apply_global_cxx_flags_to_all_targets() must be invoked.
+#
+# cmake-lint: disable=C0103
+macro(myx_cmake_remove_flag_from_file _target _file _flag)
+  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.
+  if(_flag_sync_required)
+    unset(_cached_${_target}_cxx_flags CACHE)
+    unset(_cached_${_target}_${_file}_cxx_flags CACHE)
+  endif()
+  get_target_property(_${_target}_cxx_flags ${_target} COMPILE_OPTIONS)
+  # On first entry, cache the target compile flags and apply them to each source file
+  # in the target.
+  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 "${_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})
+      # Check for pre-existing flags set by set_source_files_properties().
+      get_source_file_property(_source_file_cxx_flags ${_source_file} COMPILE_FLAGS)
+      if(_source_file_cxx_flags)
+        separate_arguments(_source_file_cxx_flags UNIX_COMMAND ${_source_file_cxx_flags})
+        list(APPEND _source_file_cxx_flags "${_target_cxx_flags}")
+      else()
+        set(_source_file_cxx_flags "${_target_cxx_flags}")
+      endif()
+      # Apply the compile flags to the current source file.
+      string(REPLACE ";" " " _source_file_cxx_flags_string "${_source_file_cxx_flags}")
+      set_source_files_properties(${_source_file} PROPERTIES COMPILE_FLAGS "${_source_file_cxx_flags_string}")
+    endforeach()
+  endif()
+  list(FIND _target_sources ${_file} _file_found_at)
+  if(_file_found_at GREATER -1)
+    if(NOT _cached_${_target}_${_file}_cxx_flags)
+      # Cache the compile flags for the specified file.
+      # 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 ${_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()

MyxCMake/functions/MyxCMakeWriteCompilerDetectionHeader.cmake

@@ -0,0 +1,30 @@
+function(myx_cmake_write_compiler_detection_header)
+
+  if(${CMAKE_VERSION} VERSION_LESS "3.6.0")
+    return()
+  endif()
+
+  include(WriteCompilerDetectionHeader)
+
+  set(OUTPUT_FILE ${CMAKE_BINARY_DIR}/include/compiler_features.hpp)
+  if(MYX_CMAKE_GENERATED_HEADER_FILENAME)
+    set(OUTPUT_FILE ${MYX_CMAKE_GENERATED_HEADER_FILENAME})
+  endif()
+
+  write_compiler_detection_header(
+    FILE ${OUTPUT_FILE}
+    PREFIX ${MYX_CMAKE_PROJECT_NAME_CANONICAL}
+    COMPILERS GNU Clang MSVC Intel
+    FEATURES
+      cxx_nullptr
+      cxx_override
+      cxx_alignas
+      cxx_alignof
+      cxx_attributes
+      cxx_auto_type
+      cxx_constexpr
+      cxx_digit_separators
+      cxx_range_for)
+  unset(OUTPUT_FILE)
+endfunction()
+

MyxCMake/functions/hpp/myx_cmake_git_info.hpp.in

@@ -0,0 +1,31 @@
+#ifndef @MYX_CMAKE_PROJECT_NAME_UPPER@_MYX_CMAKE_GIT_INFO_HPP_
+#define @MYX_CMAKE_PROJECT_NAME_UPPER@_MYX_CMAKE_GIT_INFO_HPP_
+
+#pragma once
+
+#if defined (@MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_REV)
+#error "Duplicate definition of macros @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_REV"
+#else
+#define @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_REV "@MYX_CMAKE_GIT_REV@"
+#endif
+
+#if defined (@MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_DIFF)
+#error "Duplicate definition of macros @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_DIFF"
+#else
+#define @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_DIFF "@MYX_CMAKE_GIT_DIFF@"
+#endif
+
+#if defined (@MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_BRANCH)
+#error "Duplicate definition of macros @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_BRANCH"
+#else
+#define @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_BRANCH "@MYX_CMAKE_GIT_BRANCH@"
+#endif
+
+#if defined (@MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_TAG)
+#error "Duplicate definition of macros @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_TAG"
+#else
+#define @MYX_CMAKE_PROJECT_NAME_UPPER@_GIT_TAG "@MYX_CMAKE_GIT_TAG@"
+#endif
+
+#endif /* @MYX_CMAKE_PROJECT_NAME_UPPER@_MYX_CMAKE_GIT_INFO_HPP_ */
+

MyxCMake/functions/hpp/myx_cmake_private_config.hpp.in

@@ -0,0 +1,94 @@
+#ifndef @CMLIB_PROJECT_NAME_UPPER@_CMLIB_CONFIG_HPP_
+#define @CMLIB_PROJECT_NAME_UPPER@_CMLIB_CONFIG_HPP_
+
+#pragma once
+
+#define @CMLIB_PROJECT_NAME_UPPER@_VERSION_STR "@PROJECT_VERSION@"
+#define @CMLIB_PROJECT_NAME_UPPER@_VERSION_INT @PROJECT_VERSION_INT@
+
+#if defined (CMLIB_ORGANIZATION_NAME)
+#error "Duplicate definition of macros CMLIB_ORGANIZATION_NAME"
+#else
+#define CMLIB_ORGANIZATION_NAME "@CMLIB_ORGANIZATION_NAME@"
+#endif
+
+#if defined (CMLIB_ORGANIZATION_NAME_LOWER)
+#error "Duplicate definition of macros CMLIB_ORGANIZATION_NAME_LOWER"
+#else
+#define CMLIB_ORGANIZATION_NAME_LOWER "@CMLIB_ORGANIZATION_NAME_LOWER@"
+#endif
+
+#if defined (CMLIB_ORGANIZATION_NAME_UPPER)
+#error "Duplicate definition of macros CMLIB_ORGANIZATION_NAME_UPPER"
+#else
+#define CMLIB_ORGANIZATION_NAME_UPPER "@CMLIB_ORGANIZATION_NAME_UPPER@"
+#endif
+
+#if defined (CMLIB_PROJECT_NAME)
+#error "Duplicate definition of macros CMLIB_PROJECT_NAME"
+#else
+#define CMLIB_PROJECT_NAME "@CMAKE_PROJECT_NAME@"
+#endif
+
+#if defined (CMLIB_PROJECT_NAME_LOWER)
+#error "Duplicate definition of macros CMLIB_PROJECT_NAME_LOWER"
+#else
+#define CMLIB_PROJECT_NAME_LOWER "@CMLIB_PROJECT_NAME_LOWER@"
+#endif
+
+#if defined (CMLIB_PROJECT_NAME_UPPER)
+#error "Duplicate definition of macros CMLIB_PROJECT_NAME_UPPER"
+#else
+#define CMLIB_PROJECT_NAME_UPPER "@CMLIB_PROJECT_NAME_UPPER@"
+#endif
+
+#if defined (CMLIB_THEME_NAME)
+#error "Duplicate definition of macros CMLIB_THEME_NAME"
+#else
+#define CMLIB_THEME_NAME "@CMLIB_THEME_NAME@"
+#endif
+
+#if defined (CMLIB_THEME_NAME_LOWER)
+#error "Duplicate definition of macros CMLIB_THEME_NAME_LOWER"
+#else
+#define CMLIB_THEME_NAME_LOWER "@CMLIB_THEME_NAME_LOWER@"
+#endif
+
+#if defined (CMLIB_THEME_NAME_UPPER)
+#error "Duplicate definition of macros CMLIB_THEME_NAME_UPPER"
+#else
+#define CMLIB_THEME_NAME_UPPER "@CMLIB_THEME_NAME_UPPER@"
+#endif
+
+#if defined (CMLIB_AUTHOR_NAME)
+#error "Duplicate definition of macros CMLIB_AUTHOR_NAME"
+#else
+#define CMLIB_AUTHOR_NAME "@CMLIB_AUTHOR_NAME@"
+#endif
+
+#if defined (CMLIB_AUTHOR_EMAIL)
+#error "Duplicate definition of macros CMLIB_AUTHOR_EMAIL"
+#else
+#define CMLIB_AUTHOR_EMAIL "@CMLIB_AUTHOR_EMAIL@"
+#endif
+
+#if defined (CMLIB_DESCRIPTION)
+#error "Duplicate definition of macros CMLIB_DESCRIPTION"
+#else
+#define CMLIB_DESCRIPTION "@CMLIB_DESCRIPTION@"
+#endif
+
+#if defined (CMLIB_BUILD_TYPE)
+#error "Duplicate definition of macros CMLIB_BUILD_TYPE"
+#else
+#define CMLIB_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
+#endif
+
+#if defined (CMLIB_BUILD_DATE)
+#error "Duplicate definition of macros CMLIB_BUILD_DATE"
+#else
+#define CMLIB_BUILD_DATE "@TODAY@"
+#endif
+
+#endif /* @CMLIB_PROJECT_NAME_UPPER@_CMLIB_CONFIG_HPP_ */
+

MyxCMake/functions/largefiles/TestFileOffsetBits.c

@@ -0,0 +1,11 @@
+#include <sys/types.h>
+
+/* Cause a compile-time error if off_t is smaller than 64 bits */
+#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
+int off_t_is_large[ (LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1 ];  
+
+int main(int argc, char **argv)
+{
+  return 0;
+}
+

MyxCMake/functions/largefiles/TestLargeFiles.c.in

@@ -0,0 +1,24 @@
+#cmakedefine _LARGEFILE_SOURCE
+#cmakedefine _LARGEFILE64_SOURCE
+#cmakedefine _LARGE_FILES
+#cmakedefine _FILE_OFFSET_BITS @_FILE_OFFSET_BITS@
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv)
+{
+  /* Cause a compile-time error if off_t is smaller than 64 bits,
+   * and make sure we have ftello / fseeko.
+   */
+#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
+  int off_t_is_large[ (LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1 ];
+  FILE *fp = fopen(argv[0],"r");
+  off_t offset = ftello( fp );
+
+  fseeko( fp, offset, SEEK_CUR );
+  fclose(fp);
+  return off_t_is_large[0] || argc;
+}
+

MyxCMake/functions/largefiles/TestWindowsFSeek.c

@@ -0,0 +1,11 @@
+
+#include <stdio.h>
+    
+int main()
+{
+  __int64 off=0;
+
+  _fseeki64(NULL, off, SEEK_SET);
+        
+  return 0;
+}

MyxCMake/modules/MyxCMakeAddSharedLibrary.cmake

@@ -0,0 +1,21 @@
+# Создание динамической библиотеки из объектной библиотеки
+function(myx_cmake_add_shared_library target)
+  get_target_property(_target_type ${target} TYPE)
+  if(NOT _target_type STREQUAL OBJECT_LIBRARY)
+    message(
+      FATAL_ERROR
+        "MyxCMake: add_shared_library needs target of type OBJECT_LIBRARY")
+    return()
+  endif()
+
+  add_library(${target}-shared SHARED $<TARGET_OBJECTS:${target}>)
+  set_target_properties(
+    ${target}-shared
+    PROPERTIES OUTPUT_NAME ${target}
+               VERSION ${PROJECT_VERSION}
+               SOVERSION ${PROJECT_VERSION_MAJOR}
+               LIBRARY_OUTPUT_DIRECTORY
+               ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+  install(TARGETS ${target}-static LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+endfunction()

MyxCMake/modules/MyxCMakeAddStaticLibrary.cmake

@@ -0,0 +1,19 @@
+# Создание статической библиотеки из объектной библиотеки
+function(myx_cmake_add_static_library target)
+  get_target_property(_target_type ${target} TYPE)
+  if(NOT _target_type STREQUAL OBJECT_LIBRARY)
+    message(
+      FATAL_ERROR
+        "MyxCMake: add_static_library needs target of type OBJECT_LIBRARY")
+    return()
+  endif()
+
+  add_library(${target}-static STATIC $<TARGET_OBJECTS:${target}>)
+  set_target_properties(
+    ${target}-static
+    PROPERTIES OUTPUT_NAME ${target}
+               ARCHIVE_OUTPUT_DIRECTORY
+               ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+  install(TARGETS ${target}-static ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+endfunction()

MyxCMake/modules/MyxCMakeBuildTypes.cmake

@@ -0,0 +1,96 @@
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW) # IN_LIST operator
+
+option(MYX_CMAKE_ENABLE_WARNING_FLAGS "Enable autodetected warning flags" ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS
+    ON
+    CACHE BOOL "Enable generation of compile_commands.json." FORCE)
+
+# Добавление конфигурации для профилирования
+if(CMAKE_CONFIGURATION_TYPES)
+  if(NOT "Profile" IN_LIST CMAKE_CONFIGURATION_TYPES)
+    list(APPEND CMAKE_CONFIGURATION_TYPES Profile)
+  endif()
+else()
+  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)
+  elseif(NOT "${CMAKE_BUILD_TYPE}" IN_LIST _allowed_build_types)
+    message(FATAL_ERROR "Invalid build type: ${CMAKE_BUILD_TYPE}")
+  endif()
+endif()
+
+set(_gcc_debug_flags "-ggdb -fno-omit-frame-pointer")
+set(_gcc_profile_flags "-pg")
+
+if(CMAKE_BUILD_TYPE STREQUAL Profile)
+  # Ключи компиляции для режима профилирования в зависимости от типа компилятора
+  if(CMAKE_CXX_COMPILER_IS_CLANG OR CMAKE_CXX_COMPILER_IS_GCC)
+    set(CMAKE_C_FLAGS_PROFILE
+        "${CMAKE_C_FLAGS_RELEASE} ${_gcc_debug_flags} ${_gcc_profile_flags}"
+        CACHE STRING "" FORCE)
+    set(CMAKE_CXX_FLAGS_PROFILE
+        "${CMAKE_CXX_FLAGS_RELEASE} ${MYX_CMAKE_DETECTED_CXX_FLAGS} ${_gcc_debug_flags} ${_gcc_profile_flags}"
+        CACHE STRING "" FORCE)
+    set(CMAKE_EXE_LINKER_FLAGS_PROFILE
+        "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${_gcc_profile_flags}"
+        CACHE STRING "" FORCE)
+    set(CMAKE_SHARED_LINKER_FLAGS_PROFILE
+        "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${_gcc_profile_flags}"
+        CACHE STRING "" FORCE)
+    set(CMAKE_STATIC_LINKER_FLAGS_PROFILE
+        "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} ${_gcc_profile_flags}"
+        CACHE STRING "" FORCE)
+    set(CMAKE_MODULE_LINKER_FLAGS_PROFILE
+        "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${_gcc_profile_flags}"
+        CACHE STRING "" FORCE)
+  elseif(CMAKE_CXX_COMPILER_IS_Intel)
+    message("Set options for profiling with Intel C++")
+  elseif(CMAKE_CXX_COMPILER_IS_MSVC)
+    message("Set options for profiling with Visual Studio C++")
+  endif()
+  set(CMAKE_VERBOSE_MAKEFILE
+      ON
+      CACHE BOOL "Enable generation of verbose build scripts." FORCE)
+elseif(CMAKE_BUILD_TYPE STREQUAL Debug)
+  # В режиме отладки подробный вывод сообщений компилятора
+  if(CMAKE_CXX_COMPILER_IS_CLANG OR CMAKE_CXX_COMPILER_IS_GCC)
+    string(REPLACE " ${_gcc_debug_flags}" "" CMAKE_C_FLAGS_DEBUG
+                   "${CMAKE_C_FLAGS_DEBUG}")
+    set(CMAKE_C_FLAGS_DEBUG
+        "${CMAKE_C_FLAGS_DEBUG} ${_gcc_debug_flags}"
+        CACHE STRING "" FORCE)
+
+    string(REPLACE " ${_gcc_debug_flags}" "" CMAKE_CXX_FLAGS_DEBUG
+                   "${CMAKE_CXX_FLAGS_DEBUG}")
+    if(MYX_CMAKE_ENABLE_WARNING_FLAGS)
+      set(CMAKE_CXX_FLAGS_DEBUG
+          "${CMAKE_CXX_FLAGS_DEBUG} ${MYX_CMAKE_DETECTED_CXX_FLAGS_DEBUG} ${_gcc_debug_flags}"
+          CACHE STRING "" FORCE)
+    else()
+      set(CMAKE_CXX_FLAGS_DEBUG
+          "${CMAKE_CXX_FLAGS_DEBUG} ${_gcc_debug_flags}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+  set(CMAKE_VERBOSE_MAKEFILE
+      ON
+      CACHE BOOL "Enable generation of verbose build scripts." FORCE)
+elseif(CMAKE_BUILD_TYPE STREQUAL Release)
+  set(CMAKE_CXX_FLAGS_RELEASE
+      "${CMAKE_CXX_FLAGS_RELEASE} ${MYX_CMAKE_DETECTED_CXX_FLAGS}"
+      CACHE STRING "" FORCE)
+elseif(CMAKE_BUILD_TYPE STREQUAL None)
+  # Режим None используется для статического анализа кода
+  set(CMAKE_VERBOSE_MAKEFILE
+      ON
+      CACHE BOOL "Enable generation of verbose build scripts." FORCE)
+endif()
+
+unset(_gcc_debug_flags)
+unset(_gcc_profile_flags)
+
+cmake_policy(POP)

MyxCMake/modules/MyxCMakeCPack.cmake

@@ -0,0 +1,69 @@
+# Общие настройки для пакета: организация, автор, версия
+set(CPACK_PACKAGE_VENDOR ${MYX_CMAKE_ORGANIZATION_NAME_LOWER} CACHE STRING "")
+set(CPACK_PACKAGE_NAME ${MYX_CMAKE_PROJECT_NAME_LOWER} CACHE STRING "")
+set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION} CACHE STRING "")
+
+# Параметры для архива исходных текстов
+if(NOT CPACK_SOURCE_GENERATOR)
+  set(CPACK_SOURCE_GENERATOR "TGZ")
+endif()
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "${MYX_CMAKE_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
+
+# Типы генераторов для бинарных архивов
+if(NOT CPACK_GENERATOR)
+  set(CPACK_GENERATOR "TGZ" "DEB")
+endif()
+
+# Параметры для архива собранного проекта
+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 "${MYX_CMAKE_PROJECT_NAME_LOWER}_${CPACK_TARGET_ARCH}_${CPACK_PACKAGE_VERSION}")
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "${MYX_CMAKE_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
+
+# Список масок для исключения из архива исходных текстов
+set(CPACK_SOURCE_IGNORE_FILES
+    "${CPACK_SOURCE_IGNORE_FILES}"
+    "${CMAKE_BINARY_DIR}"
+    "^${CMAKE_SOURCE_DIR}/.?build.?/"
+    "^${CMAKE_SOURCE_DIR}/.?output.?/"
+    "^${CMAKE_SOURCE_DIR}/files/var"
+    "^${CMAKE_SOURCE_DIR}/files/log"
+    "CMakeLists.txt.user.*"
+    ".*.autosave"
+    ".*.status"
+    "~$"
+    "\\\\.swp$")
+
+option(MYX_CMAKE_COMPACT_SOURCE_PACKAGE "Make compact source package" ON)
+if(MYX_CMAKE_COMPACT_SOURCE_PACKAGE)
+  # Список масок для исключения из архива исходных текстов для более компактного архива
+  set(CPACK_SOURCE_IGNORE_FILES
+      "${CPACK_SOURCE_IGNORE_FILES}"
+      "\\\\.git"
+      "/\\\\.git/"
+      "/\\\\.gitlab-ci/"
+      "\\\\.clang-tidy$"
+      "\\\\.cmake-format$"
+      "\\\\.gitignore$"
+      "\\\\.gitattributes$"
+      "\\\\.gitmodules$"
+      "\\\\.gitlab-ci.yml$")
+endif()
+
+set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_CURRENT_LIST_DIR}/MyxCMakeCPackProject.cmake)
+
+option(MYX_CMAKE_CPACK_DEFAULT_SCHEME "Use packaging default scheme" ON)
+
+# Правила для сборки обычных архивов
+if(MYX_CMAKE_CPACK_DEFAULT_SCHEME)
+  set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+  set(CPACK_COMPONENTS_GROUPING IGNORE)
+endif()
+
+# Правила для сборки пакетов для Debian
+include(CMLibCPackDeb)
+
+# Подключение модуля, выполняющего сборку архивов и пакетов
+include(CPack)

MyxCMake/modules/MyxCMakeCPackDeb.cmake

@@ -0,0 +1,81 @@
+# По умолчанию пакет собирается для дистрибутива unstable
+if(NOT DEBIAN_PACKAGE_TYPE)
+  set(DEBIAN_PACKAGE_TYPE "unstable")
+endif()
+
+if(NOT CPACK_DEBIAN_PACKAGE_SECTION)
+  set(CPACK_DEBIAN_PACKAGE_SECTION "misc")
+endif()
+
+if(NOT CPACK_DEBIAN_PACKAGE_PRIORITY)
+  set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+endif()
+
+# По умолчанию пакет для Debian делится на компоненты
+if(NOT CPACK_DEB_COMPONENT_INSTALL)
+  set(CPACK_DEB_COMPONENT_INSTALL ON)
+endif()
+
+if(MYX_CMAKE_CPACK_DEFAULT_SCHEME)
+  # Если имя компонента по умолчанию не определено, то устанавливается MAIN
+  if(NOT CMAKE_INSTALL_DEFAULT_COMPONENT_NAME)
+    set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME main)
+  endif()
+
+  # В списке компонентов обязательно должны быть main, base-dev, libs-dev и doc
+  list(
+    APPEND
+    CPACK_COMPONENTS_ALL
+    main
+    base-dev
+    libs-dev
+    doc)
+  list(REMOVE_DUPLICATES CPACK_COMPONENTS_ALL)
+
+  # Правило формирования имени пакета и файла для компонента main
+  set(CPACK_DEBIAN_MAIN_PACKAGE_NAME "${MYX_CMAKE_PROJECT_NAME_LOWER}")
+  set(CPACK_DEBIAN_MAIN_FILE_NAME
+      ${MYX_CMAKE_PROJECT_NAME_LOWER}_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}.deb)
+
+  # Правило формирования имени пакета и файла для компонента base-dev
+  set(CPACK_DEBIAN_BASE-DEV_PACKAGE_NAME "lib${MYX_CMAKE_PROJECT_NAME_LOWER}-base-dev")
+  set(CPACK_DEBIAN_BASE-DEV_FILE_NAME
+      lib${MYX_CMAKE_PROJECT_NAME_LOWER}-base-dev_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}.deb)
+
+  # Правило формирования имени пакета и файла для компонента libs-dev
+  set(CPACK_DEBIAN_LIBS-DEV_PACKAGE_NAME lib${MYX_CMAKE_PROJECT_NAME_LOWER}-dev)
+  set(CPACK_DEBIAN_LIBS-DEV_FILE_NAME
+      lib${MYX_CMAKE_PROJECT_NAME_LOWER}-dev_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}.deb)
+
+  set(CPACK_DEBIAN_LIBS-DEV_PACKAGE_DEPENDS "lib${MYX_CMAKE_PROJECT_NAME_LOWER}-base-dev")
+
+  foreach(component ${CPACK_COMPONENTS_ALL})
+    string(TOLOWER ${component} _cl)
+    string(TOUPPER ${component} _cu)
+    # Правила формирования имени пакета и файла для остальных компонентов
+    if(NOT ${_cl} STREQUAL main AND NOT ${_cl} STREQUAL base-dev AND NOT ${_cl} STREQUAL libs-dev)
+      set(CPACK_DEBIAN_${_cu}_PACKAGE_NAME "${MYX_CMAKE_PROJECT_NAME_LOWER}-${_cl}")
+      set(CPACK_DEBIAN_${_cu}_FILE_NAME
+          "${MYX_CMAKE_PROJECT_NAME_LOWER}-${_cl}_${CPACK_PACKAGE_VERSION}_${CPACK_TARGET_ARCH}.deb")
+    endif()
+
+    # Если в каталоге ${CMAKE_SOURCE_DIR}/cmake/deb/${_cl} находятся сценарии сопровождающего
+    # postinst, preinst, postrm и prerm, то они будут добавлены к пакету.
+    if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/preinst")
+      list(APPEND CPACK_DEBIAN_${_cu}_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/preinst")
+    endif()
+    if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/postinst")
+      list(APPEND CPACK_DEBIAN_${_cu}_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/postinst")
+    endif()
+    if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/prerm")
+      list(APPEND CPACK_DEBIAN_${_cu}_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/prerm")
+    endif()
+    if(EXISTS "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/postrm")
+      list(APPEND CPACK_DEBIAN_${_cu}_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/deb/${_cl}/postrm")
+    endif()
+  endforeach()
+endif()
+
+if(UNIX AND NOT TARGET deb)
+  add_custom_target(deb WORKING_DIRECTORY ${CMAKE_BINARY_DIR} COMMAND cpack -G DEB)
+endif()

MyxCMake/modules/MyxCMakeCPackProject.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()

MyxCMake/modules/MyxCMakeCheckPaths.cmake

@@ -0,0 +1,22 @@
+# Запись результатов сборки проекта внутрь иерархии каталогов с исходными
+# текстами приводит к засорению файлами формируемыми на этапе сборки, которые
+# затрудняют разработку, поиск в оригинальных файлах и мешают ориентироваться в
+# проекте. При работе с несколькими типами сборки, например, отладка и выпуск,
+# появляется необходимость корректного полного удаления результатов предыдущего
+# варианта.
+
+get_filename_component(_source_realpath "${CMAKE_SOURCE_DIR}" REALPATH)
+get_filename_component(_binary_realpath "${CMAKE_BINARY_DIR}" REALPATH)
+get_filename_component(_install_realpath "${CMAKE_INSTALL_PREFIX}" REALPATH)
+
+if(_install_realpath STREQUAL _binary_realpath)
+  message(FATAL_ERROR "MyxCMake: Cannot install into build directory.")
+endif()
+
+if(_install_realpath STREQUAL _source_realpath)
+  message(FATAL_ERROR "MyxCMake: Cannot install into source directory.")
+endif()
+
+if(_source_realpath STREQUAL _binary_realpath)
+  message(FATAL_ERROR "MyxCMake: In-source builds are not allowed.")
+endif()

MyxCMake/modules/MyxCMakeCodeAnalyzeClangCheck.cmake

@@ -0,0 +1,34 @@
+set(CLANG_CHECK_NAMES clang-check)
+foreach(V RANGE 9 15)
+  list(INSERT CLANG_CHECK_NAMES 0 "clang-check-${V}")
+endforeach()
+
+find_program(CLANG_CHECK_EXE NAMES ${CLANG_CHECK_NAMES})
+if(CLANG_CHECK_EXE)
+  option(MYX_CMAKE_CLANG_CHECK_FIX "MyxCMake: perform fixes for Clang Check" OFF)
+endif()
+unset(V)
+unset(CLANG_CHECK_NAMES)
+
+function(myx_cmake_clang_check_analyze target)
+  set(_args --analyze --extra-arg="-Wno-unknown-warning-option")
+  get_target_property(__sources ${target} SOURCES)
+  list(FILTER __sources EXCLUDE REGEX "qrc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "moc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "ui_.*\\.h$")
+
+  if(CLANG_CHECK_EXE)
+    if(MYX_CMAKE_CLANG_ANALYZE_FIX)
+      list(APPEND _args "--fixit")
+    endif()
+    if(NOT TARGET myx-cmake-clang-check-analyze)
+      add_custom_target(myx-cmake-clang-check-analyze)
+    endif()
+    add_custom_target(${target}-clang-check-analyze WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+                      COMMAND ${CLANG_CHECK_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${__sources})
+    add_dependencies(${target}-clang-check-analyze ${target})
+    add_dependencies(myx-cmake-clang-check-analyze ${target}-clang-check-analyze)
+  else()
+    message(STATUS "MyxCMake: Clang Check analyzer is not found")
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeCodeAnalyzeClangTidy.cmake

@@ -0,0 +1,34 @@
+set(CLANG_TIDY_NAMES clang-tidy)
+foreach(V RANGE 9 15)
+  list(INSERT CLANG_TIDY_NAMES 0 "clang-tidy-${V}")
+endforeach()
+
+find_program(CLANG_TIDY_EXE NAMES ${CLANG_TIDY_NAMES})
+if(CLANG_TIDY_EXE)
+  option(MYX_CMAKE_CLANG_TIDY_FIX "MyxCMake: perform fixes for Clang Tidy" OFF)
+endif()
+unset(V)
+unset(CLANG_TIDY_NAMES)
+
+function(myx_cmake_clang_tidy_analyze target)
+  set(_args -extra-arg="-Wno-unknown-warning-option")
+  get_target_property(__sources ${target} SOURCES)
+  list(FILTER __sources EXCLUDE REGEX "qrc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "moc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "ui_.*\\.h$")
+
+  if(CLANG_TIDY_EXE)
+    if(MYX_CMAKE_CLANG_TIDY_FIX)
+      list(APPEND _args "--fix")
+    endif()
+    if(NOT TARGET myx-cmake-clang-tidy-analyze)
+      add_custom_target(myx-cmake-clang-tidy-analyze)
+    endif()
+    add_custom_target(${target}-clang-tidy-analyze WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+                      COMMAND ${CLANG_TIDY_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${__sources})
+    add_dependencies(${target}-clang-tidy-analyze ${target})
+    add_dependencies(myx-cmake-clang-tidy-analyze ${target}-clang-tidy-analyze)
+  else()
+    message(STATUS "MyxCMake: Clang Tidy analyzer is not found")
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeCodeAnalyzeClazy.cmake

@@ -0,0 +1,57 @@
+find_program(CLAZY_EXE NAMES clazy-standalone)
+
+set(CLANG_APPLY_REPLACEMENTS_NAMES clang-apply-replacements)
+foreach(V RANGE 9 15)
+  list(INSERT CLANG_APPLY_REPLACEMENTS 0 "clang-apply-replacements-${V}")
+endforeach()
+
+find_program(CLANG_APPLY_REPLACEMENTS_EXE NAMES ${CLANG_APPLY_REPLACEMENTS_NAMES})
+if(CLANG_TIDY_EXE)
+  option(MYX_CMAKE_CLANG_TIDY_FIX "MyxCMake: perform fixes for Clang Tidy" OFF)
+endif()
+unset(V)
+unset(CLANG_TIDY_NAMES)
+
+if(CLAZY_EXE AND CLANG_APPLY_REPLACEMENTS_EXE)
+  option(MYX_CMAKE_CLAZY_FIX "MyxCMake: perform fixes for Clazy" OFF)
+endif()
+
+function(myx_cmake_clazy_analyze target)
+  set(options)
+  set(oneValueArgs CHECKS)
+  set(multiValueArgs)
+
+  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"
+    )
+  endif()
+
+  get_target_property(__sources ${target} SOURCES)
+  list(FILTER __sources EXCLUDE REGEX "qrc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "moc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "ui_.*\\.h$")
+  set(_args -checks=${ARG_CHECKS} -extra-arg="-Wno-unknown-warning-option"
+            -export-fixes=clazy-fixes-file.yaml)
+
+  if(CLAZY_EXE)
+    if(NOT TARGET myx-cmake-clazy-analyze)
+      add_custom_target(myx-cmake-clazy-analyze)
+    endif()
+    if(MYX_CMAKE_CLAZY_FIX)
+      add_custom_target(
+        ${target}-clazy-analyze
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMAND ${CLAZY_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${__sources}
+        COMMAND ${CLANG_APPLY_REPLACEMENTS_EXE} ${CMAKE_BINARY_DIR})
+    else()
+      add_custom_target(${target}-clazy-analyze WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+                        COMMAND ${CLAZY_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${__sources})
+    endif()
+    add_dependencies(${target}-clazy-analyze ${target})
+    add_dependencies(myx-cmake-clazy-analyze ${target}-clazy-analyze)
+  else()
+    message(STATUS "MyxCMake: Clazy standalone analyzer is not found")
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeCodeAnalyzePvsStudio.cmake

@@ -0,0 +1,63 @@
+if(CMAKE_EXPORT_COMPILE_COMMANDS)
+  find_program(PVS_STUDIO_ANALYZER_EXE NAMES pvs-studio-analyzer)
+  include(PVS-Studio)
+else()
+  message(STATUS "MyxCMake: CMAKE_EXPORT_COMPILE_COMMANDS is not set. PVS checks will be disabled.")
+endif()
+
+function(myx_cmake_pvs_studio_analyze target)
+  if(PVS_STUDIO_ANALYZER_EXE)
+    if(NOT TARGET myx-cmake-pvs-studio-analyze)
+      add_custom_target(myx-cmake-pvs-studio-analyze)
+    endif()
+
+    set(PVS_STUDIO_CONFIG "${CMAKE_BINARY_DIR}/PVS-Studio-${target}.cfg")
+    set(PVS_STUDIO_CONFIG_COMMAND "${CMAKE_COMMAND}" -E echo "sourcetree-root=${CMAKE_SOURCE_DIR}" > "${PVS_STUDIO_CONFIG}")
+
+    add_custom_command(OUTPUT "${PVS_STUDIO_CONFIG}"
+                       COMMAND ${PVS_STUDIO_CONFIG_COMMAND}
+                       WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+                       COMMENT "Generating PVS-Studio.cfg")
+
+    set(PVS_STUDIO_HEADER "${CMAKE_BINARY_DIR}/include/pvs_studio_suppression_${target}.hpp")
+    file(WRITE ${PVS_STUDIO_HEADER}
+      "#ifndef PVS_STUDIO_HPP_\n"
+      "#define PVS_STUDIO_HPP_\n"
+      "#pragma once\n"
+      "//-V813_MINSIZE=33\n"
+      "#endif // PVS_STUDIO_HPP_\n"
+      )
+
+    get_target_property(__sources ${target} SOURCES)
+    list(FILTER __sources EXCLUDE REGEX "qrc_.*\\.cpp$")
+    list(FILTER __sources EXCLUDE REGEX "moc_.*\\.cpp$")
+    list(FILTER __sources EXCLUDE REGEX "ui_.*\\.h$")
+
+    pvs_studio_add_target(
+      TARGET ${target}-pvs-studio-analyze
+      CONFIG ${PVS_STUDIO_CONFIG}
+      DEPENDS ${PVS_STUDIO_CONFIG}
+      LOG "${CMAKE_BINARY_DIR}/PVS-Studio-${target}.log"
+      SOURCES ${__sources}
+      COMPILE_COMMANDS HIDE_HELP
+      OUTPUT FORMAT errorfile
+      ARGS --exclude-path ${CMAKE_CURRENT_BINARY_DIR}/${target}_autogen
+      MODE GA:1,2,3;64:1;OP:1,2;CS:1,2)
+
+    add_dependencies(myx-cmake-pvs-studio-analyze ${target}-pvs-studio-analyze)
+
+    get_target_property(__target_type ${target} TYPE)
+    if(${__target_type} STREQUAL INTERFACE_LIBRARY)
+      set(__target_type INTERFACE)
+    else()
+      set(__target_type PRIVATE)
+    endif()
+    if(MSVC)
+      target_compile_options(${target} BEFORE ${__target_type} /FI ${PVS_STUDIO_HEADER})
+    else() # GCC/Clang
+      target_compile_options(${target} BEFORE ${__target_type} -include ${PVS_STUDIO_HEADER})
+    endif()
+  else()
+    message(STATUS "MyxCMake: PVS-Studio analyzer is not found")
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeCodeCoverage.cmake

@@ -0,0 +1,34 @@
+option(MYX_CMAKE_CODE_COVERAGE "MyxCMake: enable code coverage" OFF)
+
+if(MYX_CMAKE_CODE_COVERAGE)
+  find_program(LCOV_EXE NAMES lcov)
+  find_program(GENHTML_EXE NAMES genhtml)
+endif()
+
+function(myx_cmake_code_coverage target)
+  if(CMAKE_CXX_COMPILER_IS_GCC AND MYX_CMAKE_CODE_COVERAGE)
+    target_compile_options(${target} PUBLIC "--coverage")
+    set_property(
+      TARGET ${target}
+      APPEND_STRING
+      PROPERTY LINK_FLAGS " --coverage")
+
+    if(LCOV_EXE)
+      add_custom_target(
+        ${target}-coverage
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMAND ${LCOV_EXE} --test-name ${target} --output "${target}.lcov"
+                --capture --directory ${CMAKE_BINARY_DIR})
+      add_dependencies(${target}-coverage ${target})
+
+      if(GENHTML_EXE)
+        add_custom_target(
+          ${target}-coverage-report
+          WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+          COMMAND ${GENHTML_EXE} --output-directory "${target}-coverage-html"
+                  "${target}.lcov")
+        add_dependencies(${target}-coverage-report ${target}-coverage)
+      endif()
+    endif()
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeCommon.cmake

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.3 FATAL_ERROR)
+
+include(GNUInstallDirs)
+include(MyxCMakeCheckPaths)
+
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS
+    ${CMAKE_CXX_SOURCE_FILE_EXTENSIONS};tpp;tcc)
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+include(MyxCMakeProjectVersion)
+include(MyxCMakeRequiredVariables)
+include(MyxCMakeGlobalFunctions)
+include(MyxCMakeGlobalVariables)
+include(MyxCMakeToday)
+include(MyxCMakeLSBInfo)
+include(MyxCMakeCompiler)
+include(MyxCMakeCompilerFlags)
+include(MyxCMakeDistCC)
+include(MyxCMakeUnityBuild)
+include(MyxCMakePrecompiledHeaders)
+include(MyxCMakeBuildTypes)
+include(MyxCMakeDebugOutputOptions)
+
+include(MyxCMakeCodeAnalyzeClangCheck)
+include(MyxCMakeCodeAnalyzeClangTidy)
+include(MyxCMakeCodeAnalyzeClazy)
+include(MyxCMakeCodeAnalyzePvsStudio)
+include(MyxCMakeCodeCoverage)
+include(MyxCMakeFormatSources)
+include(MyxCMakeCommonTargetProperties)
+include(MyxCMakeAddSharedLibrary)
+include(MyxCMakeAddStaticLibrary)
+include(MyxCMakePkgConfig)
+include(MyxCMakeNinjaGeneratorHelper)
+include(CMLibGit)
+
+
+
+# include(CMLibDocDoxygen) include(CMLibDocBreathe)
+# include(CMLibExternalProject)
+
+include(MyxCMakeCPack)
+include(MyxCMakeUninstall)

MyxCMake/modules/MyxCMakeCommonTargetProperties.cmake

@@ -0,0 +1,157 @@
+function(myx_cmake_common_target_properties target)
+  get_target_property(_target_type ${target} TYPE)
+
+  set(__visibility PUBLIC)
+  if(_target_type STREQUAL INTERFACE_LIBRARY)
+    set(__visibility INTERFACE)
+  else()
+    #
+    if(TARGET Qt5::Core)
+      if(_target_type STREQUAL EXECUTABLE)
+        target_compile_options(${target}
+                               PUBLIC ${Qt5Core_EXECUTABLE_COMPILE_FLAGS})
+      endif()
+      if(NOT MYX_CMAKE_DEBUG_OUTPUT)
+        target_compile_definitions(${target} PUBLIC QT_NO_DEBUG_OUTPUT)
+      endif()
+      if(NOT MYX_CMAKE_INFO_OUTPUT)
+        target_compile_definitions(${target} PUBLIC QT_NO_INFO_OUTPUT)
+      endif()
+      if(NOT MYX_CMAKE_WARNING_OUTPUT)
+        target_compile_definitions(${target} PUBLIC QT_NO_WARNING_OUTPUT)
+      endif()
+    endif()
+    if(CMAKE_CXX_COMPILER_IS_GCC AND NOT APPLE)
+      set_property(
+        TARGET ${target}
+        APPEND_STRING
+        PROPERTY LINK_FLAGS " -Wl,--no-as-needed")
+    endif()
+
+    # Исключение файлов qrc из списка объединяемых файлов
+    get_target_property(__sources ${target} SOURCES)
+    foreach(src IN LISTS __sources)
+      string(REGEX MATCH ".*/qrc_.*\\.cpp$" __qrc ${src})
+      if(__qrc)
+        set_property(SOURCE ${__qrc} PROPERTY COTIRE_EXCLUDED ON)
+        set_property(SOURCE ${__qrc} PROPERTY SKIP_UNITY_BUILD_INCLUSION ON)
+      endif()
+    endforeach()
+
+    target_include_directories(
+      ${target}
+      PUBLIC $<INSTALL_INTERFACE:include>
+             $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+             $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+             $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>)
+
+  endif()
+
+  target_compile_features(${target} ${__visibility} cxx_alias_templates
+                                    cxx_nullptr cxx_override)
+  if(_target_type STREQUAL EXECUTABLE)
+    set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+    set_target_properties(
+      ${target} PROPERTIES RUNTIME_OUTPUT_DIRECTORY
+                           ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})
+    if(CMAKE_CXX_COMPILE_OPTIONS_PIE)
+      target_compile_options(${target} PUBLIC ${CMAKE_CXX_COMPILE_OPTIONS_PIE})
+    endif()
+    if(CMAKE_CXX_COMPILER_IS_GCC AND MYX_CMAKE_CODE_COVERAGE)
+      myx_cmake_code_coverage(${target})
+    endif()
+  endif()
+
+  if(APPLE)
+    target_compile_definitions(${target} ${__visibility} Darwin)
+  endif()
+
+  if(_target_type STREQUAL OBJECT_LIBRARY)
+    # target_include_directories(${target} PUBLIC
+    # $<INSTALL_INTERFACE:include/${target}>)
+    set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+  endif()
+
+  # LTO only for executables (not libraries) in Release build 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(CXX_HAS_LTO_FLAG)
+      target_compile_options(${target} PUBLIC "-flto")
+      set_property(
+        TARGET ${target}
+        APPEND_STRING
+        PROPERTY LINK_FLAGS " -flto")
+      if(CXX_HAS_NO_FAT_LTO_FLAG)
+        target_compile_options(${target} PUBLIC "-fno-fat-lto-objects")
+        set_property(
+          TARGET ${target}
+          APPEND_STRING
+          PROPERTY LINK_FLAGS " -fno-fat-lto-objects")
+      endif()
+    endif()
+  endif()
+
+  # cmake-format: off
+  if(COMMAND cotire)
+  set_property(TARGET ${target}
+               PROPERTY COTIRE_ENABLE_PRECOMPILED_HEADER ${MYX_CMAKE_PRECOMPILED_HEADERS})
+  set_property(TARGET ${target}
+               PROPERTY COTIRE_ADD_UNITY_BUILD ${MYX_CMAKE_UNITY_BUILD})
+  endif()
+  # cmake-format: on
+
+  if(CMAKE_BUILD_TYPE STREQUAL Profile)
+    target_compile_definitions(${target} ${__visibility} PROFILE)
+  elseif(CMAKE_BUILD_TYPE STREQUAL Debug)
+    target_compile_definitions(${target} ${__visibility} DEBUG)
+  elseif(CMAKE_BUILD_TYPE STREQUAL Release)
+    target_compile_definitions(${target} ${__visibility} RELEASE)
+  elseif(CMAKE_BUILD_TYPE STREQUAL None)
+    target_compile_definitions(${target} ${__visibility} ANALYSIS)
+  endif()
+  target_compile_definitions(
+    ${target} ${__visibility}
+              "MYX_CMAKE_LSB_ID_${MYX_CMAKE_LSB_DISTRIBUTOR_ID}")
+  target_compile_definitions(
+    ${target} ${__visibility}
+              "MYX_CMAKE_LSB_CODENAME_${MYX_CMAKE_LSB_CODENAME}")
+
+  myx_cmake_clang_tidy_analyze(${target})
+  myx_cmake_clang_check_analyze(${target})
+  myx_cmake_clazy_analyze(${target})
+  myx_cmake_pvs_studio_analyze(${target})
+  myx_cmake_format_sources(${target})
+
+  # Создание в каталоге ${CMAKE_BINARY_DIR} стандартных каталогов bin,include,lib
+  if(NOT TARGET ${target}-default-directories)
+    add_custom_target(
+      ${target}-default-directories
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/bin
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/include
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/lib
+    )
+    add_dependencies(${target} ${target}-default-directories)
+  endif()
+
+  # Создание в каталоге ${CMAKE_BINARY_DIR} символических ссылок на каталоги в ${CMAKE_SOURCE_DIR}/files
+  if(NOT TARGET ${target}-symlinks AND UNIX)
+    add_custom_target(
+      ${target}-symlinks
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+      # Ссылка на каталог с журналами
+      COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SOURCE_DIR}/files/log
+              ${CMAKE_BINARY_DIR}/log
+      # Ссылка на каталог с обрабатываемыми данными
+      COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SOURCE_DIR}/files/var
+              ${CMAKE_BINARY_DIR}/var
+      # Ссылка на каталог с постоянными данными
+      COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SOURCE_DIR}/files/share
+              ${CMAKE_BINARY_DIR}/share
+      # Ссылка на каталог настроек
+      COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SOURCE_DIR}/files/etc
+              ${CMAKE_BINARY_DIR}/etc)
+    add_dependencies(${target} ${target}-symlinks)
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeCompiler.cmake

@@ -0,0 +1,64 @@
+# 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 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)
+elseif(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+  set(CMAKE_C_COMPILER_IS_MSVC ON)
+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 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)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  set(CMAKE_CXX_COMPILER_IS_MSVC ON)
+endif()
+
+# Предпочтительные пути к утилитам для компоновки
+if(CMAKE_CXX_COMPILER_IS_GCC)
+  # Astra Linux Smolensk 1.5
+  if(MYX_CMAKE_LSB_DISTRIBUTOR_ID STREQUAL "AstraLinuxSE"
+     AND MYX_CMAKE_LSB_CODENAME STREQUAL "smolensk"
+     AND MYX_CMAKE_LSB_RELEASE STREQUAL "1.5")
+    find_program(CMAKE_GCC_AR NAMES "/usr/bin/x86_64-linux-gnu-gcc-ar-4.7")
+    find_program(CMAKE_GCC_NM NAMES "/usr/bin/x86_64-linux-gnu-gcc-nm-4.7")
+    find_program(CMAKE_GCC_RANLIB
+                 NAMES "/usr/bin/x86_64-linux-gnu-gcc-ranlib-4.7")
+    # Elbrus E2K
+  elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "e2k")
+    find_program(CMAKE_GCC_AR
+                 NAMES "/usr/${CMAKE_SYSTEM_PROCESSOR}-linux/bin/ar")
+    find_program(CMAKE_GCC_NM
+                 NAMES "/usr/${CMAKE_SYSTEM_PROCESSOR}-linux/bin/nm")
+    find_program(CMAKE_GCC_RANLIB
+                 NAMES "/usr/${CMAKE_SYSTEM_PROCESSOR}-linux/bin/ranlib")
+  else()
+    find_program(CMAKE_GCC_AR NAMES "gcc-ar" "ar")
+    find_program(CMAKE_GCC_NM NAMES "gcc-nm" "nm")
+    find_program(CMAKE_GCC_RANLIB NAMES "gcc-ranlib" "ranlib")
+  endif()
+
+  if(CMAKE_GCC_AR)
+    set(CMAKE_AR
+        ${CMAKE_GCC_AR}
+        CACHE STRING "" FORCE)
+  endif()
+  if(CMAKE_GCC_NM)
+    set(CMAKE_NM
+        ${CMAKE_GCC_NM}
+        CACHE STRING "" FORCE)
+  endif()
+  if(CMAKE_GCC_RANLIB)
+    set(CMAKE_RANLIB
+        ${CMAKE_GCC_RANLIB}
+        CACHE STRING "" FORCE)
+  endif()
+endif()

MyxCMake/modules/MyxCMakeCompilerFlags.cmake

@@ -0,0 +1,240 @@
+# based on https://github.com/bluescarni/yacma
+
+include(CheckCXXCompilerFlag)
+
+macro(CHECK_ENABLE_CXX_FLAG flag)
+  set(CMAKE_REQUIRED_QUIET TRUE)
+  check_cxx_compiler_flag("${flag}" CHECK_CXX_FLAG)
+  unset(CMAKE_REQUIRED_QUIET)
+
+  if(CHECK_CXX_FLAG)
+    message(STATUS "'${flag}': flag is supported.")
+    string(CONCAT _MYX_CMAKE_DETECTED_CXX_FLAGS
+                  "${_MYX_CMAKE_DETECTED_CXX_FLAGS} ${flag}")
+  else()
+    message(STATUS "'${flag}': flag is NOT supported.")
+  endif()
+  # NOTE: check_cxx_compiler stores variables in the cache.
+  unset(CHECK_CXX_FLAG CACHE)
+endmacro()
+
+macro(CHECK_ENABLE_DEBUG_CXX_FLAG flag)
+  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(CMAKE_REQUIRED_QUIET TRUE)
+    check_cxx_compiler_flag("${flag}" CHECK_CXX_FLAG_DEBUG)
+    unset(CMAKE_REQUIRED_QUIET)
+
+    if(CHECK_CXX_FLAG_DEBUG)
+      message(STATUS "'${flag}': debug flag is supported.")
+      string(CONCAT _MYX_CMAKE_DETECTED_CXX_FLAGS_DEBUG
+                    "${_MYX_CMAKE_DETECTED_CXX_FLAGS_DEBUG} ${flag}")
+    else()
+      message(STATUS "'${flag}': debug flag is NOT supported.")
+    endif()
+    # NOTE: check_cxx_compiler stores variables in the cache.
+    unset(CHECK_CXX_FLAG_DEBUG CACHE)
+  endif()
+endmacro()
+
+function(myx_cmake_set_cxx_standard version)
+  # Выбор стандарта по умолчанию (можно переопределить в проекте)
+  set(CMAKE_CXX_STANDARD_REQUIRED
+      YES
+      PARENT_SCOPE)
+
+  if(version EQUAL 11)
+    set(CMAKE_CXX_STANDARD
+        11
+        PARENT_SCOPE)
+    set(CMAKE_CXX_EXTENSIONS
+        YES
+        PARENT_SCOPE)
+  endif()
+
+  if(version EQUAL 14)
+    set(CMAKE_CXX_STANDARD
+        14
+        PARENT_SCOPE)
+    set(CMAKE_CXX_EXTENSIONS
+        YES
+        PARENT_SCOPE)
+  endif()
+
+  if(version EQUAL 17)
+    if(${CMAKE_VERSION} VERSION_LESS "3.10.0")
+      check_cxx_compiler_flag(-std=gnu++17 HAVE_FLAG_STD_GNUXX17)
+      if(HAVE_FLAG_STD_GNUXX17)
+        add_compile_options("-std=gnu++17")
+      else()
+        check_cxx_compiler_flag(-std=gnu++1z HAVE_FLAG_STD_GNUXX1Z)
+        if(HAVE_FLAG_STD_GNUXX1Z)
+          add_compile_options("-std=gnu++1z")
+        else()
+          check_cxx_compiler_flag(-std=c++17 HAVE_FLAG_STD_CXX17)
+          if(HAVE_FLAG_STD_CXX17)
+            add_compile_options("-std=c++17")
+          else()
+            check_cxx_compiler_flag(-std=c++1z HAVE_FLAG_STD_CXX1Z)
+            if(HAVE_FLAG_STD_CXX1Z)
+              add_compile_options("-std=c++1z")
+            endif()
+          endif()
+        endif()
+      endif()
+    else()
+      set(CMAKE_CXX_STANDARD
+          17
+          PARENT_SCOPE)
+      set(CMAKE_CXX_EXTENSIONS
+          YES
+          PARENT_SCOPE)
+    endif()
+  endif()
+endfunction()
+
+if(NOT MYX_CMAKE_CXX_FLAGS_AUTODETECTION_DONE)
+  set(_MYX_CMAKE_DETECTED_CXX_FLAGS "")
+  set(_MYX_CMAKE_DETECTED_CXX_FLAGS_DEBUG "")
+
+  # Configuration bits specific for clang.
+  if(CMAKE_CXX_COMPILER_IS_CLANG)
+    if(CMAKE_COLOR_MAKEFILE)
+      check_enable_cxx_flag(-fcolor-diagnostics)
+    endif()
+    # For now it seems like -Wshadow from clang behaves better than GCC's, just
+    # enable it here for the time being.
+    check_enable_debug_cxx_flag(-Wshadow)
+    # New warnings in clang 8. NOTE: a few issues with macros here, let's
+    # disable for now. CHECK_ENABLE_DEBUG_CXX_FLAG(-Wextra-semi-stmt) New
+    # warnings in clang 10.
+    check_enable_debug_cxx_flag(-Wtautological-overlap-compare)
+    check_enable_debug_cxx_flag(-Wtautological-compare)
+    check_enable_debug_cxx_flag(-Wtautological-bitwise-compare)
+    check_enable_debug_cxx_flag(-Wbitwise-conditional-parentheses)
+    check_enable_debug_cxx_flag(-Wrange-loop-analysis)
+    check_enable_debug_cxx_flag(-Wmisleading-indentation)
+    check_enable_debug_cxx_flag(-Wc99-designator)
+    check_enable_debug_cxx_flag(-Wreorder-init-list)
+    check_enable_debug_cxx_flag(-Wsizeof-pointer-div)
+    check_enable_debug_cxx_flag(-Wsizeof-array-div)
+    check_enable_debug_cxx_flag(-Wxor-used-as-pow)
+    check_enable_debug_cxx_flag(-Wfinal-dtor-non-final-class)
+    # NOTE: this is a new flag in Clang 13 which seems to give
+    # incorrect warnings for UDLs.
+    check_enable_debug_cxx_flag(-Wno-reserved-identifier)
+  endif()
+
+  # 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)
+    check_enable_debug_cxx_flag(-Wall)
+    check_enable_debug_cxx_flag(-Wextra)
+    check_enable_debug_cxx_flag(-Wnon-virtual-dtor)
+    check_enable_debug_cxx_flag(-Wnoexcept)
+    check_enable_debug_cxx_flag(-Wlogical-op)
+    check_enable_debug_cxx_flag(-Wconversion)
+    check_enable_debug_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_debug_cxx_flag(-Wold-style-cast)
+    check_enable_debug_cxx_flag(-Wdisabled-optimization)
+    # This is useful when the compiler decides the template backtrace is too
+    # verbose.
+    check_enable_debug_cxx_flag(-ftemplate-backtrace-limit=0)
+    check_enable_debug_cxx_flag(-fstack-protector-all)
+    # A few suggestion flags.
+    check_enable_debug_cxx_flag(-Wsuggest-attribute=pure)
+    check_enable_debug_cxx_flag(-Wsuggest-attribute=const)
+    check_enable_debug_cxx_flag(-Wsuggest-attribute=noreturn)
+    check_enable_debug_cxx_flag(-Wsuggest-attribute=format)
+    # From GCC 5.
+    check_enable_debug_cxx_flag(-Wodr)
+    check_enable_debug_cxx_flag(-Wsuggest-final-types)
+    check_enable_debug_cxx_flag(-Wsuggest-final-methods)
+    check_enable_debug_cxx_flag(-Wsuggest-override)
+    # From GCC 6.
+    check_enable_debug_cxx_flag(-Wshift-negative-value)
+    check_enable_debug_cxx_flag(-Wshift-overflow=2)
+    check_enable_debug_cxx_flag(-Wduplicated-cond)
+    check_enable_debug_cxx_flag(-Wnull-dereference)
+    # From GCC 7.
+    check_enable_debug_cxx_flag(-Wrestrict)
+    check_enable_debug_cxx_flag(-Waligned-new)
+    check_enable_debug_cxx_flag(-fdiagnostics-parseable-fixits)
+    check_enable_debug_cxx_flag(-fdiagnostics-generate-patch)
+    # From GCC 8.
+    check_enable_debug_cxx_flag(-Wcast-align=strict)
+    # This is supposed to produce a nice graphical visualization of mismatching
+    # template errors.
+    check_enable_cxx_flag(-fdiagnostics-show-template-tree)
+    check_enable_debug_cxx_flag(-fdiagnostics-show-option)
+
+    check_enable_debug_cxx_flag(-pedantic)
+    check_enable_debug_cxx_flag(-Wcast-align)
+    check_enable_debug_cxx_flag(-Wcast-qual)
+    check_enable_debug_cxx_flag(-Wctor-dtor-privacy)
+    check_enable_debug_cxx_flag(-Wdisabled-optimization)
+    check_enable_debug_cxx_flag(-Wformat=2)
+    check_enable_debug_cxx_flag(-Winit-self)
+    check_enable_debug_cxx_flag(-Wmissing-include-dirs)
+    check_enable_debug_cxx_flag(-Woverloaded-virtual)
+    check_enable_debug_cxx_flag(-Wredundant-decls)
+    check_enable_debug_cxx_flag(-Wsign-promo)
+    check_enable_debug_cxx_flag(-Wstrict-overflow=5)
+    check_enable_debug_cxx_flag(-Wundef)
+    check_enable_debug_cxx_flag(-Wno-unused)
+    check_enable_debug_cxx_flag(-Wno-variadic-macros)
+    check_enable_debug_cxx_flag(-Wno-parentheses)
+    check_enable_debug_cxx_flag(-Wstrict-null-sentinel)
+    check_enable_debug_cxx_flag(-Wshadow-all)
+  endif()
+
+  if(CMAKE_CXX_COMPILER_IS_GCC)
+    if(CMAKE_COLOR_MAKEFILE)
+      check_enable_cxx_flag(-fdiagnostics-color=auto)
+    endif()
+    # The -Wmaybe-uninitialized flag is enabled by -Wall, but it is known to
+    # emit a lot of possibly spurious warnings. Let's just disable it.
+    check_enable_debug_cxx_flag(-Wno-maybe-uninitialized)
+    # New in GCC 9.
+    check_enable_debug_cxx_flag(-Waddress-of-packed-member)
+
+    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)
+    endif()
+  endif()
+
+  # cmake-format: off
+  if(MYX_CMAKE_LSB_DISTRIBUTOR_ID STREQUAL "AstraLinuxSE" AND
+     MYX_CMAKE_LSB_CODENAME       STREQUAL "smolensk" AND
+     MYX_CMAKE_LSB_RELEASE        STREQUAL "1.5")
+  # cmake-format: on
+    myx_cmake_set_cxx_standard(11)
+  elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "e2k")
+    myx_cmake_set_cxx_standard(14)
+    check_enable_debug_cxx_flag(-Wno-invalid-offsetof)
+    list(APPEND CMAKE_LIBRARY_PATH "/usr/lib/e2k-linux-gnu")
+  else()
+    myx_cmake_set_cxx_standard(17)
+    # -Wshadow gives a lot of false positives with GCC 4.7.2 in Astra Linux 1.5
+    if(CMAKE_CXX_COMPILER_IS_GCC)
+      check_enable_debug_cxx_flag(-Wshadow)
+    endif()
+  endif()
+
+  # Set the cache variables.
+  set(MYX_CMAKE_DETECTED_CXX_FLAGS
+      "${_MYX_CMAKE_DETECTED_CXX_FLAGS}"
+      CACHE INTERNAL "")
+  set(MYX_CMAKE_DETECTED_CXX_FLAGS_DEBUG
+      "${_MYX_CMAKE_DETECTED_CXX_FLAGS_DEBUG}"
+      CACHE INTERNAL "")
+  set(MYX_CMAKE_CXX_FLAGS_AUTODETECTION_DONE
+      YES
+      CACHE INTERNAL "")
+endif()

MyxCMake/modules/MyxCMakeDebugOutputOptions.cmake

@@ -0,0 +1,18 @@
+# По умолчанию отключена отладочная печать (если не включена явно программистом)
+option(MYX_CMAKE_DEBUG_OUTPUT "Enable debug output" OFF)
+option(MYX_CMAKE_INFO_OUTPUT "Enable info output" OFF)
+option(MYX_CMAKE_WARNING_OUTPUT "Enable warning output" OFF)
+
+# Если сборка производится в режиме для отладки, то включаются флаги для
+# разрешения отладочной печати
+if(CMAKE_BUILD_TYPE STREQUAL Debug)
+  set(MYX_CMAKE_DEBUG_OUTPUT
+      ON
+      CACHE BOOL "" FORCE)
+  set(MYX_CMAKE_INFO_OUTPUT
+      ON
+      CACHE BOOL "" FORCE)
+  set(MYX_CMAKE_WARNING_OUTPUT
+      ON
+      CACHE BOOL "" FORCE)
+endif()

MyxCMake/modules/MyxCMakeDistCC.cmake

@@ -0,0 +1,13 @@
+find_program(DISTCC_EXECUTABLE distcc)
+mark_as_advanced(DISTCC_EXECUTABLE)
+if(DISTCC_EXECUTABLE)
+  foreach(lang C CXX)
+    if(NOT DEFINED CMAKE_${lang}_COMPILER_LAUNCHER
+       AND NOT CMAKE_${lang}_COMPILER MATCHES ".*/distcc$")
+      message(STATUS "MyxCMake: distcc enabled for ${lang}")
+      set(CMAKE_${lang}_COMPILER_LAUNCHER
+          ${DISTCC_EXECUTABLE}
+          CACHE STRING "")
+    endif()
+  endforeach()
+endif()

MyxCMake/modules/MyxCMakeFormatSources.cmake

@@ -0,0 +1,52 @@
+function(myx_cmake_format_sources target)
+
+  get_target_property(__sources ${target} SOURCES)
+  list(FILTER __sources EXCLUDE REGEX "qrc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "moc_.*\\.cpp$")
+  list(FILTER __sources EXCLUDE REGEX "ui_.*\\.h$")
+
+  if(NOT TARGET myx-cmake-format-sources)
+    add_custom_target(myx-cmake-format-sources)
+  endif()
+  if(NOT TARGET myx-cmake-check-format-sources)
+    add_custom_target(myx-cmake-check-format-sources)
+  endif()
+  if(NOT TARGET myx-cmake-add-doxygen-comments)
+    add_custom_target(myx-cmake-add-doxygen-comments)
+  endif()
+
+  find_program(UNCRUSTIFY_EXE NAMES uncrustify)
+  if(UNCRUSTIFY_EXE)
+    if(EXISTS ${CMAKE_SOURCE_DIR}/files/etc/uncrustify.cfg)
+      list(APPEND UNCRUSTIFY_OPTS -c ${CMAKE_SOURCE_DIR}/files/etc/uncrustify.cfg)
+    endif()
+    # cmake-format: off
+    add_custom_target(${target}-check-format-sources-uncrustify
+      COMMAND ${UNCRUSTIFY_EXE} ${UNCRUSTIFY_OPTS} --check ${__sources})
+    list(APPEND UNCRUSTIFY_OPTS --replace --no-backup)
+    add_custom_target(${target}-format-sources-uncrustify
+      COMMAND ${UNCRUSTIFY_EXE} ${UNCRUSTIFY_OPTS} --mtime ${__sources})
+    add_custom_target(${target}-add-doxygen-comments-uncrustify
+      COMMAND ${UNCRUSTIFY_EXE} ${UNCRUSTIFY_OPTS}
+      --set cmt_insert_file_header=fileheader.txt
+      --set cmt_insert_file_footer=filefooter.txt
+      --set cmt_insert_func_header=funcheader.txt
+      --set cmt_insert_class_header=classheader.txt
+      --set cmt_insert_before_ctor_dtor=true ${__sources})
+    # cmake-format: on
+    add_dependencies(myx-cmake-check-format-sources ${target}-check-format-sources-uncrustify)
+    add_dependencies(myx-cmake-format-sources ${target}-format-sources-uncrustify)
+    add_dependencies(myx-cmake-add-doxygen-comments ${target}-add-doxygen-comments-uncrustify)
+  else()
+    message(STATUS "MyxCMake: uncrustify executable is not found")
+  endif()
+
+  find_program(DOS2UNIX_EXE NAMES dos2unix)
+  if(DOS2UNIX_EXE)
+    list(APPEND DOS2UNIX_OPTS -k -r)
+    add_custom_target(${target}-format-sources-dos2unix COMMAND ${DOS2UNIX_EXE} ${DOS2UNIX_OPTS} ${__sources})
+    add_dependencies(myx-cmake-format-sources ${target}-format-sources-dos2unix)
+  else()
+    message(STATUS "MyxCMake: dos2unix executable is not found")
+  endif()
+endfunction()

MyxCMake/modules/MyxCMakeGlobalFunctions.cmake

@@ -0,0 +1,19 @@
+# Формирование строки, состоящей из заглавных символов, цифр и подчёркиваний
+function(myx_cmake_canonical_string in_string out_string)
+  string(TOUPPER ${in_string} _arg_uppercase)
+  string(REGEX REPLACE "[ -]" "_" _arg_fixed ${_arg_uppercase})
+  set(${out_string}
+      ${_arg_fixed}
+      PARENT_SCOPE)
+endfunction()
+
+# Добавление общего префикса ко всем переменным в списке
+function(myx_cmake_list_transform_prepend var prefix)
+  set(temp "")
+  foreach(filename ${${var}})
+    list(APPEND temp "${prefix}${filename}")
+  endforeach()
+  set(${var}
+      "${temp}"
+      PARENT_SCOPE)
+endfunction()

MyxCMake/modules/MyxCMakeGlobalVariables.cmake

@@ -0,0 +1,29 @@
+if(NOT MYX_CMAKE_THEME_NAME)
+  set(MYX_CMAKE_THEME_NAME "default")
+endif()
+
+# cmake-format: off
+myx_cmake_canonical_string(${MYX_CMAKE_ORGANIZATION_NAME} MYX_CMAKE_ORGANIZATION_NAME_CANONICAL)
+myx_cmake_canonical_string(${PROJECT_NAME} MYX_CMAKE_PROJECT_NAME_CANONICAL)
+myx_cmake_canonical_string(${MYX_CMAKE_THEME_NAME} MYX_CMAKE_THEME_NAME_CANONICAL)
+
+string(TOLOWER ${MYX_CMAKE_ORGANIZATION_NAME_CANONICAL} MYX_CMAKE_ORGANIZATION_NAME_LOWER)
+string(TOLOWER ${MYX_CMAKE_PROJECT_NAME_CANONICAL} MYX_CMAKE_PROJECT_NAME_LOWER)
+string(TOLOWER ${MYX_CMAKE_THEME_NAME_CANONICAL} MYX_CMAKE_THEME_NAME_LOWER)
+
+string(TOUPPER ${MYX_CMAKE_ORGANIZATION_NAME_CANONICAL} MYX_CMAKE_ORGANIZATION_NAME_UPPER)
+string(TOUPPER ${MYX_CMAKE_PROJECT_NAME_CANONICAL} MYX_CMAKE_PROJECT_NAME_UPPER)
+string(TOUPPER ${MYX_CMAKE_THEME_NAME_CANONICAL} MYX_CMAKE_THEME_NAME_UPPER)
+# cmake-format: on
+
+option(MYX_CMAKE_ADD_THEME_PREFIX "Append theme name to install prefix" OFF)
+if(MYX_CMAKE_ADD_THEME_PREFIX AND NOT MYX_CMAKE_THEME_PREFIX_APPENDED)
+  if(NOT MYX_CMAKE_THEME_NAME_LOWER STREQUAL "default")
+    set(MYX_CMAKE_THEME_PREFIX_APPENDED
+        ON
+        CACHE BOOL "" FORCE)
+    set(CMAKE_INSTALL_PREFIX
+        "${CMAKE_INSTALL_PREFIX}/${MYX_CMAKE_THEME_NAME}"
+        CACHE PATH "" FORCE)
+  endif()
+endif()

MyxCMake/modules/MyxCMakeLSBInfo.cmake

@@ -0,0 +1,29 @@
+if(CMAKE_CROSSCOMPILING)
+  return()
+endif()
+
+if(MYX_CMAKE_LSB_RELEASE)
+  return()
+endif()
+
+set(MYX_CMAKE_LSB_DISTRIBUTOR_ID "unknown")
+set(MYX_CMAKE_LSB_CODENAME "unknown")
+set(MYX_CMAKE_LSB_RELEASE "unknown")
+
+if(EXISTS /etc/mcst_version)
+  set(MYX_CMAKE_LSB_DISTRIBUTOR_ID "ElbrusD")
+  set(MYX_CMAKE_LSB_CODENAME "Jessie")
+  execute_process(
+    COMMAND cat /etc/mcst_version
+    OUTPUT_VARIABLE MYX_CMAKE_LSB_RELEASE
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+else()
+  find_program(_lsb_release_executable lsb_release)
+  # cmake-format: off
+  if(_lsb_release_executable)
+    execute_process(COMMAND ${_lsb_release_executable} -si OUTPUT_VARIABLE MYX_CMAKE_LSB_DISTRIBUTOR_ID OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND ${_lsb_release_executable} -sc OUTPUT_VARIABLE MYX_CMAKE_LSB_CODENAME OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND ${_lsb_release_executable} -sr OUTPUT_VARIABLE MYX_CMAKE_LSB_RELEASE OUTPUT_STRIP_TRAILING_WHITESPACE)
+  # cmake-format: on
+  endif()
+endif()

MyxCMake/modules/MyxCMakeNinjaGeneratorHelper.cmake

@@ -0,0 +1,9 @@
+# Если выбран генератор Ninja, то в основном сборочном каталоге создаётся файл
+# Makefile, который обрабатывается командой make и передаёт исполнение системе
+# сборки ninja. Таким образом можно выполнять команду make, даже если правила
+# сборки проекта сгенерированы для ninja.
+
+if(CMAKE_GENERATOR MATCHES Ninja)
+  file(WRITE ${CMAKE_BINARY_DIR}/Makefile
+       ".PHONY: build\n" "%:\n" "\t@ninja \$@\n" "build:\n" "\t@ninja\n")
+endif()

MyxCMake/modules/MyxCMakePkgConfig.cmake

@@ -0,0 +1,47 @@
+function(myx_cmake_generate_pkgconfig target)
+  set(options)
+  set(oneVA COMPONENT)
+  set(multiVA)
+
+  cmake_parse_arguments(ARG "${options}" "${oneVA}" "${multiVA}" ${ARGN})
+
+  if(NOT ARG_COMPONENT)
+    set(ARG_COMPONENT "base-dev")
+  endif()
+
+  get_target_property(_target_type ${target} TYPE)
+
+  if(_target_type STREQUAL INTERFACE_LIBRARY)
+    file(
+      WRITE "${CMAKE_BINARY_DIR}/${target}.pc"
+      "prefix=${CMAKE_INSTALL_PREFIX}\n"
+      "exec_prefix=${CMAKE_INSTALL_PREFIX}\n"
+      "includedir=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}\n"
+      "\n"
+      "Name: ${target}\n"
+      "Description: ${target} header-only library\n"
+      "Version: ${PROJECT_VERSION}\n"
+      "\n"
+      "Requires:\n"
+      "Cflags: -I${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}\n")
+  else()
+    file(
+      WRITE "${CMAKE_BINARY_DIR}/${target}.pc"
+      "prefix=${CMAKE_INSTALL_PREFIX}\n"
+      "exec_prefix=${CMAKE_INSTALL_PREFIX}\n"
+      "libdir=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}\n"
+      "includedir=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}\n"
+      "\n"
+      "Name: ${target}\n"
+      "Description: ${target} library\n"
+      "Version: ${PROJECT_VERSION}\n"
+      "\n"
+      "Requires:\n"
+      "Libs: -L${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR} -l${target}\n"
+      "Cflags: -I${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}\n")
+  endif()
+  install(
+    FILES "${CMAKE_BINARY_DIR}/${target}.pc"
+    COMPONENT ${ARG_COMPONENT}
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endfunction()

MyxCMake/modules/MyxCMakePrecompiledHeaders.cmake

@@ -0,0 +1,10 @@
+if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
+  include(cotire OPTIONAL)
+  if(COMMAND cotire)
+    option(MYX_CMAKE_PRECOMPILED_HEADERS "MyxCMake: enable precompiled headers"
+           OFF)
+  endif()
+else()
+  option(MYX_CMAKE_PRECOMPILED_HEADERS "MyxCMake: enable precompiled headers"
+         OFF)
+endif()

MyxCMake/modules/MyxCMakeProjectVersion.cmake

@@ -0,0 +1,17 @@
+function(myx_cmake_check_project_version)
+  if(NOT ${PROJECT_VERSION_PATCH} MATCHES "([0-9]+)")
+    message(FATAL_ERROR "MyxCMake: Please set project version in X.Y.Z format")
+  endif()
+endfunction()
+
+function(myx_cmake_set_project_version_int)
+  myx_cmake_check_project_version()
+  math(
+    EXPR
+    _version_int
+    "(${PROJECT_VERSION_MAJOR} << 16) + (${PROJECT_VERSION_MINOR} << 8) + ${PROJECT_VERSION_PATCH}"
+  )
+  set_property(GLOBAL PROPERTY PROJECT_VERSION_INT ${_version_int})
+endfunction()
+
+myx_cmake_set_project_version_int()

MyxCMake/modules/MyxCMakeRequiredVariables.cmake

@@ -0,0 +1,34 @@
+#
+# Обязательные переменные, значения которым необходимо присвоить в файле
+# CMakeLists.txt до подключения MyxCMake, либо передать из командной строки
+# через ключ -D
+#
+if(NOT MYX_CMAKE_ORGANIZATION_NAME)
+  message(
+    FATAL_ERROR
+      "MyxCMake: Required variable MYX_CMAKE_ORGANIZATION_NAME is not defined")
+endif()
+
+if(NOT MYX_CMAKE_AUTHOR_NAME)
+  message(
+    FATAL_ERROR
+      "MyxCMake: Required variable MYX_CMAKE_AUTHOR_NAME is not defined")
+endif()
+
+if(NOT MYX_CMAKE_AUTHOR_EMAIL)
+  message(
+    FATAL_ERROR
+      "MyxCMake: Required variable MYX_CMAKE_AUTHOR_EMAIL is not defined")
+endif()
+set(CPACK_PACKAGE_CONTACT
+    "${MYX_CMAKE_AUTHOR_NAME} <${MYX_CMAKE_AUTHOR_EMAIL}>"
+    CACHE STRING "")
+
+if(NOT MYX_CMAKE_DESCRIPTION)
+  message(
+    FATAL_ERROR
+      "MyxCMake: Required variable MYX_CMAKE_DESCRIPTION is not defined")
+endif()
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY
+    ${MYX_CMAKE_DESCRIPTION}
+    CACHE STRING "")

MyxCMake/modules/MyxCMakeToday.cmake

@@ -0,0 +1,8 @@
+if(NOT TODAY)
+  if(WIN32)
+    execute_process(COMMAND "cmd" " /C date /T" OUTPUT_VARIABLE TODAY)
+  else()
+    execute_process(COMMAND "date" "+%d/%m/%Y" OUTPUT_VARIABLE TODAY)
+  endif()
+  string(REGEX REPLACE "(..)/(..)/(....).*" "\\3-\\2-\\1" TODAY ${TODAY})
+endif()

MyxCMake/modules/MyxCMakeUninstall.cmake

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

MyxCMake/modules/MyxCMakeUninstall.cmake.in

@@ -0,0 +1,31 @@
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    exec_program(
+      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    if(NOT "${rm_retval}" STREQUAL 0)
+      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+    endif(NOT "${rm_retval}" STREQUAL 0)
+  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+endforeach(file)
+
+# Удаление пустых каталогов
+foreach(_file ${files})
+  set(_res 0)
+  while(_res EQUAL 0)
+    get_filename_component(_file ${_file} DIRECTORY)
+    execute_process(COMMAND rmdir ${_file} RESULT_VARIABLE _res OUTPUT_QUIET ERROR_QUIET)
+  endwhile()
+endforeach()
+

MyxCMake/modules/MyxCMakeUnityBuild.cmake

@@ -0,0 +1,8 @@
+if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
+  include(cotire OPTIONAL)
+  if(COMMAND cotire)
+    option(MYX_CMAKE_UNITY_BUILD "Enable unity build" OFF)
+  endif()
+else()
+  option(MYX_CMAKE_UNITY_BUILD "Enable unity build" OFF)
+endif()

MyxCMake/sanitizers/.cmake-format.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+
+# ----------------------------------
+# Options affecting listfile parsing
+# ----------------------------------
+with section("parse"):
+
+  # Specify structure for custom cmake functions
+  additional_commands = {
+    'add_doxygen': { 'flags' : [],
+                            'kwargs': { 'LATEX': 1,
+                                        'HTML': 1,
+                                        'COMMENT': 1}},
+    'add_breathe': { 'flags' : [],
+                            'kwargs': { 'COMMENT': 1}},
+    'add_common_library': { 'flags' : [],
+                            'kwargs': { 'OUTPUT_NAME': 1,
+                                        'SOURCES': '*',
+                                        'TARGET': 1}},
+    'qt5_translation': { 'flags' : [],
+                         'kwargs': { 'OUTPUT_DIR': 1,
+                                     'LANGUAGES': '*',
+                                     'SOURCES': '*',
+                                     'BASE_NAME': 1}},
+    'pvs_studio_add_target': { 'flags' : [ 'COMPILE_COMMANDS',
+                                           'OUTPUT',
+                                           'HIDE_HELP'],
+                               'kwargs': { 'ARGS': '*',
+                                           'CONFIG': '*',
+                                           'DEPENDS': '*',
+                                           'FORMAT': '*',
+                                           'MODE': '*',
+                                           'TARGET': 1}},
+    'write_compiler_detection_header': { 'flags' : [],
+                                         'kwargs': { 'COMPILERS': '*',
+                                                     'FEATURES': '*',
+                                                     'FILE': '*',
+                                                     'PREFIX': '*'}}}
+
+  # Specify variable tags.
+  vartags = []
+
+  # Specify property tags.
+  proptags = []
+
+# -----------------------------
+# Options affecting formatting.
+# -----------------------------
+with section("format"):
+
+  # How wide to allow formatted cmake files
+  line_width = 100
+
+  # How many spaces to tab for indent
+  tab_size = 4
+
+  # If an argument group contains more than this many sub-groups (parg or kwarg
+  # groups) then force it to a vertical layout.
+  max_subgroups_hwrap = 3
+
+  # If a positional argument group contains more than this many arguments, then
+  # force it to a vertical layout.
+  max_pargs_hwrap = 5
+
+  # If a cmdline positional group consumes more than this many lines without
+  # nesting, then invalidate the layout (and nest)
+  max_rows_cmdline = 2
+
+  # If true, separate flow control names from their parentheses with a space
+  separate_ctrl_name_with_space = False
+
+  # If true, separate function names from parentheses with a space
+  separate_fn_name_with_space = False
+
+  # If a statement is wrapped to more than one line, than dangle the closing
+  # parenthesis on its own line.
+  dangle_parens = False
+
+  # If the trailing parenthesis must be 'dangled' on its on line, then align it
+  # to this reference: `prefix`: the start of the statement,  `prefix-indent`:
+  # the start of the statement, plus one indentation  level, `child`: align to
+  # the column of the arguments
+  dangle_align = 'prefix'
+
+  # If the statement spelling length (including space and parenthesis) is
+  # smaller than this amount, then force reject nested layouts.
+  min_prefix_chars = 4
+
+  # If the statement spelling length (including space and parenthesis) is larger
+  # than the tab width by more than this amount, then force reject un-nested
+  # layouts.
+  max_prefix_chars = 2
+
+  # If a candidate layout is wrapped horizontally but it exceeds this many
+  # lines, then reject the layout.
+  max_lines_hwrap = 2
+
+  # What style line endings to use in the output.
+  line_ending = 'unix'
+
+  # Format command names consistently as 'lower' or 'upper' case
+  command_case = 'canonical'
+
+  # Format keywords consistently as 'lower' or 'upper' case
+  keyword_case = 'upper'
+
+  # A list of command names which should always be wrapped
+  always_wrap = []
+
+  # If true, the argument lists which are known to be sortable will be sorted
+  # lexicographicall
+  enable_sort = True
+
+  # If true, the parsers may infer whether or not an argument list is sortable
+  # (without annotation).
+  autosort = False
+
+  # By default, if cmake-format cannot successfully fit everything into the
+  # desired linewidth it will apply the last, most agressive attempt that it
+  # made. If this flag is True, however, cmake-format will print error, exit
+  # with non-zero status code, and write-out nothing
+  require_valid_layout = False
+
+  # A dictionary mapping layout nodes to a list of wrap decisions. See the
+  # documentation for more information.
+  layout_passes = {}
+
+# ------------------------------------------------
+# Options affecting comment reflow and formatting.
+# ------------------------------------------------
+with section("markup"):
+
+  # What character to use for bulleted lists
+  bullet_char = '*'
+
+  # What character to use as punctuation after numerals in an enumerated list
+  enum_char = '.'
+
+  # If comment markup is enabled, don't reflow the first comment block in each
+  # listfile. Use this to preserve formatting of your copyright/license
+  # statements.
+  first_comment_is_literal = False
+
+  # If comment markup is enabled, don't reflow any comment block which matches
+  # this (regex) pattern. Default is `None` (disabled).
+  literal_comment_pattern = None
+
+  # Regular expression to match preformat fences in comments default=
+  # ``r'^\s*([`~]{3}[`~]*)(.*)$'``
+  fence_pattern = '^\\s*([`~]{3}[`~]*)(.*)$'
+
+  # Regular expression to match rulers in comments default=
+  # ``r'^\s*[^\w\s]{3}.*[^\w\s]{3}$'``
+  ruler_pattern = '^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$'
+
+  # If a comment line matches starts with this pattern then it is explicitly a
+  # trailing comment for the preceeding argument. Default is '#<'
+  explicit_trailing_pattern = '#<'
+
+  # If a comment line starts with at least this many consecutive hash
+  # characters, then don't lstrip() them off. This allows for lazy hash rulers
+  # where the first hash char is not separated by space
+  hashruler_min_length = 10
+
+  # If true, then insert a space between the first hash char and remaining hash
+  # chars in a hash ruler, and normalize its length to fill the column
+  canonicalize_hashrulers = True
+
+  # enable comment markup parsing and reflow
+  enable_markup = False
+
+# ----------------------------
+# Options affecting the linter
+# ----------------------------
+with section("lint"):
+
+  # a list of lint codes to disable
+  disabled_codes = ['C0113']
+
+  # regular expression pattern describing valid function names
+  function_pattern = '[0-9a-z_]+'
+
+  # regular expression pattern describing valid macro names
+  macro_pattern = '[0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with global
+  # scope
+  global_var_pattern = '[0-9A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with global
+  # scope (but internal semantic)
+  internal_var_pattern = '_[0-9A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with local
+  # scope
+  local_var_pattern = '[0-9a-z_]+'
+
+  # regular expression pattern describing valid names for privatedirectory
+  # variables
+  private_var_pattern = '_[0-9a-z_]+'
+
+  # regular expression pattern describing valid names for publicdirectory
+  # variables
+  public_var_pattern = '[0-9A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for keywords used in
+  # functions or macros
+  keyword_pattern = '[0-9A-Z_]+'
+
+  # In the heuristic for C0201, how many conditionals to match within a loop in
+  # before considering the loop a parser.
+  max_conditionals_custom_parser = 2
+
+  # Require at least this many newlines between statements
+  min_statement_spacing = 1
+
+  # Require no more than this many newlines between statements
+  max_statement_spacing = 2
+  max_returns = 6
+  max_branches = 12
+  max_arguments = 5
+  max_localvars = 15
+  max_statements = 50
+
+# -------------------------------
+# Options affecting file encoding
+# -------------------------------
+with section("encode"):
+
+  # If true, emit the unicode byte-order mark (BOM) at the start of the file
+  emit_byteorder_mark = False
+
+  # Specify the encoding of the input file. Defaults to utf-8
+  input_encoding = 'utf-8'
+
+  # Specify the encoding of the output file. Defaults to utf-8. Note that cmake
+  # only claims to support utf-8 so be careful when using anything else
+  output_encoding = 'utf-8'
+
+# -------------------------------------
+# Miscellaneous configurations options.
+# -------------------------------------
+with section("misc"):
+
+  # A dictionary containing any per-command configuration overrides. Currently
+  # only `command_case` is supported.
+  per_command = {}
+

MyxCMake/sanitizers/FindASan.cmake

@@ -0,0 +1,45 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault 2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+# associated documentation files (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge, publish, distribute,
+# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+# OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+option(SANITIZE_ADDRESS "Enable AddressSanitizer for sanitized targets." Off)
+
+set(FLAG_CANDIDATES
+    # Clang 3.2+ use this version. The no-omit-frame-pointer option is optional.
+    "-g -fsanitize=address -fno-omit-frame-pointer" "-g -fsanitize=address"
+    # Older deprecated flag for ASan
+    "-g -faddress-sanitizer")
+
+include(sanitize-helpers)
+
+sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "AddressSanitizer" "ASan")
+
+find_program(ASan_WRAPPER "asan-wrapper" PATHS ${CMAKE_MODULE_PATH})
+mark_as_advanced(ASan_WRAPPER)
+
+function(add_sanitize_address TARGET)
+    # TODO: check conditions for target:
+    # if (SANITIZE_ADDRESS AND (SANITIZE_THREAD OR SANITIZE_MEMORY))
+    #   message(FATAL_ERROR "AddressSanitizer is not compatible with ThreadSanitizer or MemorySanitizer.")
+    # endif ()
+
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "AddressSanitizer" "ASan")
+endfunction()

MyxCMake/sanitizers/FindCFI.cmake

@@ -0,0 +1,42 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault 2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+# associated documentation files (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge, publish, distribute,
+# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+# OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+option(SANITIZE_CFI "Enable Control Flow Integrity (CFI) for sanitized targets." OFF)
+
+set(FLAG_CANDIDATES
+    # FIXME: Brief comment on why the additional flags
+    # In this case you need a
+    # linker that does optimization at
+    # linking time such as LLVM lld or GNU gold.
+    "-g -fsanitize=cfi -fvisibility=hidden -flto -fuse-ld=lld")
+
+# There might be some conflict with the other sanitizer
+# hence it might need an if statement here.
+
+# add some handy functions
+include(sanitize-helpers)
+
+sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "ControlFlowIntegrity" "CFI")
+
+function(add_sanitize_cfi TARGET)
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "ControlFlowIntegrity" "CFI")
+endfunction()

MyxCMake/sanitizers/FindLeakSan.cmake

@@ -0,0 +1,37 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2019 Barcelona Supercomputing Center
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+option(SANITIZE_LEAK "Enable LeakSanitizer for sanitized targets." Off)
+
+set(FLAG_CANDIDATES "-g -fsanitize=leak")
+
+include(sanitize-helpers)
+
+sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "LeakSanitizer" "LeakSan")
+
+function(add_sanitize_leak TARGET)
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "LeakSanitizer" "LeakSan")
+endfunction()

MyxCMake/sanitizers/FindMSan.cmake

@@ -0,0 +1,49 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+option(SANITIZE_MEMORY "Enable MemorySanitizer for sanitized targets." Off)
+
+set(FLAG_CANDIDATES "-g -fsanitize=memory")
+
+include(sanitize-helpers)
+
+if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    message(NOTICE "MemorySanitizer disabled for target ${TARGET} because "
+            "MemorySanitizer is supported for Linux systems only.")
+elseif(NOT ${CMAKE_SIZEOF_VOID_P} EQUAL 8)
+    message(NOTICE "MemorySanitizer disabled for target ${TARGET} because "
+            "MemorySanitizer is supported for 64bit systems only.")
+else()
+    sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "MemorySanitizer" "MSan")
+endif()
+
+function(add_sanitize_memory TARGET)
+    # TODO: check conditions for target:
+    # if (SANITIZE_MEMORY AND (SANITIZE_THREAD OR SANITIZE_ADDRESS))
+    #   message(FATAL_ERROR "AddressSanitizer is not compatible with ThreadSanitizer or MemorySanitizer.")
+    # endif ()
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "MemorySanitizer" "MSan")
+endfunction()

MyxCMake/sanitizers/FindSS.cmake

@@ -0,0 +1,37 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault 2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+# associated documentation files (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge, publish, distribute,
+# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+# OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+option(SANITIZE_SS "Enable SafeStack for sanitized targets." OFF)
+
+set(FLAG_CANDIDATES "-g -fsanitize=safe-stack")
+
+# There might be some conflict with the other sanitizer
+# hence it might need an if statement here.
+
+# add some handy functions
+include(sanitize-helpers)
+
+sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "SafeStack" "SS")
+
+function(add_sanitize_ss TARGET)
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "SafeStack" "SS")
+endfunction()

MyxCMake/sanitizers/FindSanitizers.cmake

@@ -0,0 +1,109 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# If any of the used compiler is a GNU compiler, add a second option to static
+# link against the sanitizers.
+option(SANITIZE_LINK_STATIC "Try to link static against sanitizers." Off)
+
+set(FIND_QUIETLY_FLAG "")
+if(DEFINED Sanitizers_FIND_QUIETLY)
+    set(FIND_QUIETLY_FLAG "QUIET")
+endif()
+
+find_package(ASan ${FIND_QUIETLY_FLAG})
+find_package(TSan ${FIND_QUIETLY_FLAG})
+find_package(MSan ${FIND_QUIETLY_FLAG})
+find_package(UBSan ${FIND_QUIETLY_FLAG})
+find_package(LeakSan ${FIND_QUIETLY_FLAG})
+find_package(CFI ${FIND_QUIETLY_FLAG})
+find_package(SS ${FIND_QUIETLY_FLAG})
+
+function(sanitizer_add_blacklist_file FILE)
+    if(NOT IS_ABSOLUTE ${FILE})
+        set(FILE "${CMAKE_CURRENT_SOURCE_DIR}/${FILE}")
+    endif()
+    get_filename_component(FILE "${FILE}" REALPATH)
+
+    sanitizer_check_compiler_flags("-fsanitize-blacklist=${FILE}" "SanitizerBlacklist" "SanBlist")
+endfunction()
+
+function(add_sanitizers ...)
+    # If no sanitizer is enabled, return immediately.
+    if(NOT
+       (SANITIZE_ADDRESS
+        OR SANITIZE_MEMORY
+        OR SANITIZE_THREAD
+        OR SANITIZE_UNDEFINED
+        OR SANITIZE_LEAK
+        OR SANITIZE_CFI
+        OR SANITIZE_SS))
+        message(STATUS "No sanitizer selected.")
+        return()
+    endif()
+
+    if(SANITIZE_ADDRESS AND SANITIZE_THREAD)
+        message(
+            FATAL_ERROR
+                "Incompatible Sanitizer combination enabled: AddressSanitizer, ThreadSanitizer")
+    endif()
+    if(SANITIZE_ADDRESS AND SANITIZE_MEMORY)
+        message(
+            FATAL_ERROR
+                "Incompatible Sanitizer combination enabled: AddressSanitizer, MemorySanitizer")
+    endif()
+
+    if(SANITIZE_MEMORY AND SANITIZE_THREAD)
+        message(
+            FATAL_ERROR
+                "Incompatible Sanitizer combination enabled: MemorySanitizer, ThreadSanitizer")
+    endif()
+
+    foreach(TARGET ${ARGV})
+        sanitizer_check_target(${TARGET})
+
+        # Add sanitizers for target.
+        if(SANITIZE_ADDRESS)
+            add_sanitize_address(${TARGET})
+        endif()
+        if(SANITIZE_THREAD)
+            add_sanitize_thread(${TARGET})
+        endif()
+        if(SANITIZE_MEMORY)
+            add_sanitize_memory(${TARGET})
+        endif()
+        if(SANITIZE_UNDEFINED)
+            add_sanitize_undefined(${TARGET})
+        endif()
+        if(SANITIZE_LEAK)
+            add_sanitize_leak(${TARGET})
+        endif()
+        if(SANITIZE_CFI)
+            add_sanitize_cfi(${TARGET})
+        endif()
+        if(SANITIZE_SS)
+            add_sanitize_ss(${TARGET})
+        endif()
+    endforeach()
+endfunction(add_sanitizers)

MyxCMake/sanitizers/FindTSan.cmake

@@ -0,0 +1,53 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+option(SANITIZE_THREAD "Enable ThreadSanitizer for sanitized targets." Off)
+
+set(FLAG_CANDIDATES "-g -fsanitize=thread")
+
+include(sanitize-helpers)
+
+if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+    message(NOTICE "ThreadSanitizer disabled for target ${TARGET} because "
+            "ThreadSanitizer is supported for Linux systems and macOS only.")
+    set(SANITIZE_THREAD Off CACHE BOOL "Enable ThreadSanitizer for sanitized targets." FORCE)
+elseif(NOT ${CMAKE_SIZEOF_VOID_P} EQUAL 8)
+    message(NOTICE "ThreadSanitizer disabled for target ${TARGET} because "
+            "ThreadSanitizer is supported for 64bit systems only.")
+    set(SANITIZE_THREAD Off CACHE BOOL "Enable ThreadSanitizer for sanitized targets." FORCE)
+else()
+    sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "ThreadSanitizer" "TSan")
+endif()
+
+function(add_sanitize_thread TARGET)
+    # ThreadSanitizer is not compatible with MemorySanitizer.
+    #
+    # if(SANITIZE_THREAD AND SANITIZE_MEMORY)
+    #     message(FATAL_ERROR "ThreadSanitizer is not compatible with " "MemorySanitizer.")
+    # endif()
+
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "ThreadSanitizer" "TSan")
+endfunction()

MyxCMake/sanitizers/FindUBSan.cmake

@@ -0,0 +1,37 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+option(SANITIZE_UNDEFINED "Enable UndefinedBehaviorSanitizer for sanitized targets." Off)
+
+set(FLAG_CANDIDATES "-g -fsanitize=undefined")
+
+include(sanitize-helpers)
+
+sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "UndefinedBehaviorSanitizer" "UBSan")
+
+function(add_sanitize_undefined TARGET)
+    sanitizer_check_target(${TARGET})
+    sanitizer_add_flags(${TARGET} "UndefinedBehaviorSanitizer" "UBSan")
+endfunction()

MyxCMake/sanitizers/asan-wrapper

@@ -0,0 +1,55 @@
+#!/bin/sh
+
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# This script is a wrapper for AddressSanitizer. In some special cases you need
+# to preload AddressSanitizer to avoid error messages - e.g. if you're
+# preloading another library to your application. At the moment this script will
+# only do something, if we're running on a Linux platform. OSX might not be
+# affected.
+
+
+# Exit immediately, if platform is not Linux.
+if [ "$(uname)" != "Linux" ]
+then
+    exec $@
+fi
+
+
+# Get the used libasan of the application ($1). If a libasan was found, it will
+# be prepended to LD_PRELOAD.
+libasan=$(ldd $1 | grep libasan | sed "s/^[[:space:]]//" | cut -d' ' -f1)
+if [ -n "$libasan" ]
+then
+    if [ -n "$LD_PRELOAD" ]
+    then
+        export LD_PRELOAD="$libasan:$LD_PRELOAD"
+    else
+        export LD_PRELOAD="$libasan"
+    fi
+fi
+
+# Execute the application.
+exec $@

MyxCMake/sanitizers/sanitize-helpers.cmake

@@ -0,0 +1,199 @@
+# The MIT License (MIT)
+#
+# Copyright (c)
+#   2013 Matthew Arsenault
+#   2015-2016 RWTH Aachen University, Federal Republic of Germany
+#   2021 Markus Eggenbauer
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Helper function to get the language of a source file.
+function(sanitizer_lang_of_source FILE RETURN_VAR)
+    get_filename_component(LONGEST_EXT "${FILE}" EXT)
+    # If extension is empty return. This can happen for extensionless headers
+    if("${LONGEST_EXT}" STREQUAL "")
+        set(${RETURN_VAR} "" PARENT_SCOPE)
+        return()
+    endif()
+    # Get shortest extension as some files can have dot in their names
+    string(REGEX REPLACE "^.*(\\.[^.]+)$" "\\1" FILE_EXT ${LONGEST_EXT})
+    string(TOLOWER "${FILE_EXT}" FILE_EXT)
+    string(SUBSTRING "${FILE_EXT}" 1 -1 FILE_EXT)
+
+    get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
+    foreach(LANG ${ENABLED_LANGUAGES})
+        list(FIND CMAKE_${LANG}_SOURCE_FILE_EXTENSIONS "${FILE_EXT}" TEMP)
+        if(NOT ${TEMP} EQUAL -1)
+            set(${RETURN_VAR} "${LANG}" PARENT_SCOPE)
+            return()
+        endif()
+    endforeach()
+
+    set(${RETURN_VAR} "" PARENT_SCOPE)
+endfunction()
+
+# Helper function to get compilers used by a target.
+function(sanitizer_target_compilers TARGET RETURN_VAR)
+    # Check if all sources for target use the same compiler. If a target uses
+    # e.g. C and Fortran mixed and uses different compilers (e.g. clang and
+    # gfortran) this can trigger huge problems, because different compilers may
+    # use different implementations for sanitizers.
+    set(BUFFER "")
+    get_target_property(TSOURCES ${TARGET} SOURCES)
+    foreach(FILE ${TSOURCES})
+        # If expression was found, FILE is a generator-expression for an object
+        # library. Object libraries will be ignored.
+        string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _file ${FILE})
+        if("${_file}" STREQUAL "")
+            sanitizer_lang_of_source(${FILE} LANG)
+            if(LANG)
+                list(APPEND BUFFER ${CMAKE_${LANG}_COMPILER_ID})
+            endif()
+        endif()
+    endforeach()
+
+    list(REMOVE_DUPLICATES BUFFER)
+    set(${RETURN_VAR} "${BUFFER}" PARENT_SCOPE)
+endfunction()
+
+# Helper function to check compiler flags for language compiler.
+function(sanitizer_check_compiler_flag FLAG LANG VARIABLE)
+    if(${LANG} STREQUAL "C")
+        include(CheckCCompilerFlag)
+        check_c_compiler_flag("${FLAG}" ${VARIABLE})
+
+    elseif(${LANG} STREQUAL "CXX")
+        include(CheckCXXCompilerFlag)
+        check_cxx_compiler_flag("${FLAG}" ${VARIABLE})
+
+    elseif(${LANG} STREQUAL "Fortran")
+        # CheckFortranCompilerFlag was introduced in CMake 3.x. To be compatible
+        # with older Cmake versions, we will check if this module is present
+        # before we use it. Otherwise we will define Fortran coverage support as
+        # not available.
+        include(CheckFortranCompilerFlag OPTIONAL RESULT_VARIABLE INCLUDED)
+        if(INCLUDED)
+            CHECK_Fortran_COMPILER_FLAG("${FLAG}" ${VARIABLE})
+        elseif(NOT CMAKE_REQUIRED_QUIET)
+            message(STATUS "Performing Test ${VARIABLE}")
+            message(STATUS "Performing Test ${VARIABLE}" " - Failed (Check not supported)")
+        endif()
+    endif()
+endfunction()
+
+# Helper function to test compiler flags.
+function(sanitizer_check_compiler_flags FLAG_CANDIDATES NAME PREFIX)
+    set(CMAKE_REQUIRED_QUIET ${${PREFIX}_FIND_QUIETLY})
+
+    get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
+    foreach(LANG ${ENABLED_LANGUAGES})
+        # Sanitizer flags are not dependend on language, but the used compiler.
+        # So instead of searching flags foreach language, search flags foreach
+        # compiler used.
+        set(COMPILER ${CMAKE_${LANG}_COMPILER_ID})
+        if(NOT DEFINED ${PREFIX}_${COMPILER}_FLAGS)
+            foreach(FLAG ${FLAG_CANDIDATES})
+                if(NOT CMAKE_REQUIRED_QUIET)
+                    message(STATUS "Try ${COMPILER} ${NAME} flag = [${FLAG}]")
+                endif()
+
+                set(CMAKE_REQUIRED_FLAGS "${FLAG}")
+                unset(${PREFIX}_FLAG_DETECTED CACHE)
+                sanitizer_check_compiler_flag("${FLAG}" ${LANG} ${PREFIX}_FLAG_DETECTED)
+
+                if(${PREFIX}_FLAG_DETECTED)
+                    # If compiler is a GNU compiler, search for static flag, if
+                    # SANITIZE_LINK_STATIC is enabled.
+                    if(SANITIZE_LINK_STATIC AND (COMPILER STREQUAL "GNU"))
+                        string(TOLOWER ${PREFIX} PREFIX_lower)
+                        sanitizer_check_compiler_flag("-static-lib${PREFIX_lower}" ${LANG}
+                                                      ${PREFIX}_STATIC_FLAG_DETECTED)
+
+                        if(${PREFIX}_STATIC_FLAG_DETECTED)
+                            set(FLAG "-static-lib${PREFIX_lower} ${FLAG}")
+                        endif()
+                    endif()
+
+                    set(${PREFIX}_${COMPILER}_FLAGS "${FLAG}"
+                        CACHE STRING "${NAME} flags for ${COMPILER} compiler.")
+                    mark_as_advanced(${PREFIX}_${COMPILER}_FLAGS)
+                    break()
+                endif()
+            endforeach()
+
+            if(NOT ${PREFIX}_FLAG_DETECTED)
+                set(${PREFIX}_${COMPILER}_FLAGS "" CACHE STRING
+                                                         "${NAME} flags for ${COMPILER} compiler.")
+                mark_as_advanced(${PREFIX}_${COMPILER}_FLAGS)
+
+                message(
+                    NOTICE "${NAME} is not available for ${COMPILER} "
+                    "compiler. Targets using this compiler will be " "compiled without ${NAME}.")
+            endif()
+        endif()
+    endforeach()
+endfunction()
+
+# Helper to assign sanitizer flags for TARGET.
+function(sanitizer_add_flags TARGET NAME PREFIX)
+    # Get list of compilers used by target and check, if sanitizer is available
+    # for this target. Other compiler checks like check for conflicting
+    # compilers will be done in add_sanitizers function.
+    sanitizer_target_compilers(${TARGET} TARGET_COMPILER)
+    list(LENGTH TARGET_COMPILER NUM_COMPILERS)
+    if("${${PREFIX}_${TARGET_COMPILER}_FLAGS}" STREQUAL "")
+        return()
+    endif()
+
+    # Set compile- and link-flags for target.
+    set_property(TARGET ${TARGET} APPEND_STRING PROPERTY COMPILE_FLAGS
+                                                         " ${${PREFIX}_${TARGET_COMPILER}_FLAGS}")
+    set_property(TARGET ${TARGET} APPEND_STRING PROPERTY COMPILE_FLAGS
+                                                         " ${SanBlist_${TARGET_COMPILER}_FLAGS}")
+    set_property(TARGET ${TARGET} APPEND_STRING PROPERTY LINK_FLAGS
+                                                         " ${${PREFIX}_${TARGET_COMPILER}_FLAGS}")
+endfunction()
+
+macro(sanitizer_check_target TARGET)
+    # Check if this target will be compiled by exactly one compiler. Other-
+    # wise sanitizers can't be used and a warning should be printed once.
+    get_target_property(TARGET_TYPE ${TARGET} TYPE)
+    if(TARGET_TYPE STREQUAL "INTERFACE_LIBRARY")
+        message(NOTICE "Can't use any sanitizers for target ${TARGET}, "
+                "because it is an interface library and cannot be " "compiled directly.")
+        return()
+    endif()
+    sanitizer_target_compilers(${TARGET} TARGET_COMPILER)
+    list(LENGTH TARGET_COMPILER NUM_COMPILERS)
+    if(NUM_COMPILERS GREATER 1)
+        message(
+            NOTICE "Can't use any sanitizers for target ${TARGET}, "
+            "because it will be compiled by incompatible compilers. "
+            "Target will be compiled without sanitizers.")
+        return()
+
+        # If the target is compiled by no or no known compiler, give a warning.
+    elseif(NUM_COMPILERS EQUAL 0)
+        message(
+            NOTICE "Sanitizers for target ${TARGET} may not be"
+            " usable, because it uses no or an unknown compiler. "
+            "This is a false warning for targets using only " "object lib(s) as input.")
+        return()
+    endif()
+endmacro(sanitizer_check_target)

MyxCMake/thirdparty/PVS-Studio.cmake

@@ -0,0 +1,564 @@
+# 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}
+                    RESULT_VARIABLE result
+                    OUTPUT_VARIABLE output
+                    ERROR_VARIABLE error)
+
+    if (result AND NOT output MATCHES "^No compilation units were found\\.")
+        message(FATAL_ERROR "PVS-Studio exited with non-zero code.\nStdout:\n${output}\nStderr:\n${error}\n")
+    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}}")
+    
+    if (NOT MSVC)
+        list(APPEND CXX_FLAGS "$<$<BOOL:${CMAKE_SYSROOT}>:--sysroot=${CMAKE_SYSROOT}>")
+        list(APPEND C_FLAGS "$<$<BOOL:${CMAKE_SYSROOT}>:--sysroot=${CMAKE_SYSROOT}>")
+    endif ()
+
+    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(prop_compopt "$<TARGET_PROPERTY:${TARGET},COMPILE_OPTIONS>")
+    list(APPEND CXX_FLAGS "$<$<BOOL:${prop_compopt}>:$<JOIN:${prop_compopt},$<SEMICOLON>>>")
+    list(APPEND C_FLAGS "$<$<BOOL:${prop_compopt}>:$<JOIN:${prop_compopt},$<SEMICOLON>>>")
+
+    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_SUPPRESS_BASE}" "${PVS_STUDIO_DEPENDS}"
+                           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
+# SUPPRESS_BASE                 path to suppress base file
+# 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
+# CONVERTER_ARGS args...        additional plog-converter/HtmlGenerator.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 KEEP_INTERMEDIATE_FILES)
+    set(SINGLE LICENSE CONFIG TARGET LOG FORMAT BIN CONVERTER PLATFORM PREPROCESSOR CFG_TEXT SUPPRESS_BASE)
+    set(MULTI SOURCES C_FLAGS CXX_FLAGS ARGS DEPENDS ANALYZE MODE CONVERTER_ARGS)
+    cmake_parse_arguments(PVS_STUDIO "${OPTIONAL}" "${SINGLE}" "${MULTI}" ${ARGN})
+
+
+    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_CONFIG}" STREQUAL "" AND NOT "${PVS_STUDIO_CFG_TEXT}" STREQUAL "")
+        set(PVS_STUDIO_CONFIG "${CMAKE_BINARY_DIR}/PVS-Studio.cfg")
+        
+        set(PVS_STUDIO_CONFIG_COMMAND "${CMAKE_COMMAND}" -E echo "${PVS_STUDIO_CFG_TEXT}" > "${PVS_STUDIO_CONFIG}")
+
+        add_custom_command(OUTPUT "${PVS_STUDIO_CONFIG}"
+                           COMMAND ${PVS_STUDIO_CONFIG_COMMAND}
+                           WORKING_DIRECTORY "${BINARY_DIR}"
+                           COMMENT "Generating PVS-Studio.cfg")
+
+        list(APPEND PVS_STUDIO_DEPENDS "${PVS_STUDIO_CONFIG}")
+    endif ()
+    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 "")
+        list(APPEND PVS_STUDIO_ARGS --lic-file "${PVS_STUDIO_LICENSE}")
+    endif ()
+
+    if (NOT ${PVS_STUDIO_CONFIG} STREQUAL "")
+        list(APPEND PVS_STUDIO_ARGS --cfg "${PVS_STUDIO_CONFIG}")
+    endif ()
+
+    list(APPEND PVS_STUDIO_ARGS --platform "${PVS_STUDIO_PLATFORM}"
+                                --preprocessor "${PVS_STUDIO_PREPROCESSOR}")
+
+    if (NOT "${PVS_STUDIO_SUPPRESS_BASE}" STREQUAL "")
+        pvs_studio_join_path(PVS_STUDIO_SUPPRESS_BASE "${CMAKE_CURRENT_SOURCE_DIR}" "${PVS_STUDIO_SUPPRESS_BASE}")
+        list(APPEND PVS_STUDIO_ARGS --suppress-file "${PVS_STUDIO_SUPPRESS_BASE}")
+    endif ()
+
+    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 ()
+    
+    if (PVS_STUDIO_KEEP_INTERMEDIATE_FILES)
+        list(APPEND PVS_STUDIO_ARGS --dump-files)
+    endif()
+
+    string(REGEX REPLACE [123,:] "" ANALYZER_MODE ${PVS_STUDIO_MODE})
+    if (NOT "$ANALYZER_MODE" STREQUAL "GA")
+        list (APPEND PVS_STUDIO_ARGS -a "${ANALYZER_MODE}")
+    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_SUPPRESS_BASE}" "${PVS_STUDIO_DEPENDS}"
+        )
+        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 || cd .)
+        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")
+            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}" "${PVS_STUDIO_CONVERTER_ARGS}" -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 ()

build_deb.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -e
+
+V=$(grep -i "project.*VERSION" CMakeLists.txt | sed 's/.* \([0-9.]*\).*)/\1/')
+D=$(mktemp -d "/tmp/myx-cmake.XXXXXX")
+mkdir -p "$D/myx-cmake-$V"
+cp -ap CMakeLists.txt MyxCMake "$D/myx-cmake-$V"
+pushd "$D"
+tar Jcf "myx-cmake_${V}.orig.tar.xz" "myx-cmake-$V"
+popd
+cp -ap debian "$D/myx-cmake-$V"
+pushd "$D/myx-cmake-$V"
+dch -D unstable -v "${V}-1" -m "New version."
+debuild
+popd
+

debian/changelog

@@ -0,0 +1,6 @@
+myx-cmake (0.1.0-1) unstable; urgency=medium
+
+  * New version.
+
+ -- Andrey Astafyev <dpkg@246060.ru>  Wed, 08 Dec 2021 14:23:03 +0300
+