Форматирование кода

This reverts commit 48fff012d0.

CMLibBuildTypes.cmake

@@ -24,8 +24,10 @@ endif()
 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} -ggdb -pg -fno-omit-frame-pointer" CACHE STRING "" FORCE)
+    set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -ggdb -pg -fno-omit-frame-pointer" CACHE STRING ""
-    set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE} -ggdb -pg -fno-omit-frame-pointer" CACHE STRING "" FORCE)
+                                                                                                 FORCE)
+    set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE} -ggdb -pg -fno-omit-frame-pointer" CACHE STRING
+                                                                                                     "" FORCE)
     set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "" FORCE)
     set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "" FORCE)
     set(CMAKE_STATIC_LINKER_FLAGS_PROFILE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} -pg" CACHE STRING "" FORCE)

CMLibCPack.cmake

@@ -4,9 +4,16 @@ set(CPACK_PACKAGE_NAME ${CMLIB_PROJECT_NAME_LOWER})
 set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
 
 # Параметры для архива исходных текстов
-set(CPACK_SOURCE_GENERATOR TXZ)
+if(NOT CPACK_SOURCE_GENERATOR)
+  set(CPACK_SOURCE_GENERATOR "TXZ")
+endif()
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
 
+# Типы генераторов для бинарных архивов
+if(NOT CPACK_GENERATOR)
+  set(CPACK_GENERATOR "TXZ" "DEB")
+endif()
+
 # Параметры для архива собранного проекта
 set(CPACK_TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
 if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
@@ -15,6 +22,34 @@ endif()
 set(CPACK_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}_${CPACK_TARGET_ARCH}_${CPACK_PACKAGE_VERSION}")
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMLIB_PROJECT_NAME_LOWER}-${CPACK_PACKAGE_VERSION}")
 
+# Список масок для исключения из архива исходных текстов
+set(CPACK_SOURCE_IGNORE_FILES
+    "${CPACK_SOURCE_IGNORE_FILES}"
+    "${CMAKE_BINARY_DIR}"
+    "^${CMAKE_SOURCE_DIR}/.?build.?/"
+    "^${CMAKE_SOURCE_DIR}/.?output.?/"
+    "^${CMAKE_SOURCE_DIR}/files/lib"
+    "^${CMAKE_SOURCE_DIR}/files/log"
+    "CMakeLists.txt.user.*"
+    ".*.autosave"
+    "~$"
+    "\\\\.swp$")
+
+option(CMLIB_COMPACT_SOURCE_PACKAGE "Make compact source package" ON)
+if(CMLIB_COMPACT_SOURCE_PACKAGE)
+  # Список масок для исключения из архива исходных текстов для более компактного архива
+  set(CPACK_SOURCE_IGNORE_FILES
+      "${CPACK_SOURCE_IGNORE_FILES}"
+      "/\\\\.git/"
+      "/\\\\.gitlab-ci/"
+      "\\\\.clang-tidy$"
+      "\\\\.cmake-format$"
+      "\\\\.gitignore$"
+      "\\\\.gitattributes$"
+      "\\\\.gitmodules$"
+      "\\\\.gitlab-ci.yml$")
+endif()
+
 set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_CURRENT_LIST_DIR}/CMLibCPackProject.cmake)
 
 # Правила для сборки пакетов для Debian

CMLibCPackDeb.cmake

@@ -3,6 +3,14 @@ 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)

CMLibCodeAnalysisClangAnalyze.cmake

@@ -1,30 +1,21 @@
-find_program(
+find_program(CLANG_CHECK_EXE NAMES clang-check-10 clang-check-9 clang-check)
-  CLANG_CHECK_EXE
-  NAMES
-    clang-check-10
-    clang-check-9
-    clang-check-8
-    clang-check-7
-    clang-check-6.0
-    clang-check)
 if(CLANG_CHECK_EXE)
-  option(CLANG_ANALYZE_FIX "Perform fixes for Clang-Check" OFF)
+  option(CMLIB_CLANG_ANALYZE_FIX "Perform fixes for Clang-Check" OFF)
 endif()
 
 function(add_clang_analyze_check target)
   set(_sources ${ARGN})
+  set(_args -analyze -extra-arg="-Wno-unknown-warning-option")
 
   if(CLANG_CHECK_EXE)
-    if(CLANG_CHECK_FIX)
+    if(CMLIB_CLANG_ANALYZE_FIX)
-      list(APPEND _args "-fix")
+      list(APPEND _args "--fixit")
     endif()
     if(NOT TARGET clang-analyze-check)
       add_custom_target(clang-analyze-check)
     endif()
-    add_custom_target(
+    add_custom_target(clang-analyze-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      clang-analyze-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                      COMMAND ${CLANG_CHECK_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${_sources})
-      COMMAND ${CLANG_CHECK_EXE} -analyze -extra-arg="-Wno-unknown-warning-option" -p ${CMAKE_BINARY_DIR}
-              ${_sources})
     add_dependencies(clang-analyze-check-${target} ${target})
     add_dependencies(clang-analyze-check clang-analyze-check-${target})
   else()

CMLibCodeAnalysisClangTidy.cmake

@@ -1,29 +1,21 @@
-find_program(
+find_program(CLANG_TIDY_EXE NAMES clang-tidy-10 clang-tidy-9 clang-tidy)
-  CLANG_TIDY_EXE
-  NAMES
-    clang-tidy-10
-    clang-tidy-9
-    clang-tidy-8
-    clang-tidy-7
-    clang-tidy-6.0
-    clang-tidy)
 if(CLANG_TIDY_EXE)
-  option(CLANG_TIDY_FIX "Perform fixes for Clang-Tidy" OFF)
+  option(CMLIB_CLANG_TIDY_FIX "Perform fixes for Clang-Tidy" OFF)
-  if(CLANG_TIDY_FIX)
-    list(APPEND _args "-fix")
-  endif()
 endif()
 
 function(add_clang_tidy_check target)
   set(_sources ${ARGN})
+  set(_args -extra-arg="-Wno-unknown-warning-option")
 
   if(CLANG_TIDY_EXE)
+    if(CMLIB_CLANG_TIDY_FIX)
+      list(APPEND _args "--fix")
+    endif()
     if(NOT TARGET clang-tidy-check)
       add_custom_target(clang-tidy-check)
     endif()
-    add_custom_target(
+    add_custom_target(clang-tidy-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      clang-tidy-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                      COMMAND ${CLANG_TIDY_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${_sources})
-      COMMAND ${CLANG_TIDY_EXE} -extra-arg="-Wno-unknown-warning-option" -p ${CMAKE_BINARY_DIR} ${_sources})
     add_dependencies(clang-tidy-check-${target} ${target})
     add_dependencies(clang-tidy-check clang-tidy-check-${target})
   else()

CMLibCodeAnalysisClazy.cmake

@@ -1,23 +1,46 @@
-set(clazy_checks
+find_program(CLANG_APPLY_REPLACEMENTS_EXE NAMES clang-apply-replacements-10 clang-apply-replacements-9
-    container-inside-loop,heap-allocated-small-trivial-type,inefficient-qlist,isempty-vs-count,qt-keywords,unneeded-cast
+                                                clang-apply-replacements)
-)
+
+find_program(CLAZY_EXE NAMES clazy-standalone)
+
+if(CLAZY_EXE AND CLANG_APPLY_REPLACEMENTS_EXE)
+  option(CMLIB_CLAZY_FIX "Perform fixes for Clazy" OFF)
+endif()
 
 function(add_clazy_check target)
-  set(_sources ${ARGN})
+  set(options)
+  set(oneValueArgs CHECKS)
+  set(multiValueArgs)
+
+  cmake_parse_arguments(_CLAZY "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  set(_sources ${_CLAZY_UNPARSED_ARGUMENTS})
+  if(NOT _CLAZY_CHECKS)
+    set(_CLAZY_CHECKS
+        "level2,container-inside-loop,heap-allocated-small-trivial-type,inefficient-qlist,isempty-vs-count,qt-keywords,unneeded-cast"
+    )
+  endif()
+  set(_args -checks=${_CLAZY_CHECKS} -extra-arg="-Wno-unknown-warning-option"
+            -export-fixes=clazy-fixes-file.yaml)
 
-  find_program(CLAZY_EXE NAMES clazy-standalone)
   if(CLAZY_EXE)
     if(NOT TARGET clazy-check)
       add_custom_target(clazy-check)
     endif()
-    add_custom_target(
+    if(CMLIB_CLAZY_FIX)
-      clazy-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      add_custom_target(
-      COMMAND ${CLAZY_EXE} -checks=level2,${clazy_checks} -extra-arg="-Wno-unknown-warning-option" -p
+        clazy-check-${target}
-              ${CMAKE_BINARY_DIR} ${_sources})
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        COMMAND ${CLAZY_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${_sources}
+        COMMAND ${CLANG_APPLY_REPLACEMENTS_EXE} ${CMAKE_BINARY_DIR})
+    else()
+      add_custom_target(clazy-check-${target} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                        COMMAND ${CLAZY_EXE} ${_args} -p ${CMAKE_BINARY_DIR} ${_sources})
+    endif()
     add_dependencies(clazy-check-${target} ${target})
     add_dependencies(clazy-check clazy-check-${target})
   else()
     message(STATUS "CMLIB warning:")
-    message(STATUS "  Clazy analyzer is not found")
+    message(STATUS "  Clazy standalone analyzer is not found")
   endif()
 endfunction()

CMLibCodeCoverage.cmake

@@ -1,10 +1,10 @@
-option(ENABLE_CODE_COVERAGE "Enable code coverage support" OFF)
+option(CMLIB_ENABLE_CODE_COVERAGE "Enable code coverage support" OFF)
 find_program(LCOV_EXE NAMES lcov)
 find_program(GENHTML_EXE NAMES genhtml)
 
 function(add_code_coverage target)
 
-  if(ENABLE_CODE_COVERAGE)
+  if(CMLIB_ENABLE_CODE_COVERAGE)
     if(CMAKE_CXX_COMPILER_IS_GCC)
       target_compile_options(${target} PUBLIC "--coverage")
       get_target_property(LF ${target} LINK_FLAGS)

CMLibCommon.cmake

@@ -27,6 +27,7 @@ include(CMLibCompilerFlags)
 include(CMLibDistCC)
 include(CMLibCompilerFeaturesHPPGenerate)
 include(CMLibFlagRemove)
+include(CMLibCotire)
 include(CMLibBuildTypes)
 include(CMLibCommonTargetProperties)
 include(CMLibCommonLibraryTarget)
@@ -36,7 +37,6 @@ include(CMLibCodeAnalysisClangTidy)
 include(CMLibCodeAnalysisClazy)
 include(CMLibCodeCoverage)
 include(CMLibSanitizers)
-include(cotire)
 
 include(CMLibFormatSources)
 include(CMLibDocDoxygen)

CMLibCommonLibraryTarget.cmake

@@ -19,21 +19,22 @@ function(add_common_library target)
                      $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include> $<INSTALL_INTERFACE:include/${target}>)
   set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
+  # cmake-format: off
   if(BUILD_SHARED_LIBS)
     add_library(${target}_shared SHARED $<TARGET_OBJECTS:${target}>)
-    set_target_properties(
+    set_target_properties(${target}_shared PROPERTIES OUTPUT_NAME ${OUTNAME}
-      ${target}_shared
+      VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR}
-      PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} OUTPUT_NAME ${OUTNAME}
+      LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
-                 LIBRARY_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR})
     install(TARGETS ${target}_shared LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
   endif()
 
   if(NOT SKIP_STATIC_LIBS)
     add_library(${target}_static STATIC $<TARGET_OBJECTS:${target}>)
-    set_target_properties(${target}_static PROPERTIES OUTPUT_NAME ${OUTNAME} ARCHIVE_OUTPUT_DIRECTORY
+    set_target_properties(${target}_static PROPERTIES OUTPUT_NAME ${OUTNAME}
-                                                                             ${CMAKE_INSTALL_LIBDIR})
+      ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
     install(TARGETS ${target}_static ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
   endif()
+  # cmake-format: on
 
   configure_file(${CMLIB_MODULE_DIR}/pc/lib.pc.in ${CMAKE_BINARY_DIR}/${target}.pc)
   install(FILES ${CMAKE_BINARY_DIR}/${target}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

CMLibCommonTargetProperties.cmake

@@ -18,8 +18,12 @@ function(common_target_properties target)
 
   target_compile_features(${target} ${__visibility} ${COMMON_CXX_FEATURES})
   get_target_property(_targetType ${target} TYPE)
-  if(_targetType STREQUAL "EXECUTABLE" AND CMAKE_CXX_COMPILE_OPTIONS_PIE)
+  if(_targetType STREQUAL "EXECUTABLE")
-    target_compile_options(${target} PUBLIC "${CMAKE_CXX_COMPILE_OPTIONS_PIE}")
+    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()
   endif()
   target_include_directories(
     ${target}
@@ -33,18 +37,6 @@ function(common_target_properties target)
       if(_targetType STREQUAL "EXECUTABLE")
         target_compile_options(${target} PUBLIC "${Qt5Core_EXECUTABLE_COMPILE_FLAGS}")
       endif()
-      # set_target_properties(${target} PROPERTIES AUTOMOC TRUE)
-      # set_target_properties(${target} PROPERTIES AUTORCC TRUE)
-    endif()
-    if(TARGET Qt5::Widgets)
-      # set_target_properties(${target} PROPERTIES AUTOUIC TRUE)
-      #      if(CMAKE_VERSION VERSION_LESS 3.7.99)
-      #        target_include_directories(
-      #          ${target}
-      #          PUBLIC
-      #          $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/${target}_autogen/include>
-      #          )
-      #      endif()
     endif()
     if(CMAKE_CXX_COMPILER_IS_GCC AND NOT APPLE)
       set_target_properties(${target} PROPERTIES LINK_FLAGS "-Wl,--no-as-needed")
@@ -81,6 +73,10 @@ function(common_target_properties target)
     endif()
   endif()
 
+  set_target_properties(${target} PROPERTIES COTIRE_ENABLE_PRECOMPILED_HEADER
+                                             ${CMLIB_COTIRE_ENABLE_PRECOMPILED_HEADER})
+  set_target_properties(${target} PROPERTIES COTIRE_ADD_UNITY_BUILD ${CMLIB_COTIRE_ADD_UNITY_BUILD})
+
   if(CMAKE_BUILD_TYPE STREQUAL Profile)
     target_compile_definitions(${target} ${__visibility} PROFILE)
   elseif(CMAKE_BUILD_TYPE STREQUAL Debug)

CMLibCompilerFeaturesHPPGenerate.cmake

@@ -1,7 +1,12 @@
 include(WriteCompilerDetectionHeader)
 
+set(OUTPUT_FILE ${CMAKE_BINARY_DIR}/include/compiler_features.hpp)
+if(CMLIB_GENERATED_HEADERS_PATH)
+  set(OUTPUT_FILE ${CMLIB_GENERATED_HEADERS_PATH}/compiler_features.hpp)
+endif()
+
 write_compiler_detection_header(
-  FILE include/compiler_features.hpp
+  FILE ${OUTPUT_FILE}
   PREFIX ${CMLIB_PROJECT_NAME_CANONICAL}
   COMPILERS GNU Clang MSVC Intel
   FEATURES
@@ -14,3 +19,5 @@ write_compiler_detection_header(
     cxx_constexpr
     cxx_digit_separators
     cxx_range_for)
+
+unset(OUTPUT_FILE)

CMLibCompilerFlags.cmake

@@ -1,5 +1,7 @@
 # based on https://github.com/bluescarni/yacma
 
+option(CMLIB_WARNING_FLAGS "Enable warning flags" ON)
+
 include(CheckCXXCompilerFlag)
 
 macro(CHECK_ENABLE_CXX_FLAG flag)
@@ -35,7 +37,7 @@ if(CMAKE_CXX_COMPILER_IS_CLANG OR CMAKE_CXX_COMPILER_IS_INTEL OR CMAKE_CXX_COMPI
   set(CMAKE_CXX_STANDARD_REQUIRED YES)
   set(CMAKE_CXX_EXTENSIONS YES)
 
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  if(CMLIB_WARNING_FLAGS AND CMAKE_BUILD_TYPE STREQUAL "Debug")
     check_enable_cxx_flag(-Wall)
     check_enable_cxx_flag(-Wextra)
     check_enable_cxx_flag(-Wnon-virtual-dtor)

CMLibConfigHPPGenerate.cmake

@@ -2,7 +2,13 @@ function(cmlib_config_hpp_generate)
   include(CMLibLargeFiles)
   cmlib_test_large_files(HAVE_LARGEFILES)
 
+  set(OUTPUT_FILE ${CMAKE_BINARY_DIR}/include/cmlib_private_config.hpp)
+  if(CMLIB_GENERATED_HEADERS_PATH)
+    set(OUTPUT_FILE ${CMLIB_GENERATED_HEADERS_PATH}/cmlib_private_config.hpp)
+  elseif(ARGV0)
+    set(OUTPUT_FILE ${ARGV0})
+  endif()
+
   get_property(PROJECT_VERSION_INT GLOBAL PROPERTY PROJECT_VERSION_INT)
-  configure_file(${CMLIB_MODULE_DIR}/hpp/cmlib_private_config.hpp.in
+  configure_file(${CMLIB_MODULE_DIR}/hpp/cmlib_private_config.hpp.in ${OUTPUT_FILE})
-                 ${CMAKE_BINARY_DIR}/include/cmlib_private_config.hpp)
 endfunction()

CMLibCotire.cmake

@@ -0,0 +1,6 @@
+include(cotire)
+
+if(COMMAND cotire)
+  option(CMLIB_COTIRE_ENABLE_PRECOMPILED_HEADER "Enable precompiled headers" OFF)
+  option(CMLIB_COTIRE_ADD_UNITY_BUILD "Enable unity build" OFF)
+endif()

CMLibFormatSources.cmake

@@ -4,22 +4,28 @@ function(add_format_sources target)
   if(NOT TARGET format-sources)
     add_custom_target(format-sources)
   endif()
+  if(NOT TARGET doc-add-comments)
+    add_custom_target(doc-add-comments)
+  endif()
 
   find_program(UNCRUSTIFY_EXE NAMES uncrustify)
   if(UNCRUSTIFY_EXE)
-    list(
+    list(APPEND UNCRUSTIFY_OPTS -lCPP --replace --no-backup)
-      APPEND
-      UNCRUSTIFY_OPTS
-      -lCPP
-      --replace
-      --no-backup
-      --mtime)
     if(EXISTS ${CMAKE_SOURCE_DIR}/cmake/etc/uncrustify/default.cfg)
       list(APPEND UNCRUSTIFY_OPTS -c ${CMAKE_SOURCE_DIR}/cmake/etc/uncrustify/default.cfg)
     endif()
+    # cmake-format: off
     add_custom_target(format-sources-uncrustify-${target} COMMAND ${UNCRUSTIFY_EXE} ${UNCRUSTIFY_OPTS}
-                                                                  ${_sources})
+      --mtime ${_sources})
+    add_custom_target(doc-add-comments-uncrustify-${target} 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(format-sources format-sources-uncrustify-${target})
+    add_dependencies(doc-add-comments doc-add-comments-uncrustify-${target})
   else()
     message(STATUS "CMLIB warning:")
     message(STATUS "  uncrustify executable is not found")

CMLibRequiredVariables.cmake

@@ -10,10 +10,6 @@ endif()
 
 set(CPACK_PACKAGE_VENDOR ${ORGANIZATION_NAME})
 
-if(NOT CPACK_GENERATOR)
-  message(FATAL_ERROR "Required variable CPACK_GENERATOR is not defined")
-endif()
-
 if(NOT CPACK_PACKAGE_CONTACT)
   message(FATAL_ERROR "Required variable CPACK_PACKAGE_CONTACT is not defined")
 endif()
@@ -21,15 +17,3 @@ endif()
 if(NOT CPACK_PACKAGE_DESCRIPTION_SUMMARY)
   message(FATAL_ERROR "Required variable CPACK_PACKAGE_DESCRIPTION_SUMMARY is not defined")
 endif()
-
-if(NOT CPACK_DEBIAN_PACKAGE_SECTION)
-  message(FATAL_ERROR "Required variable CPACK_DEBIAN_PACKAGE_SECTION is not defined")
-endif()
-
-if(NOT CPACK_DEBIAN_PACKAGE_PRIORITY)
-  message(FATAL_ERROR "Required variable CPACK_DEBIAN_PACKAGE_PRIORITY is not defined")
-endif()
-
-if(NOT CPACK_SOURCE_IGNORE_FILES)
-  message(FATAL_ERROR "Required variable CPACK_SOURCE_IGNORE_FILES is not defined")
-endif()

thirdparty/cotire.cmake

@@ -931,7 +931,13 @@ function (cotire_add_includes_to_cmd _cmdVar _language _includesVar _systemInclu
 					list (FIND ${_systemIncludesVar} "${_include}" _index)
 				endif()
 				if (_index GREATER -1)
-					list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_SYSTEM_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_SEP_${_language}}${_include}")
+					if (CMAKE_${_language}_COMPILER_ID MATCHES "GNU|Clang")
+						string(REPLACE " " "" _flag ${CMAKE_INCLUDE_SYSTEM_FLAG_${_language}})
+						list (APPEND ${_cmdVar} "${_flag}")
+						list (APPEND ${_cmdVar} "${_include}")
+					else()
+						list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_SYSTEM_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_SEP_${_language}}${_include}")
+					endif()
 				else()
 					list (APPEND ${_cmdVar} "${CMAKE_INCLUDE_FLAG_${_language}}${CMAKE_INCLUDE_FLAG_SEP_${_language}}${_include}")
 				endif()