diff options
82 files changed, 766 insertions, 518 deletions
diff --git a/CompileFlags.cmake b/CompileFlags.cmake index c8a039a..91f2adf 100644 --- a/CompileFlags.cmake +++ b/CompileFlags.cmake @@ -8,11 +8,16 @@ if(WIN32 AND CMAKE_C_COMPILER_ID STREQUAL "Intel") set(_INTEL_WINDOWS 1) endif() +if(WIN32 AND CMAKE_C_COMPILER_ID STREQUAL "Clang" + AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + set(_CLANG_MSVC_WINDOWS 1) +endif() + # Disable deprecation warnings for standard C functions. # really only needed for newer versions of VS, but should # not hurt other versions, and this will work into the # future -if(MSVC OR _INTEL_WINDOWS) +if(MSVC OR _INTEL_WINDOWS OR _CLANG_MSVC_WINDOWS) add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE) else() endif() @@ -21,6 +26,10 @@ if(MSVC) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stack:10000000") endif() +if(_CLANG_MSVC_WINDOWS AND "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Xlinker -stack:20000000") +endif() + #silence duplicate symbol warnings on AIX if(CMAKE_SYSTEM_NAME MATCHES "AIX") if(NOT CMAKE_COMPILER_IS_GNUCXX) diff --git a/Help/command/install.rst b/Help/command/install.rst index 7571aae..ab6fef6 100644 --- a/Help/command/install.rst +++ b/Help/command/install.rst @@ -660,9 +660,9 @@ and installed by the current project. For example, the code install(TARGETS myexe EXPORT myproj DESTINATION bin) install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj) - install(EXPORT_ANDROID_MK myexp DESTINATION share/ndk-modules) + install(EXPORT_ANDROID_MK myproj DESTINATION share/ndk-modules) -will install the executable myexe to ``<prefix>/bin`` and code to import +will install the executable ``myexe`` to ``<prefix>/bin`` and code to import it in the file ``<prefix>/lib/myproj/myproj.cmake`` and ``<prefix>/share/ndk-modules/Android.mk``. An outside project may load this file with the include command and reference the ``myexe`` diff --git a/Help/dev/maint.rst b/Help/dev/maint.rst index a8942cd..1153a09 100644 --- a/Help/dev/maint.rst +++ b/Help/dev/maint.rst @@ -188,12 +188,6 @@ Update ``Source/CMakeVersion.cmake`` to set the version to set(CMake_VERSION_PATCH 0) set(CMake_VERSION_RC 1) -Update ``Utilities/Release/upload_release.cmake``: - -.. code-block:: cmake - - set(VERSION $ver) - Update uses of ``DEVEL_CMAKE_VERSION`` in the source tree to mention the actual version number: diff --git a/Help/manual/cmake.1.rst b/Help/manual/cmake.1.rst index 97c65e7..107c2cb 100644 --- a/Help/manual/cmake.1.rst +++ b/Help/manual/cmake.1.rst @@ -552,20 +552,23 @@ Available commands are: Compress the resulting archive with bzip2. ``J`` Compress the resulting archive with XZ. - ``--`` - Stop interpreting options and treat all remaining arguments - as file names even if they start in ``-``. + ``--zstd`` + Compress the resulting archive with Zstandard. ``--files-from=<file>`` Read file names from the given file, one per line. Blank lines are ignored. Lines may not start in ``-`` except for ``--add-file=<name>`` to add files whose names start in ``-``. - ``--mtime=<date>`` - Specify modification time recorded in tarball entries. ``--format=<format>`` Specify the format of the archive to be created. Supported formats are: ``7zip``, ``gnutar``, ``pax``, ``paxr`` (restricted pax, default), and ``zip``. + ``--mtime=<date>`` + Specify modification time recorded in tarball entries. + ``--`` + Stop interpreting options and treat all remaining arguments + as file names, even if they start with ``-``. + ``time <command> [<args>...]`` Run command and display elapsed time. diff --git a/Help/release/dev/FindPython-FIND_FRAMEWORK.rst b/Help/release/dev/FindPython-FIND_FRAMEWORK.rst new file mode 100644 index 0000000..f390460 --- /dev/null +++ b/Help/release/dev/FindPython-FIND_FRAMEWORK.rst @@ -0,0 +1,5 @@ +FindPython-FIND_FRAMEWORK +------------------------- + +* Modules :module:`FindPython3`, :module:`FindPython2` and :module:`FindPython` + gain a new variable to control frameworks lookup on macOS. diff --git a/Help/release/dev/clang-gnulike-support.rst b/Help/release/dev/clang-gnulike-support.rst new file mode 100644 index 0000000..87715d7 --- /dev/null +++ b/Help/release/dev/clang-gnulike-support.rst @@ -0,0 +1,5 @@ +clang-gnulike-support +--------------------- + +* The ``Clang`` compiler variant on Windows that targets the MSVC ABI + but has a GNU-like command line is now supported. diff --git a/Help/release/dev/cmake-e-tar-zstd-support.rst b/Help/release/dev/cmake-e-tar-zstd-support.rst new file mode 100644 index 0000000..e3488b5 --- /dev/null +++ b/Help/release/dev/cmake-e-tar-zstd-support.rst @@ -0,0 +1,7 @@ +Help/release/dev/cmake-e-tar-zstd-support +----------------------------------------- + +* The :manual:`cmake(1)` ``-E tar`` tool now support Zstandard compression + algorithm with ``--zstd`` option. Zstandard was designed to give + a compression ratio comparable to that of the DEFLATE (zip) algorithm, + but faster, especially for decompression. diff --git a/Help/release/dev/cmake_automoc_relaxed_mode.rst b/Help/release/dev/cmake_automoc_relaxed_mode.rst new file mode 100644 index 0000000..aa4772a --- /dev/null +++ b/Help/release/dev/cmake_automoc_relaxed_mode.rst @@ -0,0 +1,5 @@ +cmake_automoc_relaxed_mode +-------------------------- + +* The variable :variable:`CMAKE_AUTOMOC_RELAXED_MODE` is considered + deprecated. Support still exists but will be removed in future versions. diff --git a/Help/variable/CMAKE_AUTOMOC_RELAXED_MODE.rst b/Help/variable/CMAKE_AUTOMOC_RELAXED_MODE.rst index addc62d..6c0c61b 100644 --- a/Help/variable/CMAKE_AUTOMOC_RELAXED_MODE.rst +++ b/Help/variable/CMAKE_AUTOMOC_RELAXED_MODE.rst @@ -1,6 +1,8 @@ CMAKE_AUTOMOC_RELAXED_MODE -------------------------- +.. deprecated:: 3.15 + Switch between strict and relaxed automoc mode. By default, :prop_tgt:`AUTOMOC` behaves exactly as described in the diff --git a/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst b/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst index 36fa37d..a03d473 100644 --- a/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst +++ b/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst @@ -2,6 +2,6 @@ CTEST_CUSTOM_WARNING_EXCEPTION ------------------------------ A list of regular expressions which will be used to exclude when detecting -warning messages in build outputs by the :command:`ctest_test` command. +warning messages in build outputs by the :command:`ctest_build` command. .. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst b/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst index a35be96..18aa6b3 100644 --- a/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst +++ b/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst @@ -2,6 +2,6 @@ CTEST_CUSTOM_WARNING_MATCH -------------------------- A list of regular expressions which will be used to detect warning messages in -build outputs by the :command:`ctest_test` command. +build outputs by the :command:`ctest_build` command. .. include:: CTEST_CUSTOM_XXX.txt diff --git a/Modules/CMakeCCompiler.cmake.in b/Modules/CMakeCCompiler.cmake.in index f473b0d..9b8d423 100644 --- a/Modules/CMakeCCompiler.cmake.in +++ b/Modules/CMakeCCompiler.cmake.in @@ -12,6 +12,7 @@ set(CMAKE_C11_COMPILE_FEATURES "@CMAKE_C11_COMPILE_FEATURES@") set(CMAKE_C_PLATFORM_ID "@CMAKE_C_PLATFORM_ID@") set(CMAKE_C_SIMULATE_ID "@CMAKE_C_SIMULATE_ID@") +set(CMAKE_C_COMPILER_FRONTEND_VARIANT "@CMAKE_C_COMPILER_FRONTEND_VARIANT@") set(CMAKE_C_SIMULATE_VERSION "@CMAKE_C_SIMULATE_VERSION@") @_SET_CMAKE_C_COMPILER_ARCHITECTURE_ID@ @SET_MSVC_C_ARCHITECTURE_ID@ diff --git a/Modules/CMakeCXXCompiler.cmake.in b/Modules/CMakeCXXCompiler.cmake.in index a1be02b..e7f0e70 100644 --- a/Modules/CMakeCXXCompiler.cmake.in +++ b/Modules/CMakeCXXCompiler.cmake.in @@ -14,6 +14,7 @@ set(CMAKE_CXX20_COMPILE_FEATURES "@CMAKE_CXX20_COMPILE_FEATURES@") set(CMAKE_CXX_PLATFORM_ID "@CMAKE_CXX_PLATFORM_ID@") set(CMAKE_CXX_SIMULATE_ID "@CMAKE_CXX_SIMULATE_ID@") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "@CMAKE_CXX_COMPILER_FRONTEND_VARIANT@") set(CMAKE_CXX_SIMULATE_VERSION "@CMAKE_CXX_SIMULATE_VERSION@") @_SET_CMAKE_CXX_COMPILER_ARCHITECTURE_ID@ @SET_MSVC_CXX_ARCHITECTURE_ID@ diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake index 495d7e8..8be781a 100644 --- a/Modules/CMakeDetermineCCompiler.cmake +++ b/Modules/CMakeDetermineCCompiler.cmake @@ -114,7 +114,6 @@ if(NOT CMAKE_C_COMPILER_ID_RUN) include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake) CMAKE_DETERMINE_COMPILER_ID(C CFLAGS CMakeCCompilerId.c) - CMAKE_DIAGNOSE_UNSUPPORTED_CLANG(C CC) # Set old compiler and platform id variables. if(CMAKE_C_COMPILER_ID STREQUAL "GNU") diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake index afcd956..00ef5b9 100644 --- a/Modules/CMakeDetermineCXXCompiler.cmake +++ b/Modules/CMakeDetermineCXXCompiler.cmake @@ -109,7 +109,6 @@ if(NOT CMAKE_CXX_COMPILER_ID_RUN) include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake) CMAKE_DETERMINE_COMPILER_ID(CXX CXXFLAGS CMakeCXXCompilerId.cpp) - CMAKE_DIAGNOSE_UNSUPPORTED_CLANG(CXX CXX) # Set old compiler and platform id variables. if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index c7e5685..6083358 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -136,6 +136,31 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "") endif() + set(_variant "") + if("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xClang") + if(CMAKE_HOST_WIN32 AND "x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC") + if(CMAKE_GENERATOR MATCHES "Visual Studio") + set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC") + else() + # Test whether an MSVC-like command-line option works. + execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -? + RESULT_VARIABLE _clang_result + OUTPUT_VARIABLE _clang_stdout + ERROR_VARIABLE _clang_stderr) + if(_clang_result EQUAL 0) + set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC") + else() + set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU") + endif() + endif() + set(_variant " with ${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}-like command-line") + else() + set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU") + endif() + else() + set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "") + endif() + # Display the final identification result. if(CMAKE_${lang}_COMPILER_ID) if(CMAKE_${lang}_COMPILER_VERSION) @@ -149,9 +174,10 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) set(_archid "") endif() message(STATUS "The ${lang} compiler identification is " - "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}") + "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}${_variant}") unset(_archid) unset(_version) + unset(_variant) else() message(STATUS "The ${lang} compiler identification is unknown") endif() @@ -163,6 +189,7 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) PARENT_SCOPE) set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_${lang}_XCODE_ARCHS}" PARENT_SCOPE) set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX}" PARENT_SCOPE) + set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}" PARENT_SCOPE) set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE) set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${CMAKE_${lang}_COMPILER_VERSION_INTERNAL}" PARENT_SCOPE) set(CMAKE_${lang}_COMPILER_WRAPPER "${CMAKE_${lang}_COMPILER_WRAPPER}" PARENT_SCOPE) @@ -864,38 +891,3 @@ function(CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX lang userflags) set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "" PARENT_SCOPE) endif() endfunction() - -function(CMAKE_DIAGNOSE_UNSUPPORTED_CLANG lang envvar) - if(NOT CMAKE_HOST_WIN32 OR CMAKE_GENERATOR MATCHES "Visual Studio" OR - NOT "${CMAKE_${lang}_COMPILER_ID};${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "Clang;MSVC") - return() - endif() - - # Test whether an MSVC-like command-line option works. - execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -? - RESULT_VARIABLE _clang_result - OUTPUT_VARIABLE _clang_stdout - ERROR_VARIABLE _clang_stderr) - if(_clang_result EQUAL 0) - return() - endif() - - # Help the user configure the environment to use the MSVC-like Clang. - string(CONCAT _msg - "The Clang compiler tool\n" - " \"${CMAKE_${lang}_COMPILER}\"\n" - "targets the MSVC ABI but has a GNU-like command-line interface. " - "This is not supported. " - "Use 'clang-cl' instead, e.g. by setting '${envvar}=clang-cl' in the environment." - ) - execute_process(COMMAND rc -help - RESULT_VARIABLE _rc_result - OUTPUT_VARIABLE _rc_stdout - ERROR_VARIABLE _rc_stderr) - if(NOT _rc_result EQUAL 0) - string(APPEND _msg " " - "Furthermore, use the MSVC command-line environment." - ) - endif() - message(FATAL_ERROR "${_msg}") -endfunction() diff --git a/Modules/CMakeFindBinUtils.cmake b/Modules/CMakeFindBinUtils.cmake index 35f75c9..0e84116 100644 --- a/Modules/CMakeFindBinUtils.cmake +++ b/Modules/CMakeFindBinUtils.cmake @@ -60,7 +60,9 @@ __resolve_tool_path(CMAKE_MT "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Manifes set(_CMAKE_TOOL_VARS "") # if it's the MS C/CXX compiler, search for link -if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC" +if(("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_SIMULATE_ID}" STREQUAL "xMSVC" AND + ("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" + OR NOT "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xClang")) OR "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xMSVC" OR (CMAKE_HOST_WIN32 AND "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xPGI") OR (CMAKE_HOST_WIN32 AND "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xNVIDIA") @@ -80,17 +82,26 @@ else() if(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN) set(_CMAKE_TOOLCHAIN_LOCATION ${_CMAKE_TOOLCHAIN_LOCATION} ${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}/bin) endif() - find_program(CMAKE_AR NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar${_CMAKE_TOOLCHAIN_SUFFIX} HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) - find_program(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) + if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL Clang) + set(LLVM_OBJDUMP "llvm-objdump") + set(LLVM_LLD "ld.lld") + set(LLVM_RANLIB "llvm-ranlib") + set(LLVM_AR "llvm-ar") + endif() + + find_program(CMAKE_AR NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar${_CMAKE_TOOLCHAIN_SUFFIX} ${LLVM_AR} HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) + + find_program(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib ${LLVM_RANLIB} HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) if(NOT CMAKE_RANLIB) set(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib") endif() + find_program(CMAKE_STRIP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip${_CMAKE_TOOLCHAIN_SUFFIX} HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) - find_program(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) + find_program(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld ${LLVM_LLD} HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) find_program(CMAKE_NM NAMES ${_CMAKE_TOOLCHAIN_PREFIX}nm HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) - find_program(CMAKE_OBJDUMP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objdump HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) + find_program(CMAKE_OBJDUMP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objdump ${LLVM_OBJDUMP} HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) find_program(CMAKE_OBJCOPY NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objcopy HINTS ${_CMAKE_TOOLCHAIN_LOCATION}) list(APPEND _CMAKE_TOOL_VARS CMAKE_AR CMAKE_RANLIB CMAKE_STRIP CMAKE_LINKER CMAKE_NM CMAKE_OBJDUMP CMAKE_OBJCOPY) diff --git a/Modules/CMakeNinjaFindMake.cmake b/Modules/CMakeNinjaFindMake.cmake index 6a0c47e..702af13 100644 --- a/Modules/CMakeNinjaFindMake.cmake +++ b/Modules/CMakeNinjaFindMake.cmake @@ -3,6 +3,6 @@ find_program(CMAKE_MAKE_PROGRAM - NAMES ninja-build ninja + NAMES ninja-build ninja samu DOC "Program used to build from build.ninja files.") mark_as_advanced(CMAKE_MAKE_PROGRAM) diff --git a/Modules/CMakeSwiftInformation.cmake b/Modules/CMakeSwiftInformation.cmake index 2bba178..21f18d4 100644 --- a/Modules/CMakeSwiftInformation.cmake +++ b/Modules/CMakeSwiftInformation.cmake @@ -18,10 +18,16 @@ if(CMAKE_Swift_COMPILER_ID) endif() set(CMAKE_INCLUDE_FLAG_Swift "-I ") -set(CMAKE_Swift_DEFINE_FLAG -D) + set(CMAKE_Swift_COMPILE_OPTIONS_TARGET "-target ") set(CMAKE_Swift_COMPILER_ARG1 -frontend) +set(CMAKE_Swift_DEFINE_FLAG -D) set(CMAKE_Swift_FRAMEWORK_SEARCH_FLAG "-F ") +set(CMAKE_Swift_LINKER_WRAPPER_FLAG "-Xlinker" " ") +set(CMAKE_Swift_RESPONSE_FILE_LINK_FLAG @) + +set(CMAKE_Swift_LINKER_PREFERENCE 50) +set(CMAKE_Swift_LINKER_PREFERENCE_PROPAGATES 1) # NOTE(compnerd) use the short form for convenience and ease of search. They # are treated equivalent to their long form names as well as custom Swift diff --git a/Modules/Compiler/Clang-CXX.cmake b/Modules/Compiler/Clang-CXX.cmake index c116078..17f3917 100644 --- a/Modules/Compiler/Clang-CXX.cmake +++ b/Modules/Compiler/Clang-CXX.cmake @@ -1,7 +1,7 @@ include(Compiler/Clang) __compiler_clang(CXX) -if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") +if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") endif() @@ -10,7 +10,8 @@ if(APPLE AND NOT appleClangPolicy STREQUAL NEW) return() endif() -if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + +if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 2.1) set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98") set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98") @@ -56,6 +57,14 @@ if(NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") unset(_clang_version_std17) + if("x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + # This clang++ is missing some features because of MSVC compatibility. + unset(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT) + unset(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT) + unset(CMAKE_CXX17_STANDARD__HAS_FULL_SUPPORT) + unset(CMAKE_CXX20_STANDARD__HAS_FULL_SUPPORT) + endif() + __compiler_check_default_language_standard(CXX 2.1 98) elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 3.9 AND CMAKE_CXX_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.0) diff --git a/Modules/FindBoost.cmake b/Modules/FindBoost.cmake index 018f675..464f229 100644 --- a/Modules/FindBoost.cmake +++ b/Modules/FindBoost.cmake @@ -1093,6 +1093,16 @@ function(_Boost_COMPILER_FEATURES component _ret) # Compiler feature for `context` same as for `fiber`. set(_Boost_CONTEXT_COMPILER_FEATURES ${_Boost_FIBER_COMPILER_FEATURES}) endif() + + # Boost Contract library available in >= 1.67 + if(NOT Boost_VERSION_STRING VERSION_LESS 1.67.0) + # From `libs/contract/build/boost_contract_build.jam` + set(_Boost_CONTRACT_COMPILER_FEATURES + cxx_lambdas + cxx_variadic_templates + ) + endif() + string(TOUPPER ${component} uppercomponent) set(${_ret} ${_Boost_${uppercomponent}_COMPILER_FEATURES} PARENT_SCOPE) endfunction() diff --git a/Modules/FindFLEX.cmake b/Modules/FindFLEX.cmake index 09d57d2..d22b7ec 100644 --- a/Modules/FindFLEX.cmake +++ b/Modules/FindFLEX.cmake @@ -95,6 +95,7 @@ respectively ``FLEX_TARGET`` and ``BISON_TARGET`` macros. ${BISON_MyParser_OUTPUTS} ${FLEX_MyScanner_OUTPUTS} ) + target_link_libraries(Foo ${FLEX_LIBRARIES}) ==================================================================== #]=======================================================================] diff --git a/Modules/FindICU.cmake b/Modules/FindICU.cmake index e4b4909..38081f5 100644 --- a/Modules/FindICU.cmake +++ b/Modules/FindICU.cmake @@ -162,7 +162,8 @@ function(_ICU_FIND) string(TOUPPER "${program}" program_upcase) set(cache_var "ICU_${program_upcase}_EXECUTABLE") set(program_var "ICU_${program_upcase}_EXECUTABLE") - find_program("${cache_var}" "${program}" + find_program("${cache_var}" + NAMES "${program}" HINTS ${icu_roots} PATH_SUFFIXES ${icu_binary_suffixes} DOC "ICU ${program} executable" @@ -228,13 +229,15 @@ function(_ICU_FIND) list(APPEND component_libnames ${static_component_libnames}) list(APPEND component_debug_libnames ${static_component_debug_libnames}) endif() - find_library("${component_cache_release}" ${component_libnames} + find_library("${component_cache_release}" + NAMES ${component_libnames} HINTS ${icu_roots} PATH_SUFFIXES ${icu_library_suffixes} DOC "ICU ${component} library (release)" NO_PACKAGE_ROOT_PATH ) - find_library("${component_cache_debug}" ${component_debug_libnames} + find_library("${component_cache_debug}" + NAMES ${component_debug_libnames} HINTS ${icu_roots} PATH_SUFFIXES ${icu_library_suffixes} DOC "ICU ${component} library (debug)" @@ -286,7 +289,8 @@ function(_ICU_FIND) string(REPLACE "." "_" data_upcase "${data_upcase}") set(cache_var "ICU_${data_upcase}") set(data_var "ICU_${data_upcase}") - find_file("${cache_var}" "${data}" + find_file("${cache_var}" + NAMES "${data}" HINTS ${icu_roots} PATH_SUFFIXES ${icu_data_suffixes} DOC "ICU ${data} data file") diff --git a/Modules/FindOpenMP.cmake b/Modules/FindOpenMP.cmake index b909db8..def23bb 100644 --- a/Modules/FindOpenMP.cmake +++ b/Modules/FindOpenMP.cmake @@ -347,6 +347,7 @@ macro(_OPENMP_SET_VERSION_BY_SPEC_DATE LANG) # Preview versions "201611=5.0" # OpenMP 5.0 preview 1 # Combined versions, 2.5 onwards + "201811=5.0" "201511=4.5" "201307=4.0" "201107=3.1" @@ -363,6 +364,9 @@ macro(_OPENMP_SET_VERSION_BY_SPEC_DATE LANG) # Fortran version 1.0 "199710=1.0" ) + if(MSVC) + list(APPEND OpenMP_SPEC_DATE_MAP "2019=2.0") + endif() if(OpenMP_${LANG}_SPEC_DATE) string(REGEX MATCHALL "${OpenMP_${LANG}_SPEC_DATE}=([0-9]+)\\.([0-9]+)" _version_match "${OpenMP_SPEC_DATE_MAP}") diff --git a/Modules/FindPython.cmake b/Modules/FindPython.cmake index 59c286d..e2f3bf3 100644 --- a/Modules/FindPython.cmake +++ b/Modules/FindPython.cmake @@ -161,14 +161,19 @@ Hints * ``LAST``: Try to use registry after environment variables. * ``NEVER``: Never try to use registry. -``CMAKE_FIND_FRAMEWORK`` - On macOS the :variable:`CMAKE_FIND_FRAMEWORK` variable determine the order of +``Python_FIND_FRAMEWORK`` + On macOS the ``Python_FIND_FRAMEWORK`` variable determine the order of preference between Apple-style and unix-style package components. + This variable can be set to empty or take same values as + :variable:`CMAKE_FIND_FRAMEWORK` variable. .. note:: Value ``ONLY`` is not supported so ``FIRST`` will be used instead. + If ``Python_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK` + variable will be used, if any. + ``Python_FIND_VIRTUALENV`` This variable defines the handling of virtual environments. It is meaningfull only when a virtual environment is active (i.e. the ``activate`` script has diff --git a/Modules/FindPython/Support.cmake b/Modules/FindPython/Support.cmake index bb2f60d..83fd1c5 100644 --- a/Modules/FindPython/Support.cmake +++ b/Modules/FindPython/Support.cmake @@ -361,6 +361,24 @@ set (_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES net45 net40) # Apple frameworks handling _python_find_frameworks () +set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK "FIRST") + +if (DEFINED ${_PYTHON_PREFIX}_FIND_FRAMEWORK) + if (NOT ${_PYTHON_PREFIX}_FIND_FRAMEWORK MATCHES "^(FIRST|LAST|NEVER)$") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_FRAMEWORK}: invalid value for '${_PYTHON_PREFIX}_FIND_FRAMEWORK'. 'FIRST', 'LAST' or 'NEVER' expected. 'FIRST' will be used instead.") + else() + set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK ${${_PYTHON_PREFIX}_FIND_FRAMEWORK}) + endif() +elseif (DEFINED CMAKE_FIND_FRAMEWORK) + if (CMAKE_FIND_FRAMEWORK STREQUAL "ONLY") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: CMAKE_FIND_FRAMEWORK: 'ONLY' value is not supported. 'FIRST' will be used instead.") + elseif (NOT CMAKE_FIND_FRAMEWORK MATCHES "^(FIRST|LAST|NEVER)$") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${CMAKE_FIND_FRAMEWORK}: invalid value for 'CMAKE_FIND_FRAMEWORK'. 'FIRST', 'LAST' or 'NEVER' expected. 'FIRST' will be used instead.") + else() + set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK}) + endif() +endif() + # Save CMAKE_FIND_APPBUNDLE if (DEFINED CMAKE_FIND_APPBUNDLE) set (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE ${CMAKE_FIND_APPBUNDLE}) @@ -373,15 +391,8 @@ set (CMAKE_FIND_APPBUNDLE "NEVER") # Save CMAKE_FIND_FRAMEWORK if (DEFINED CMAKE_FIND_FRAMEWORK) set (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK}) - if (CMAKE_FIND_FRAMEWORK STREQUAL "ONLY") - message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: CMAKE_FIND_FRAMEWORK: 'ONLY' value is not supported. 'FIRST' will be used instead.") - set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK "FIRST") - else() - set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK}) - endif() else() unset (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK) - set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK "FIRST") endif() # To avoid framework lookup set (CMAKE_FIND_FRAMEWORK "NEVER") @@ -389,7 +400,7 @@ set (CMAKE_FIND_FRAMEWORK "NEVER") # Windows Registry handling if (DEFINED ${_PYTHON_PREFIX}_FIND_REGISTRY) if (NOT ${_PYTHON_PREFIX}_FIND_REGISTRY MATCHES "^(FIRST|LAST|NEVER)$") - message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_REGISTRY}: invalid value for '${_PYTHON_PREFIX}_FIND_REGISTRY'. 'FIRST', 'LAST' or 'NEVER' expected.") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_REGISTRY}: invalid value for '${_PYTHON_PREFIX}_FIND_REGISTRY'. 'FIRST', 'LAST' or 'NEVER' expected. 'FIRST' will be used instead.") set (_${_PYTHON_PREFIX}_FIND_REGISTRY "FIRST") else() set (_${_PYTHON_PREFIX}_FIND_REGISTRY ${${_PYTHON_PREFIX}_FIND_REGISTRY}) @@ -402,7 +413,7 @@ endif() if (DEFINED ENV{VIRTUAL_ENV}) if (DEFINED ${_PYTHON_PREFIX}_FIND_VIRTUALENV) if (NOT ${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY|STANDARD)$") - message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_VIRTUALENV}: invalid value for '${_PYTHON_PREFIX}_FIND_VIRTUALENV'. 'FIRST', 'ONLY' or 'IGNORE' expected.") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_VIRTUALENV}: invalid value for '${_PYTHON_PREFIX}_FIND_VIRTUALENV'. 'FIRST', 'ONLY' or 'STANDARD' expected. 'FIRST' will be used instead.") set (_${_PYTHON_PREFIX}_FIND_VIRTUALENV "FIRST") else() set (_${_PYTHON_PREFIX}_FIND_VIRTUALENV ${${_PYTHON_PREFIX}_FIND_VIRTUALENV}) diff --git a/Modules/FindPython2.cmake b/Modules/FindPython2.cmake index 8a633e0..8372ce7 100644 --- a/Modules/FindPython2.cmake +++ b/Modules/FindPython2.cmake @@ -162,14 +162,19 @@ Hints * ``LAST``: Try to use registry after environment variables. * ``NEVER``: Never try to use registry. -``CMAKE_FIND_FRAMEWORK`` - On macOS the :variable:`CMAKE_FIND_FRAMEWORK` variable determine the order of +``Python2_FIND_FRAMEWORK`` + On macOS the ``Python2_FIND_FRAMEWORK`` variable determine the order of preference between Apple-style and unix-style package components. + This variable can be set to empty or take same values as + :variable:`CMAKE_FIND_FRAMEWORK` variable. .. note:: Value ``ONLY`` is not supported so ``FIRST`` will be used instead. + If ``Python2_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK` + variable will be used, if any. + ``Python2_FIND_VIRTUALENV`` This variable defines the handling of virtual environments. It is meaningfull only when a virtual environment is active (i.e. the ``activate`` script has diff --git a/Modules/FindPython3.cmake b/Modules/FindPython3.cmake index 2867326..2ead5b6 100644 --- a/Modules/FindPython3.cmake +++ b/Modules/FindPython3.cmake @@ -162,14 +162,19 @@ Hints * ``LAST``: Try to use registry after environment variables. * ``NEVER``: Never try to use registry. -``CMAKE_FIND_FRAMEWORK`` - On macOS the :variable:`CMAKE_FIND_FRAMEWORK` variable determine the order of +``Python3_FIND_FRAMEWORK`` + On macOS the ``Python3_FIND_FRAMEWORK`` variable determine the order of preference between Apple-style and unix-style package components. + This variable can be set to empty or take same values as + :variable:`CMAKE_FIND_FRAMEWORK` variable. .. note:: Value ``ONLY`` is not supported so ``FIRST`` will be used instead. + If ``Python3_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK` + variable will be used, if any. + ``Python3_FIND_VIRTUALENV`` This variable defines the handling of virtual environments. It is meaningfull only when a virtual environment is active (i.e. the ``activate`` script has diff --git a/Modules/FindThreads.cmake b/Modules/FindThreads.cmake index d317b71..b0c91b2 100644 --- a/Modules/FindThreads.cmake +++ b/Modules/FindThreads.cmake @@ -32,9 +32,6 @@ caller can set The compiler flag can only be used with the imported target. Use of both the imported target as well as this switch is highly recommended for new code. - -This module is not needed for C++11 and later if threading is done using -``std::thread`` from the standard library. #]=======================================================================] include (CheckLibraryExists) diff --git a/Modules/FindZLIB.cmake b/Modules/FindZLIB.cmake index 790eb42..79e2313 100644 --- a/Modules/FindZLIB.cmake +++ b/Modules/FindZLIB.cmake @@ -67,8 +67,8 @@ set(_ZLIB_SEARCH_NORMAL unset(_ZLIB_x86) list(APPEND _ZLIB_SEARCHES _ZLIB_SEARCH_NORMAL) -set(ZLIB_NAMES z zlib zdll zlib1) -set(ZLIB_NAMES_DEBUG zlibd zlibd1) +set(ZLIB_NAMES z zlib zdll zlib1 zlibstatic) +set(ZLIB_NAMES_DEBUG zd zlibd zdlld zlibd1 zlib1d zlibstaticd) # Try each search configuration. foreach(search ${_ZLIB_SEARCHES}) diff --git a/Modules/GetPrerequisites.cmake b/Modules/GetPrerequisites.cmake index fa6d75a..06655a4 100644 --- a/Modules/GetPrerequisites.cmake +++ b/Modules/GetPrerequisites.cmake @@ -169,17 +169,11 @@ Possible types are: other #]=======================================================================] -function(gp_append_unique list_var value) - set(contains 0) - - foreach(item ${${list_var}}) - if(item STREQUAL "${value}") - set(contains 1) - break() - endif() - endforeach() +cmake_policy(PUSH) +cmake_policy(SET CMP0057 NEW) # if IN_LIST - if(NOT contains) +function(gp_append_unique list_var value) + if(NOT item IN_LIST ${list_var}) set(${list_var} ${${list_var}} "${value}" PARENT_SCOPE) endif() endfunction() @@ -1043,3 +1037,5 @@ function(list_prerequisites_by_glob glob_arg glob_exp) endif() endforeach() endfunction() + +cmake_policy(POP) diff --git a/Modules/Platform/Windows-Clang.cmake b/Modules/Platform/Windows-Clang.cmake index 007ae53..b317da6 100644 --- a/Modules/Platform/Windows-Clang.cmake +++ b/Modules/Platform/Windows-Clang.cmake @@ -8,13 +8,120 @@ if(__WINDOWS_CLANG) endif() set(__WINDOWS_CLANG 1) +macro(__windows_compiler_clang_gnu lang) + set(CMAKE_LIBRARY_PATH_FLAG "-L") + set(CMAKE_LINK_LIBRARY_FLAG "-l") + + set(CMAKE_IMPORT_LIBRARY_PREFIX "") + set(CMAKE_SHARED_LIBRARY_PREFIX "") + set(CMAKE_SHARED_MODULE_PREFIX "") + set(CMAKE_STATIC_LIBRARY_PREFIX "") + set(CMAKE_EXECUTABLE_SUFFIX ".exe") + set(CMAKE_IMPORT_LIBRARY_SUFFIX ".lib") + set(CMAKE_SHARED_LIBRARY_SUFFIX ".dll") + set(CMAKE_SHARED_MODULE_SUFFIX ".dll") + set(CMAKE_STATIC_LIBRARY_SUFFIX ".lib") + set(CMAKE_DEPFILE_FLAGS_${lang} "-MD -MT <OBJECT> -MF <DEPFILE>") + + set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "") + set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll" ".dll.a" ".a" ".lib") + set(CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS 1) + set (CMAKE_LINK_DEF_FILE_FLAG "-Xlinker /DEF:") + + if("${CMAKE_${lang}_SIMULATE_VERSION}" MATCHES "^([0-9]+)\\.([0-9]+)") + math(EXPR MSVC_VERSION "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}") + endif() + + # No -fPIC on Windows + set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "") + set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "") + set(_CMAKE_${lang}_PIE_MAY_BE_SUPPORTED_BY_LINKER NO) + set(CMAKE_${lang}_LINK_OPTIONS_PIE "") + set(CMAKE_${lang}_LINK_OPTIONS_NO_PIE "") + set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "") + + set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1) + set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES 1) + set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 1) + + # Create archiving rules to support large object file lists for static libraries. + set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>") + set(CMAKE_${lang}_CREATE_SHARED_LIBRARY + "<CMAKE_${lang}_COMPILER> -nostartfiles -nostdlib <CMAKE_SHARED_LIBRARY_${lang}_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> -o <TARGET> ${CMAKE_GNULD_IMAGE_VERSION} -Xlinker /implib:<TARGET_IMPLIB> -Xlinker /pdb:<TARGET_PDB> -Xlinker /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> <OBJECTS> <LINK_LIBRARIES>") + set(CMAKE_${lang}_CREATE_SHARED_MODULE ${CMAKE_${lang}_CREATE_SHARED_LIBRARY}) + set(CMAKE_${lang}_LINK_EXECUTABLE + "<CMAKE_${lang}_COMPILER> -nostartfiles -nostdlib <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> -Xlinker /implib:<TARGET_IMPLIB> -Xlinker /pdb:<TARGET_PDB> -Xlinker /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR> ${CMAKE_GNULD_IMAGE_VERSION} <LINK_LIBRARIES>") + + set(CMAKE_${lang}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded -Xclang -flto-visibility-public-std -D_MT -Xclang --dependent-lib=libcmt) + set(CMAKE_${lang}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL -D_DLL -D_MT -Xclang --dependent-lib=msvcrt) + set(CMAKE_${lang}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug -D_DEBUG -Xclang -flto-visibility-public-std -D_MT -Xclang --dependent-lib=libcmtd) + set(CMAKE_${lang}_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL -D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd) + + if(CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT) + set(__ADDED_FLAGS "") + set(__ADDED_FLAGS_DEBUG "") + else() + set(__ADDED_FLAGS_DEBUG "-D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd") + set(__ADDED_FLAGS "-D_DLL -D_MT -Xclang --dependent-lib=msvcrt") + endif() + + string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -g -Xclang -gcodeview -O0 ${__ADDED_FLAGS_DEBUG}") + string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Os -DNDEBUG ${__ADDED_FLAGS}") + string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " -O3 -DNDEBUG ${__ADDED_FLAGS}") + string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG -Xclang -gcodeview ${__ADDED_FLAGS}") + set(CMAKE_INCLUDE_SYSTEM_FLAG_${lang} "-isystem ") + + unset(__ADDED_FLAGS) + unset(__ADDED_FLAGS_DEBUG) + string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE_LOWER) + set(CMAKE_${lang}_STANDARD_LIBRARIES_INIT "-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32 -loldnames") + + enable_language(RC) +endmacro() + if("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") - include(Platform/Windows-MSVC) - macro(__windows_compiler_clang lang) - set(_COMPILE_${lang} "${_COMPILE_${lang}_MSVC}") - __windows_compiler_msvc(${lang}) - endmacro() + + if ( DEFINED CMAKE_C_COMPILER_ID AND DEFINED CMAKE_CXX_COMPILER_ID + AND NOT "x${CMAKE_C_COMPILER_ID}" STREQUAL "x${CMAKE_CXX_COMPILER_ID}") + message(FATAL_ERROR "The current configuration mixes Clang and MSVC or " + "some other CL compatible compiler tool. This is not supported. " + "Use either clang or MSVC as both C and C++ compilers.") + endif() + + if ( DEFINED CMAKE_C_COMPILER_FRONTEND_VARIANT AND DEFINED CMAKE_CXX_COMPILER_FRONTEND_VARIANT + AND NOT "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}") + message(FATAL_ERROR "The current configuration uses the Clang compiler " + "tool with mixed frontend variants, both the GNU and in MSVC CL " + "like variants. This is not supported. Use either clang/clang++ " + "or clang-cl as both C and C++ compilers.") + endif() + + if ( "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" OR "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" ) + include(Platform/Windows-MSVC) + + macro(__windows_compiler_clang lang) + set(_COMPILE_${lang} "${_COMPILE_${lang}_MSVC}") + __windows_compiler_msvc(${lang}) + endmacro() + else() + cmake_policy(GET CMP0091 __WINDOWS_CLANG_CMP0091) + if(__WINDOWS_CLANG_CMP0091 STREQUAL "NEW") + set(CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL") + else() + set(CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT "") + endif() + unset(__WINDOWS_CLANG_CMP0091) + + set(CMAKE_BUILD_TYPE_INIT Debug) + + macro(__windows_compiler_clang lang) + __windows_compiler_clang_gnu(${lang}) + endmacro() + endif() + else() include(Platform/Windows-GNU) macro(__windows_compiler_clang lang) diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 9325305..63f1dce 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 14) -set(CMake_VERSION_PATCH 20190526) +set(CMake_VERSION_PATCH 20190530) #set(CMake_VERSION_RC 1) diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx index 177ba02..359d57a 100644 --- a/Source/cmArchiveWrite.cxx +++ b/Source/cmArchiveWrite.cxx @@ -137,6 +137,13 @@ cmArchiveWrite::cmArchiveWrite(std::ostream& os, Compress c, return; } break; + case CompressZstd: + if (archive_write_add_filter_zstd(this->Archive) != ARCHIVE_OK) { + this->Error = "archive_write_add_filter_zstd: "; + this->Error += cm_archive_error_string(this->Archive); + return; + } + break; } #if !defined(_WIN32) || defined(__CYGWIN__) if (archive_read_disk_set_standard_lookup(this->Disk) != ARCHIVE_OK) { diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h index 1f23dae..9ea88d3 100644 --- a/Source/cmArchiveWrite.h +++ b/Source/cmArchiveWrite.h @@ -49,7 +49,8 @@ public: CompressGZip, CompressBZip2, CompressLZMA, - CompressXZ + CompressXZ, + CompressZstd }; /** Construct with output stream to which to write archive. */ diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 071ff56..d1226c3 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -1611,8 +1611,8 @@ std::string cmCTest::Base64GzipEncodeFile(std::string const& file) std::vector<std::string> files; files.push_back(file); - if (!cmSystemTools::CreateTar(tarFile.c_str(), files, - cmSystemTools::TarCompressGZip, false)) { + if (!cmSystemTools::CreateTar(tarFile, files, cmSystemTools::TarCompressGZip, + false)) { cmCTestLog(this, ERROR_MESSAGE, "Error creating tar while " "encoding file: " diff --git a/Source/cmCallVisualStudioMacro.cxx b/Source/cmCallVisualStudioMacro.cxx index 2f6cf64..f7a2244 100644 --- a/Source/cmCallVisualStudioMacro.cxx +++ b/Source/cmCallVisualStudioMacro.cxx @@ -61,7 +61,8 @@ HRESULT InstanceCallMacro(IDispatch* vsIDE, const std::string& macro, if (0 != vsIDE) { DISPID dispid = (DISPID)-1; - OLECHAR* name = L"ExecuteCommand"; + wchar_t execute_command[] = L"ExecuteCommand"; + OLECHAR* name = execute_command; hr = vsIDE->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid); @@ -119,7 +120,8 @@ HRESULT InstanceCallMacro(IDispatch* vsIDE, const std::string& macro, } oss << " dwHelpContext: " << excep.dwHelpContext << std::endl; oss << " pvReserved: " << excep.pvReserved << std::endl; - oss << " pfnDeferredFillIn: " << excep.pfnDeferredFillIn << std::endl; + oss << " pfnDeferredFillIn: " + << reinterpret_cast<void*>(excep.pfnDeferredFillIn) << std::endl; oss << " scode: " << excep.scode << std::endl; } @@ -140,7 +142,8 @@ HRESULT GetSolutionObject(IDispatch* vsIDE, IDispatchPtr& vsSolution) if (0 != vsIDE) { DISPID dispid = (DISPID)-1; - OLECHAR* name = L"Solution"; + wchar_t solution[] = L"Solution"; + OLECHAR* name = solution; hr = vsIDE->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid); @@ -183,7 +186,8 @@ HRESULT GetSolutionFullName(IDispatch* vsSolution, std::string& fullName) if (0 != vsSolution) { DISPID dispid = (DISPID)-1; - OLECHAR* name = L"FullName"; + wchar_t full_name[] = L"FullName"; + OLECHAR* name = full_name; hr = vsSolution->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid); diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 3495f2a..26886f5 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -535,11 +535,22 @@ void cmGlobalGenerator::EnableLanguage( # ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx # pragma warning(push) -# pragma warning(disable : 4996) +# ifdef __INTEL_COMPILER +# pragma warning(disable : 1478) +# elif defined __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +# else +# pragma warning(disable : 4996) +# endif # endif GetVersionExW((OSVERSIONINFOW*)&osviex); # ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx -# pragma warning(pop) +# ifdef __clang__ +# pragma clang diagnostic pop +# else +# pragma warning(pop) +# endif # endif std::ostringstream windowsVersionString; windowsVersionString << osviex.dwMajorVersion << "." diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index ea65a77..3fce29e 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -238,14 +238,11 @@ void cmGlobalNinjaGenerator::WritePhonyBuild( void cmGlobalNinjaGenerator::AddCustomCommandRule() { - this->AddRule("CUSTOM_COMMAND", "$COMMAND", "$DESC", - "Rule for running custom commands.", - /*depfile*/ "", - /*deptype*/ "", - /*rspfile*/ "", - /*rspcontent*/ "", - /*restat*/ "", // bound on each build statement as needed - /*generator*/ false); + cmNinjaRule rule("CUSTOM_COMMAND"); + rule.Command = "$COMMAND"; + rule.Description = "$DESC"; + rule.Comment = "Rule for running custom commands."; + this->AddRule(rule); } void cmGlobalNinjaGenerator::WriteCustomCommandBuild( @@ -293,15 +290,11 @@ void cmGlobalNinjaGenerator::WriteCustomCommandBuild( void cmGlobalNinjaGenerator::AddMacOSXContentRule() { - this->AddRule("COPY_OSX_CONTENT", CMakeCmd() + " -E copy $in $out", - "Copying OS X Content $out", - "Rule for copying OS X bundle content file.", - /*depfile*/ "", - /*deptype*/ "", - /*rspfile*/ "", - /*rspcontent*/ "", - /*restat*/ "", - /*generator*/ false); + cmNinjaRule rule("COPY_OSX_CONTENT"); + rule.Command = CMakeCmd() + " -E copy $in $out"; + rule.Description = "Copying OS X Content $out"; + rule.Comment = "Rule for copying OS X bundle content file."; + this->AddRule(rule); } void cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input, @@ -320,40 +313,36 @@ void cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input, cmNinjaDeps(), cmNinjaVars()); } -void cmGlobalNinjaGenerator::WriteRule( - std::ostream& os, const std::string& name, const std::string& command, - const std::string& description, const std::string& comment, - const std::string& depfile, const std::string& deptype, - const std::string& rspfile, const std::string& rspcontent, - const std::string& restat, bool generator) +void cmGlobalNinjaGenerator::WriteRule(std::ostream& os, + cmNinjaRule const& rule) { // -- Parameter checks // Make sure the rule has a name. - if (name.empty()) { + if (rule.Name.empty()) { cmSystemTools::Error("No name given for WriteRule! called with comment: " + - comment); + rule.Comment); return; } // Make sure a command is given. - if (command.empty()) { + if (rule.Command.empty()) { cmSystemTools::Error( - "No command given for WriteRule! called with comment: " + comment); + "No command given for WriteRule! called with comment: " + rule.Comment); return; } // Make sure response file content is given - if (!rspfile.empty() && rspcontent.empty()) { + if (!rule.RspFile.empty() && rule.RspContent.empty()) { cmSystemTools::Error("rspfile but no rspfile_content given for WriteRule! " "called with comment: " + - comment); + rule.Comment); return; } // -- Write rule // Write rule intro - cmGlobalNinjaGenerator::WriteComment(os, comment); - os << "rule " << name << '\n'; + cmGlobalNinjaGenerator::WriteComment(os, rule.Comment); + os << "rule " << rule.Name << '\n'; // Write rule key/value pairs auto writeKV = [&os](const char* key, std::string const& value) { @@ -363,16 +352,16 @@ void cmGlobalNinjaGenerator::WriteRule( } }; - writeKV("depfile", depfile); - writeKV("deps", deptype); - writeKV("command", command); - writeKV("description", description); - if (!rspfile.empty()) { - writeKV("rspfile", rspfile); - writeKV("rspfile_content", rspcontent); + writeKV("depfile", rule.DepFile); + writeKV("deps", rule.DepType); + writeKV("command", rule.Command); + writeKV("description", rule.Description); + if (!rule.RspFile.empty()) { + writeKV("rspfile", rule.RspFile); + writeKV("rspfile_content", rule.RspContent); } - writeKV("restat", restat); - if (generator) { + writeKV("restat", rule.Restat); + if (rule.Generator) { writeKV("generator", "1"); } @@ -639,13 +628,20 @@ void cmGlobalNinjaGenerator::EnableLanguage( this->ResolveLanguageCompiler(l, mf, optional); } #ifdef _WIN32 - if ((mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID") != "MSVC") && - (mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID") != "MSVC") && - (mf->IsOn("CMAKE_COMPILER_IS_MINGW") || - (mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "GNU") || - (mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "GNU") || - (mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "Clang") || - (mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "Clang"))) { + const bool clangGnuMode = + ((mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "Clang") && + (mf->GetSafeDefinition("CMAKE_C_COMPILER_FRONTEND_VARIANT") == "GNU")) || + ((mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "Clang") && + (mf->GetSafeDefinition("CMAKE_CXX_COMPILER_FRONTEND_VARIANT") == "GNU")); + + if (clangGnuMode || + ((mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID") != "MSVC") && + (mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID") != "MSVC") && + (mf->IsOn("CMAKE_COMPILER_IS_MINGW") || + (mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "GNU") || + (mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "GNU") || + (mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "Clang") || + (mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "Clang")))) { this->UsingGCCOnWindows = true; } #endif @@ -690,23 +686,16 @@ cmGlobalNinjaGenerator::GenerateBuildCommand( // Non-virtual public methods. -void cmGlobalNinjaGenerator::AddRule( - const std::string& name, const std::string& command, - const std::string& description, const std::string& comment, - const std::string& depfile, const std::string& deptype, - const std::string& rspfile, const std::string& rspcontent, - const std::string& restat, bool generator) +void cmGlobalNinjaGenerator::AddRule(cmNinjaRule const& rule) { // Do not add the same rule twice. - if (!this->Rules.insert(name).second) { + if (!this->Rules.insert(rule.Name).second) { return; } // Store command length - this->RuleCmdLength[name] = static_cast<int>(command.size()); + this->RuleCmdLength[rule.Name] = static_cast<int>(rule.Command.size()); // Write rule - cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream, name, command, - description, comment, depfile, deptype, - rspfile, rspcontent, restat, generator); + cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream, rule); } bool cmGlobalNinjaGenerator::HasRule(const std::string& name) @@ -1322,21 +1311,18 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os) cmLocalGenerator* lg = this->LocalGenerators[0]; { - std::string cmd = CMakeCmd(); - cmd += " -S"; - cmd += lg->ConvertToOutputFormat(lg->GetSourceDirectory(), - cmOutputConverter::SHELL); - cmd += " -B"; - cmd += lg->ConvertToOutputFormat(lg->GetBinaryDirectory(), - cmOutputConverter::SHELL); - WriteRule(*this->RulesFileStream, "RERUN_CMAKE", cmd, - "Re-running CMake...", "Rule for re-running cmake.", - /*depfile=*/"", - /*deptype=*/"", - /*rspfile=*/"", - /*rspcontent*/ "", - /*restat=*/"", - /*generator=*/true); + cmNinjaRule rule("RERUN_CMAKE"); + rule.Command = CMakeCmd(); + rule.Command += " -S"; + rule.Command += lg->ConvertToOutputFormat(lg->GetSourceDirectory(), + cmOutputConverter::SHELL); + rule.Command += " -B"; + rule.Command += lg->ConvertToOutputFormat(lg->GetBinaryDirectory(), + cmOutputConverter::SHELL); + rule.Description = "Re-running CMake..."; + rule.Comment = "Rule for re-running cmake."; + rule.Generator = true; + WriteRule(*this->RulesFileStream, rule); } cmNinjaDeps implicitDeps; @@ -1358,20 +1344,15 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os) cmake* cm = this->GetCMakeInstance(); if (this->SupportsManifestRestat() && cm->DoWriteGlobVerifyTarget()) { { - std::string cmd = CMakeCmd(); - cmd += " -P "; - cmd += lg->ConvertToOutputFormat(cm->GetGlobVerifyScript(), - cmOutputConverter::SHELL); - - WriteRule(*this->RulesFileStream, "VERIFY_GLOBS", cmd, - "Re-checking globbed directories...", - "Rule for re-checking globbed directories.", - /*depfile=*/"", - /*deptype=*/"", - /*rspfile=*/"", - /*rspcontent*/ "", - /*restat=*/"", - /*generator=*/true); + cmNinjaRule rule("VERIFY_GLOBS"); + rule.Command = CMakeCmd(); + rule.Command += " -P "; + rule.Command += lg->ConvertToOutputFormat(cm->GetGlobVerifyScript(), + cmOutputConverter::SHELL); + rule.Description = "Re-checking globbed directories..."; + rule.Comment = "Rule for re-checking globbed directories."; + rule.Generator = true; + this->WriteRule(*this->RulesFileStream, rule); } std::string verifyForce = cm->GetGlobVerifyScript() + "_force"; @@ -1507,19 +1488,14 @@ bool cmGlobalNinjaGenerator::WriteTargetCleanAdditional(std::ostream& os) // Write rule { - std::string cmd = CMakeCmd(); - cmd += " -P "; - cmd += lgr->ConvertToOutputFormat(this->NinjaOutputPath(cleanScriptRel), - cmOutputConverter::SHELL); - WriteRule(*this->RulesFileStream, "CLEAN_ADDITIONAL", cmd, - "Cleaning additional files...", - "Rule for cleaning additional files.", - /*depfile=*/"", - /*deptype=*/"", - /*rspfile=*/"", - /*rspcontent*/ "", - /*restat=*/"", - /*generator=*/false); + cmNinjaRule rule("CLEAN_ADDITIONAL"); + rule.Command = CMakeCmd(); + rule.Command += " -P "; + rule.Command += lgr->ConvertToOutputFormat( + this->NinjaOutputPath(cleanScriptRel), cmOutputConverter::SHELL); + rule.Description = "Cleaning additional files..."; + rule.Comment = "Rule for cleaning additional files."; + WriteRule(*this->RulesFileStream, rule); } // Write build @@ -1546,15 +1522,13 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os) // -- Default clean target // Write rule - WriteRule(*this->RulesFileStream, "CLEAN", NinjaCmd() + " -t clean", - "Cleaning all built files...", - "Rule for cleaning all built files.", - /*depfile=*/"", - /*deptype=*/"", - /*rspfile=*/"", - /*rspcontent*/ "", - /*restat=*/"", - /*generator=*/false); + { + cmNinjaRule rule("CLEAN"); + rule.Command = NinjaCmd() + " -t clean"; + rule.Description = "Cleaning all built files..."; + rule.Comment = "Rule for cleaning all built files."; + WriteRule(*this->RulesFileStream, rule); + } // Write build { @@ -1577,15 +1551,13 @@ void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os) void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os) { - WriteRule(*this->RulesFileStream, "HELP", NinjaCmd() + " -t targets", - "All primary targets available:", - "Rule for printing all primary targets available.", - /*depfile=*/"", - /*deptype=*/"", - /*rspfile=*/"", - /*rspcontent*/ "", - /*restat=*/"", - /*generator=*/false); + { + cmNinjaRule rule("HELP"); + rule.Command = NinjaCmd() + " -t targets"; + rule.Description = "All primary targets available:"; + rule.Comment = "Rule for printing all primary targets available."; + WriteRule(*this->RulesFileStream, rule); + } WriteBuild(os, "Print all primary targets available.", "HELP", /*outputs=*/cmNinjaDeps(1, this->NinjaOutputPath("help")), /*implicitOuts=*/cmNinjaDeps(), diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index 47685c2..dcc358b 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -138,18 +138,10 @@ public: const std::string& output); /** - * Write a rule statement named @a name to @a os with the @a comment, - * the mandatory @a command, the @a depfile and the @a description. - * It also writes the variables bound to this rule statement. + * Write a rule statement to @a os. * @warning no escaping of any kind is done here. */ - static void WriteRule(std::ostream& os, const std::string& name, - const std::string& command, - const std::string& description, - const std::string& comment, const std::string& depfile, - const std::string& deptype, const std::string& rspfile, - const std::string& rspcontent, - const std::string& restat, bool generator); + static void WriteRule(std::ostream& os, cmNinjaRule const& rule); /** * Write a variable named @a name to @a os with value @a value and an @@ -273,11 +265,7 @@ public: * Call WriteRule() behind the scene but perform some check before like: * - Do not add twice the same rule. */ - void AddRule(const std::string& name, const std::string& command, - const std::string& description, const std::string& comment, - const std::string& depfile, const std::string& deptype, - const std::string& rspfile, const std::string& rspcontent, - const std::string& restat, bool generator); + void AddRule(cmNinjaRule const& rule); bool HasRule(const std::string& name); diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index 1e4d2ed..6e9e112 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -162,13 +162,8 @@ struct cmNinjaRemoveNoOpCommands void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(bool useResponseFile) { - cmStateEnums::TargetType targetType = this->GetGeneratorTarget()->GetType(); - std::string ruleName = this->LanguageLinkerDeviceRule(); - // Select whether to use a response file for objects. - std::string rspfile; - std::string rspcontent; - - if (!this->GetGlobalGenerator()->HasRule(ruleName)) { + cmNinjaRule rule(this->LanguageLinkerDeviceRule()); + if (!this->GetGlobalGenerator()->HasRule(rule.Name)) { cmRulePlaceholderExpander::RuleVariables vars; vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str(); vars.CMTargetType = @@ -192,16 +187,16 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(bool useResponseFile) } else { responseFlag = "@"; } - rspfile = "$RSP_FILE"; - responseFlag += rspfile; + rule.RspFile = "$RSP_FILE"; + responseFlag += rule.RspFile; // build response file content if (this->GetGlobalGenerator()->IsGCCOnWindows()) { - rspcontent = "$in"; + rule.RspContent = "$in"; } else { - rspcontent = "$in_newline"; + rule.RspContent = "$in_newline"; } - rspcontent += " $LINK_LIBRARIES"; + rule.RspContent += " $LINK_LIBRARIES"; vars.Objects = responseFlag.c_str(); vars.LinkLibraries = ""; } @@ -220,7 +215,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(bool useResponseFile) vars.Manifests = "$MANIFESTS"; std::string langFlags; - if (targetType != cmStateEnums::EXECUTABLE) { + if (this->GetGeneratorTarget()->GetType() != cmStateEnums::EXECUTABLE) { langFlags += "$LANGUAGE_COMPILE_FLAGS $ARCH_FLAGS"; vars.LanguageCompileFlags = langFlags.c_str(); } @@ -247,39 +242,35 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(bool useResponseFile) // If there is no ranlib the command will be ":". Skip it. cmEraseIf(linkCmds, cmNinjaRemoveNoOpCommands()); - std::string linkCmd = - this->GetLocalGenerator()->BuildCommandLine(linkCmds); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(linkCmds); // Write the linker rule with response file if needed. - std::ostringstream comment; - comment << "Rule for linking " << this->TargetLinkLanguage << " " - << this->GetVisibleTypeName() << "."; - std::ostringstream description; - description << "Linking " << this->TargetLinkLanguage << " " - << this->GetVisibleTypeName() << " $TARGET_FILE"; - this->GetGlobalGenerator()->AddRule(ruleName, linkCmd, description.str(), - comment.str(), - /*depfile*/ "", - /*deptype*/ "", rspfile, rspcontent, - /*restat*/ "$RESTAT", - /*generator*/ false); + rule.Comment = "Rule for linking "; + rule.Comment += this->TargetLinkLanguage; + rule.Comment += " "; + rule.Comment += this->GetVisibleTypeName(); + rule.Comment += "."; + rule.Description = "Linking "; + rule.Description += this->TargetLinkLanguage; + rule.Description += " "; + rule.Description += this->GetVisibleTypeName(); + rule.Description += " $TARGET_FILE"; + rule.Restat = "$RESTAT"; + + this->GetGlobalGenerator()->AddRule(rule); } } void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile) { cmStateEnums::TargetType targetType = this->GetGeneratorTarget()->GetType(); - std::string ruleName = this->LanguageLinkerRule(); - - // Select whether to use a response file for objects. - std::string rspfile; - std::string rspcontent; - if (!this->GetGlobalGenerator()->HasRule(ruleName)) { + std::string linkRuleName = this->LanguageLinkerRule(); + if (!this->GetGlobalGenerator()->HasRule(linkRuleName)) { + cmNinjaRule rule(std::move(linkRuleName)); cmRulePlaceholderExpander::RuleVariables vars; vars.CMTargetName = this->GetGeneratorTarget()->GetName().c_str(); - vars.CMTargetType = - cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()); + vars.CMTargetType = cmState::GetTargetTypeName(targetType); vars.Language = this->TargetLinkLanguage.c_str(); @@ -311,17 +302,21 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile) } else { responseFlag = "@"; } - rspfile = "$RSP_FILE"; - responseFlag += rspfile; + rule.RspFile = "$RSP_FILE"; + responseFlag += rule.RspFile; // build response file content if (this->GetGlobalGenerator()->IsGCCOnWindows()) { - rspcontent = "$in"; + rule.RspContent = "$in"; } else { - rspcontent = "$in_newline"; + rule.RspContent = "$in_newline"; + } + rule.RspContent += " $LINK_PATH $LINK_LIBRARIES"; + if (this->TargetLinkLanguage == "Swift") { + vars.SwiftSources = responseFlag.c_str(); + } else { + vars.Objects = responseFlag.c_str(); } - rspcontent += " $LINK_PATH $LINK_LIBRARIES"; - vars.Objects = responseFlag.c_str(); vars.LinkLibraries = ""; } @@ -385,22 +380,21 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile) linkCmds.insert(linkCmds.begin(), "$PRE_LINK"); linkCmds.emplace_back("$POST_BUILD"); - std::string linkCmd = - this->GetLocalGenerator()->BuildCommandLine(linkCmds); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(linkCmds); // Write the linker rule with response file if needed. - std::ostringstream comment; - comment << "Rule for linking " << this->TargetLinkLanguage << " " - << this->GetVisibleTypeName() << "."; - std::ostringstream description; - description << "Linking " << this->TargetLinkLanguage << " " - << this->GetVisibleTypeName() << " $TARGET_FILE"; - this->GetGlobalGenerator()->AddRule(ruleName, linkCmd, description.str(), - comment.str(), - /*depfile*/ "", - /*deptype*/ "", rspfile, rspcontent, - /*restat*/ "$RESTAT", - /*generator*/ false); + rule.Comment = "Rule for linking "; + rule.Comment += this->TargetLinkLanguage; + rule.Comment += " "; + rule.Comment += this->GetVisibleTypeName(); + rule.Comment += "."; + rule.Description = "Linking "; + rule.Description += this->TargetLinkLanguage; + rule.Description += " "; + rule.Description += this->GetVisibleTypeName(); + rule.Description += " $TARGET_FILE"; + rule.Restat = "$RESTAT"; + this->GetGlobalGenerator()->AddRule(rule); } if (this->TargetNames.Output != this->TargetNames.Real && @@ -409,41 +403,28 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile) this->GetLocalGenerator()->ConvertToOutputFormat( cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL); if (targetType == cmStateEnums::EXECUTABLE) { - std::vector<std::string> commandLines; - commandLines.push_back(cmakeCommand + - " -E cmake_symlink_executable $in $out"); - commandLines.emplace_back("$POST_BUILD"); - - this->GetGlobalGenerator()->AddRule( - "CMAKE_SYMLINK_EXECUTABLE", - this->GetLocalGenerator()->BuildCommandLine(commandLines), - "Creating executable symlink $out", - "Rule for creating " - "executable symlink.", - /*depfile*/ "", - /*deptype*/ "", - /*rspfile*/ "", - /*rspcontent*/ "", - /*restat*/ "", - /*generator*/ false); + cmNinjaRule rule("CMAKE_SYMLINK_EXECUTABLE"); + { + std::vector<std::string> cmd; + cmd.push_back(cmakeCommand + " -E cmake_symlink_executable $in $out"); + cmd.emplace_back("$POST_BUILD"); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(cmd); + } + rule.Description = "Creating executable symlink $out"; + rule.Comment = "Rule for creating executable symlink."; + this->GetGlobalGenerator()->AddRule(rule); } else { - std::vector<std::string> commandLines; - commandLines.push_back(cmakeCommand + - " -E cmake_symlink_library $in $SONAME $out"); - commandLines.emplace_back("$POST_BUILD"); - - this->GetGlobalGenerator()->AddRule( - "CMAKE_SYMLINK_LIBRARY", - this->GetLocalGenerator()->BuildCommandLine(commandLines), - "Creating library symlink $out", - "Rule for creating " - "library symlink.", - /*depfile*/ "", - /*deptype*/ "", - /*rspfile*/ "", - /*rspcontent*/ "", - /*restat*/ "", - /*generator*/ false); + cmNinjaRule rule("CMAKE_SYMLINK_LIBRARY"); + { + std::vector<std::string> cmd; + cmd.push_back(cmakeCommand + + " -E cmake_symlink_library $in $SONAME $out"); + cmd.emplace_back("$POST_BUILD"); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(cmd); + } + rule.Description = "Creating library symlink $out"; + rule.Comment = "Rule for creating library symlink."; + this->GetGlobalGenerator()->AddRule(rule); } } } diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index 9652a51..5b8ed90 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -495,9 +495,10 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL); if (explicitPP) { + cmNinjaRule rule(this->LanguagePreprocessRule(lang)); // Explicit preprocessing always uses a depfile. - std::string const ppDeptype; // no deps= for multiple outputs - std::string const ppDepfile = "$DEP_FILE"; + rule.DepType = ""; // no deps= for multiple outputs + rule.DepFile = "$DEP_FILE"; cmRulePlaceholderExpander::RuleVariables ppVars; ppVars.CMTargetName = vars.CMTargetName; @@ -505,7 +506,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) ppVars.Language = vars.Language; ppVars.Object = "$out"; // for RULE_LAUNCH_COMPILE ppVars.PreprocessedSource = "$out"; - ppVars.DependencyFile = ppDepfile.c_str(); + ppVars.DependencyFile = rule.DepFile.c_str(); // Preprocessing uses the original source, // compilation uses preprocessed output. @@ -524,17 +525,15 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) ppVars.Includes = vars.Includes; // If using a response file, move defines, includes, and flags into it. - std::string ppRspFile; - std::string ppRspContent; if (!responseFlag.empty()) { - ppRspFile = "$RSP_FILE"; - ppRspContent = " "; - ppRspContent += ppVars.Defines; - ppRspContent += " "; - ppRspContent += ppVars.Includes; - ppRspContent += " "; - ppRspContent += ppFlags; - ppFlags = responseFlag + ppRspFile; + rule.RspFile = "$RSP_FILE"; + rule.RspContent = " "; + rule.RspContent += ppVars.Defines; + rule.RspContent += " "; + rule.RspContent += ppVars.Includes; + rule.RspContent += " "; + rule.RspContent += ppFlags; + ppFlags = responseFlag + rule.RspFile; ppVars.Defines = ""; ppVars.Includes = ""; } @@ -570,31 +569,25 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) } ppCmds.emplace_back(std::move(ccmd)); } - std::string const ppCmdLine = - this->GetLocalGenerator()->BuildCommandLine(ppCmds); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(ppCmds); // Write the rule for preprocessing file of the given language. - std::string ppComment = "Rule for preprocessing "; - ppComment += lang; - ppComment += " files."; - std::string ppDesc = "Building "; - ppDesc += lang; - ppDesc += " preprocessed $out"; - this->GetGlobalGenerator()->AddRule( - this->LanguagePreprocessRule(lang), ppCmdLine, ppDesc, ppComment, - ppDepfile, ppDeptype, ppRspFile, ppRspContent, - /*restat*/ "", - /*generator*/ false); + rule.Comment = "Rule for preprocessing "; + rule.Comment += lang; + rule.Comment += " files."; + rule.Description = "Building "; + rule.Description += lang; + rule.Description += " preprocessed $out"; + this->GetGlobalGenerator()->AddRule(rule); } if (needDyndep) { // Write the rule for ninja dyndep file generation. - + cmNinjaRule rule(this->LanguageDyndepRule(lang)); // Command line length is almost always limited -> use response file for // dyndep rules - std::string ddRspFile = "$out.rsp"; - std::string ddRspContent = "$in"; - std::string ddCmdLine; + rule.RspFile = "$out.rsp"; + rule.RspContent = "$in"; // Run CMake dependency scanner on the source file (using the preprocessed // source if that was performed). @@ -608,53 +601,49 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) ccmd += lang; ccmd += " --dd=$out "; ccmd += "@"; - ccmd += ddRspFile; + ccmd += rule.RspFile; ddCmds.emplace_back(std::move(ccmd)); } - ddCmdLine = this->GetLocalGenerator()->BuildCommandLine(ddCmds); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(ddCmds); } - std::string ddComment = "Rule to generate ninja dyndep files for "; - ddComment += lang; - ddComment += "."; - std::string ddDesc = "Generating "; - ddDesc += lang; - ddDesc += " dyndep file $out"; - this->GetGlobalGenerator()->AddRule(this->LanguageDyndepRule(lang), - ddCmdLine, ddDesc, ddComment, - /*depfile*/ "", - /*deps*/ "", ddRspFile, ddRspContent, - /*restat*/ "", - /*generator*/ false); + rule.Comment = "Rule to generate ninja dyndep files for "; + rule.Comment += lang; + rule.Comment += "."; + rule.Description = "Generating "; + rule.Description += lang; + rule.Description += " dyndep file $out"; + this->GetGlobalGenerator()->AddRule(rule); } + cmNinjaRule rule(this->LanguageCompilerRule(lang)); // If using a response file, move defines, includes, and flags into it. - std::string rspfile; - std::string rspcontent; if (!responseFlag.empty()) { - rspfile = "$RSP_FILE"; - rspcontent = - std::string(" ") + vars.Defines + " " + vars.Includes + " " + flags; - flags = responseFlag + rspfile; + rule.RspFile = "$RSP_FILE"; + rule.RspContent = " "; + rule.RspContent += vars.Defines; + rule.RspContent += " "; + rule.RspContent += vars.Includes; + rule.RspContent += " "; + rule.RspContent += flags; + flags = responseFlag + rule.RspFile; vars.Defines = ""; vars.Includes = ""; } // Tell ninja dependency format so all deps can be loaded into a database - std::string deptype; - std::string depfile; std::string cldeps; if (explicitPP) { // The explicit preprocessing step will handle dependency scanning. } else if (this->NeedDepTypeMSVC(lang)) { - deptype = "msvc"; - depfile.clear(); + rule.DepType = "msvc"; + rule.DepFile.clear(); flags += " /showIncludes"; } else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_" + lang)) { // For the MS resource compiler we need cmcldeps, but skip dependencies // for source-file try_compile cases because they are always fresh. if (!mf->GetIsSourceFileTryCompile()) { - deptype = "gcc"; - depfile = "$DEP_FILE"; + rule.DepType = "gcc"; + rule.DepFile = "$DEP_FILE"; const std::string cl = mf->GetDefinition("CMAKE_C_COMPILER") ? mf->GetSafeDefinition("CMAKE_C_COMPILER") : mf->GetSafeDefinition("CMAKE_CXX_COMPILER"); @@ -665,8 +654,8 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) cldeps += "\" \"" + cl + "\" "; } } else { - deptype = "gcc"; - depfile = "$DEP_FILE"; + rule.DepType = "gcc"; + rule.DepFile = "$DEP_FILE"; const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang; std::string depfileFlags = mf->GetSafeDefinition(flagsName); if (!depfileFlags.empty()) { @@ -679,7 +668,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) } vars.Flags = flags.c_str(); - vars.DependencyFile = depfile.c_str(); + vars.DependencyFile = rule.DepFile.c_str(); // Rule for compiling object file. std::vector<std::string> compileCmds; @@ -784,21 +773,16 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) vars); } - std::string cmdLine = - this->GetLocalGenerator()->BuildCommandLine(compileCmds); + rule.Command = this->GetLocalGenerator()->BuildCommandLine(compileCmds); // Write the rule for compiling file of the given language. - std::string comment = "Rule for compiling "; - comment += lang; - comment += " files."; - std::string description = "Building "; - description += lang; - description += " object $out"; - this->GetGlobalGenerator()->AddRule(this->LanguageCompilerRule(lang), - cmdLine, description, comment, depfile, - deptype, rspfile, rspcontent, - /*restat*/ "", - /*generator*/ false); + rule.Comment = "Rule for compiling "; + rule.Comment += lang; + rule.Comment += " files."; + rule.Description = "Building "; + rule.Description += lang; + rule.Description += " object $out"; + this->GetGlobalGenerator()->AddRule(rule); } void cmNinjaTargetGenerator::WriteObjectBuildStatements() diff --git a/Source/cmNinjaTypes.h b/Source/cmNinjaTypes.h index 9e962f1..78f3917 100644 --- a/Source/cmNinjaTypes.h +++ b/Source/cmNinjaTypes.h @@ -8,6 +8,7 @@ #include <map> #include <set> #include <string> +#include <utility> #include <vector> enum cmNinjaTargetDepends @@ -20,4 +21,24 @@ typedef std::vector<std::string> cmNinjaDeps; typedef std::set<std::string> cmNinjaOuts; typedef std::map<std::string, std::string> cmNinjaVars; +class cmNinjaRule +{ +public: + cmNinjaRule(std::string name) + : Name(std::move(name)) + { + } + + std::string Name; + std::string Command; + std::string Description; + std::string Comment; + std::string DepFile; + std::string DepType; + std::string RspFile; + std::string RspContent; + std::string Restat; + bool Generator = false; +}; + #endif // ! cmNinjaTypes_h diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx index 2d12964..265daf6 100644 --- a/Source/cmQtAutoGenInitializer.cxx +++ b/Source/cmQtAutoGenInitializer.cxx @@ -407,6 +407,19 @@ bool cmQtAutoGenInitializer::InitCustomTargets() } } } + + // CMAKE_AUTOMOC_RELAXED_MODE deprecation warning + if (this->Moc.Enabled) { + if (cmSystemTools::IsOn( + makefile->GetDefinition("CMAKE_AUTOMOC_RELAXED_MODE"))) { + std::string msg = "AUTOMOC: CMAKE_AUTOMOC_RELAXED_MODE is " + "deprecated an will be removed in the future. "; + msg += "Consider disabling it and converting the target "; + msg += this->Target->GetName(); + msg += " to regular mode."; + makefile->IssueMessage(MessageType::AUTHOR_WARNING, msg); + } + } } // Init rcc specific settings diff --git a/Source/cmQtAutoMocUic.cxx b/Source/cmQtAutoMocUic.cxx index dbabba0..889f47d 100644 --- a/Source/cmQtAutoMocUic.cxx +++ b/Source/cmQtAutoMocUic.cxx @@ -708,7 +708,7 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource( msg += Quoted(sourceFile.FileName); msg += "!\nBetter include "; msg += Quoted(sourceBase + ".moc"); - msg += " for compatibility with strict mode.\n"; + msg += " for compatibility with regular mode.\n"; msg += "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"; Log().WarningFile(GenT::MOC, sourceFile.FileName, msg); } @@ -770,7 +770,7 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource( msg += Quoted(header->FileName); msg += "!\nBetter include "; msg += Quoted("moc_" + incKey.Base + ".cpp"); - msg += " for a compatibility with strict mode.\n"; + msg += " for a compatibility with regular mode.\n"; msg += "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"; Log().WarningFile(GenT::MOC, sourceFile.FileName, msg); } else { @@ -782,7 +782,7 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource( msg += Quoted(header->FileName); msg += "!\nBetter include "; msg += Quoted("moc_" + incKey.Base + ".cpp"); - msg += " for compatibility with strict mode.\n"; + msg += " for compatibility with regular mode.\n"; msg += "This is a CMAKE_AUTOMOC_RELAXED_MODE warning.\n"; Log().WarningFile(GenT::MOC, sourceFile.FileName, msg); } @@ -797,7 +797,7 @@ bool cmQtAutoMocUic::JobEvaluateT::MocEvalSource( // Check if this is the sources own .moc file bool const ownMoc = (incKey.Base == sourceBase); if (!ownMoc) { - // Don't allow <BASE>.moc include other than own in strict mode + // Don't allow <BASE>.moc include other than own in regular mode std::string msg = "The file includes the moc file "; msg += Quoted(incKey.Key); msg += ",\nwhich seems to be the moc file from a different " diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 2453aea..1501481 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -1529,7 +1529,7 @@ bool cmSystemTools::IsPathToFramework(const std::string& path) cmHasLiteralSuffix(path, ".framework")); } -bool cmSystemTools::CreateTar(const char* outFileName, +bool cmSystemTools::CreateTar(const std::string& outFileName, const std::vector<std::string>& files, cmTarCompression compressType, bool verbose, std::string const& mtime, @@ -1537,7 +1537,7 @@ bool cmSystemTools::CreateTar(const char* outFileName, { #if defined(CMAKE_BUILD_WITH_CMAKE) std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); - cmsys::ofstream fout(outFileName, std::ios::out | std::ios::binary); + cmsys::ofstream fout(outFileName.c_str(), std::ios::out | std::ios::binary); if (!fout) { std::string e = "Cannot open output file \""; e += outFileName; @@ -1557,6 +1557,9 @@ bool cmSystemTools::CreateTar(const char* outFileName, case TarCompressXZ: compress = cmArchiveWrite::CompressXZ; break; + case TarCompressZstd: + compress = cmArchiveWrite::CompressZstd; + break; case TarCompressNone: compress = cmArchiveWrite::CompressNone; break; @@ -1757,7 +1760,7 @@ bool copy_data(struct archive* ar, struct archive* aw) # endif } -bool extract_tar(const char* outFileName, +bool extract_tar(const std::string& outFileName, const std::vector<std::string>& files, bool verbose, bool extract) { @@ -1783,7 +1786,7 @@ bool extract_tar(const char* outFileName, } } - int r = cm_archive_read_open_file(a, outFileName, 10240); + int r = cm_archive_read_open_file(a, outFileName.c_str(), 10240); if (r) { ArchiveError("Problem with archive_read_open_file(): ", a); archive_write_free(ext); @@ -1878,7 +1881,7 @@ bool extract_tar(const char* outFileName, } #endif -bool cmSystemTools::ExtractTar(const char* outFileName, +bool cmSystemTools::ExtractTar(const std::string& outFileName, const std::vector<std::string>& files, bool verbose) { @@ -1892,7 +1895,7 @@ bool cmSystemTools::ExtractTar(const char* outFileName, #endif } -bool cmSystemTools::ListTar(const char* outFileName, +bool cmSystemTools::ListTar(const std::string& outFileName, const std::vector<std::string>& files, bool verbose) { diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h index 09a4d13..016c266 100644 --- a/Source/cmSystemTools.h +++ b/Source/cmSystemTools.h @@ -447,17 +447,18 @@ public: TarCompressGZip, TarCompressBZip2, TarCompressXZ, + TarCompressZstd, TarCompressNone }; - static bool ListTar(const char* outFileName, + static bool ListTar(const std::string& outFileName, const std::vector<std::string>& files, bool verbose); - static bool CreateTar(const char* outFileName, + static bool CreateTar(const std::string& outFileName, const std::vector<std::string>& files, cmTarCompression compressType, bool verbose, std::string const& mtime = std::string(), std::string const& format = std::string()); - static bool ExtractTar(const char* inFileName, + static bool ExtractTar(const std::string& inFileName, const std::vector<std::string>& files, bool verbose); // This should be called first thing in main // it will keep child processes from inheriting the diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index 4ddfddd..f4ef45c 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -1043,11 +1043,17 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string> const& args) std::vector<std::string> files; std::string mtime; std::string format; + cmSystemTools::cmTarCompression compress = + cmSystemTools::TarCompressNone; + int nCompress = 0; bool doing_options = true; for (auto const& arg : cmMakeRange(args).advance(4)) { if (doing_options && cmHasLiteralPrefix(arg, "--")) { if (arg == "--") { doing_options = false; + } else if (arg == "--zstd") { + compress = cmSystemTools::TarCompressZstd; + ++nCompress; } else if (cmHasLiteralPrefix(arg, "--mtime=")) { mtime = arg.substr(8); } else if (cmHasLiteralPrefix(arg, "--files-from=")) { @@ -1075,10 +1081,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string> const& args) } } cmSystemTools::cmTarAction action = cmSystemTools::TarActionNone; - cmSystemTools::cmTarCompression compress = - cmSystemTools::TarCompressNone; bool verbose = false; - int nCompress = 0; for (auto flag : flags) { switch (flag) { @@ -1127,7 +1130,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string> const& args) return 1; } if (action == cmSystemTools::TarActionList) { - if (!cmSystemTools::ListTar(outFile.c_str(), files, verbose)) { + if (!cmSystemTools::ListTar(outFile, files, verbose)) { cmSystemTools::Error("Problem listing tar: " + outFile); return 1; } @@ -1136,13 +1139,13 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string> const& args) cmSystemTools::Message("tar: No files or directories specified", "Warning"); } - if (!cmSystemTools::CreateTar(outFile.c_str(), files, compress, - verbose, mtime, format)) { + if (!cmSystemTools::CreateTar(outFile, files, compress, verbose, mtime, + format)) { cmSystemTools::Error("Problem creating tar: " + outFile); return 1; } } else if (action == cmSystemTools::TarActionExtract) { - if (!cmSystemTools::ExtractTar(outFile.c_str(), files, verbose)) { + if (!cmSystemTools::ExtractTar(outFile, files, verbose)) { cmSystemTools::Error("Problem extracting tar: " + outFile); return 1; } diff --git a/Tests/AliasTarget/CMakeLists.txt b/Tests/AliasTarget/CMakeLists.txt index fc70135..6271988 100644 --- a/Tests/AliasTarget/CMakeLists.txt +++ b/Tests/AliasTarget/CMakeLists.txt @@ -7,7 +7,7 @@ set(CMAKE_CXX_STANDARD 98) # Clang/C2 in C++98 mode cannot properly handle some of MSVC headers if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") - set(CMAKE_CXX_STANDARD 11) + set(CMAKE_CXX_STANDARD 14) endif() add_library(foo SHARED empty.cpp) diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index 698cb1d..6901077 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -770,14 +770,14 @@ if(BUILD_TESTING) file(WRITE "${_TEST_DIR}/nightly-cmake.sh" "cd ${_TEST_DIR} ${CMake_BINARY_DIR}/bin/cmake -DCMAKE_CREATE_VERSION=nightly -P ${CMake_SOURCE_DIR}/Utilities/Release/${script} -${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release/upload_release.cmake +${CMake_SOURCE_DIR}/Utilities/Release/push.bash --dir dev -- '${CMake_BUILD_NIGHTLY_RELEASES}' ") add_test(${name} /bin/sh ${_TEST_DIR}/nightly-cmake.sh) if(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY) set_tests_properties (${name} PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT}) endif() endmacro() - if(CMAKE_BUILD_NIGHTLY_RELEASES) + if(CMake_BUILD_NIGHTLY_RELEASES) ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWin32 win32_release.cmake) ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWin64 diff --git a/Tests/COnly/CMakeLists.txt b/Tests/COnly/CMakeLists.txt index b3cc438..3037f13 100644 --- a/Tests/COnly/CMakeLists.txt +++ b/Tests/COnly/CMakeLists.txt @@ -7,7 +7,7 @@ add_library(testc1 STATIC libc1.c) add_library(testc2 SHARED libc2.c) add_executable (COnly conly.c foo.c foo.h) target_link_libraries(COnly testc1 testc2) -if(MSVC_VERSION) +if(MSVC_VERSION AND NOT CMAKE_C_COMPILER_ID STREQUAL Clang OR "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC") set_target_properties(COnly PROPERTIES LINK_FLAGS " /NODEFAULTLIB:\"libcdg.lib\" /NODEFAULTLIB:\"libcmtg.lib\" /NODEFAULTLIB:\"foomsvcrt.lib\" /NODEFAULTLIB:\"libbar.lib\" /NODEFAULTLIB:\"libfooba.lib\"") endif() diff --git a/Tests/CompileOptions/CMakeLists.txt b/Tests/CompileOptions/CMakeLists.txt index 18896bf..1433462 100644 --- a/Tests/CompileOptions/CMakeLists.txt +++ b/Tests/CompileOptions/CMakeLists.txt @@ -43,7 +43,7 @@ else() ) endif() -if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|Borland|Embarcadero") +if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|Borland|Embarcadero" AND NOT "${CMAKE_GENERATOR}" MATCHES "NMake Makefiles") set_property(TARGET CompileOptions APPEND PROPERTY COMPILE_OPTIONS "-DTEST_OCTOTHORPE=\"#\"" ) diff --git a/Tests/Complex/CMakeLists.txt b/Tests/Complex/CMakeLists.txt index 2e41754..fef83f6 100644 --- a/Tests/Complex/CMakeLists.txt +++ b/Tests/Complex/CMakeLists.txt @@ -446,6 +446,11 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND set(CMAKE_CXX_STANDARD 11) endif() +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") + set(CMAKE_CXX_STANDARD 14) +endif() + # # Create the libs and the main exe # diff --git a/Tests/ComplexOneConfig/CMakeLists.txt b/Tests/ComplexOneConfig/CMakeLists.txt index 628cd4e..77baa4c 100644 --- a/Tests/ComplexOneConfig/CMakeLists.txt +++ b/Tests/ComplexOneConfig/CMakeLists.txt @@ -403,6 +403,11 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND set(CMAKE_CXX_STANDARD 11) endif() +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") + set(CMAKE_CXX_STANDARD 14) +endif() + # # Create the libs and the main exe # diff --git a/Tests/EnforceConfig.cmake.in b/Tests/EnforceConfig.cmake.in index f84d180..b7587aa 100644 --- a/Tests/EnforceConfig.cmake.in +++ b/Tests/EnforceConfig.cmake.in @@ -18,7 +18,12 @@ if(NOT CTEST_CONFIGURATION_TYPE) endif() endforeach() if(NOT CTEST_CONFIGURATION_TYPE) - set(CTEST_CONFIGURATION_TYPE NoConfig) + if("@CMAKE_C_COMPILER_ID@;@CMAKE_C_SIMULATE_ID@;@CMAKE_C_COMPILER_FRONTEND_VARIANT@" STREQUAL "Clang;MSVC;GNU") + # A valid configuration is required for this compiler in tests that do not set CMP0091 to NEW. + set(CTEST_CONFIGURATION_TYPE Debug) + else() + set(CTEST_CONFIGURATION_TYPE NoConfig) + endif() endif() message("Guessing configuration ${CTEST_CONFIGURATION_TYPE}") endif() diff --git a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt index cffef5a..b30928d 100644 --- a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt +++ b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt @@ -133,7 +133,9 @@ endif() # for msvc the compiler version determines which c++11 features are available. if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" - OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")) + OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" + AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC" + AND "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" )) if(";${CMAKE_CXX_COMPILE_FEATURES};" MATCHES ";cxx_delegating_constructors;") list(APPEND true_defs EXPECTED_COMPILER_CXX_DELEGATING_CONSTRUCTORS) list(APPEND true_defs EXPECTED_COMPILER_CXX_VARIADIC_TEMPLATES) diff --git a/Tests/Plugin/CMakeLists.txt b/Tests/Plugin/CMakeLists.txt index 8e8fa07..c4540db 100644 --- a/Tests/Plugin/CMakeLists.txt +++ b/Tests/Plugin/CMakeLists.txt @@ -5,6 +5,17 @@ project(Plugin) # We need proper C++98 support from the compiler set(CMAKE_CXX_STANDARD 98) +# Clang/C2 in C++98 mode cannot properly handle some of MSVC headers +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") + set(CMAKE_CXX_STANDARD 11) +endif() + +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") + set(CMAKE_CXX_STANDARD 14) +endif() + # Test per-target output directory properties. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${Plugin_BINARY_DIR}/bin) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${Plugin_BINARY_DIR}/lib/plugin) @@ -29,12 +40,6 @@ include_directories( ${Plugin_SOURCE_DIR}/include ) -# Clang/C2 in C++98 mode cannot properly handle some of MSVC headers -if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND - CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") - set(CMAKE_CXX_STANDARD 11) -endif() - # Create an executable that exports an API for use by plugins. add_executable(example_exe src/example_exe.cxx) set_target_properties(example_exe PROPERTIES diff --git a/Tests/Preprocess/CMakeLists.txt b/Tests/Preprocess/CMakeLists.txt index 8c2cdc9..588af03 100644 --- a/Tests/Preprocess/CMakeLists.txt +++ b/Tests/Preprocess/CMakeLists.txt @@ -28,6 +28,11 @@ endif() if("${CMAKE_GENERATOR}" MATCHES "Visual Studio") set(PP_VS 1) endif() +if(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND + "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" AND + "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") + set(CLANG_GNULIKE_WINDOWS 1) +endif() # Some tests below check the PP_* variables set above. They are meant # to test the case that the build tool is at fault. Other tests below @@ -53,7 +58,7 @@ endif() string(APPEND STRING_EXTRA " ") -if(NOT PP_BORLAND AND NOT PP_WATCOM) +if(NOT PP_BORLAND AND NOT PP_WATCOM AND NOT CLANG_GNULIKE_WINDOWS) # Borland, WMake: multiple spaces # The make tool seems to remove extra whitespace from inside # quoted strings when passing to the compiler. It does not have @@ -70,14 +75,14 @@ if(NOT PP_VS) string(APPEND STRING_EXTRA ",") endif() -if(NOT PP_MINGW) +if(NOT PP_MINGW AND NOT CLANG_GNULIKE_WINDOWS) # MinGW: & # When inside -D"FOO=\"a & b\"" MinGW make wants -D"FOO=\"a "&" b\"" # but it does not like quoted ampersand elsewhere. string(APPEND STRING_EXTRA "&") endif() -if(NOT PP_MINGW) +if(NOT PP_MINGW AND NOT CLANG_GNULIKE_WINDOWS) # MinGW: | # When inside -D"FOO=\"a | b\"" MinGW make wants -D"FOO=\"a "|" b\"" # but it does not like quoted pipe elsewhere. @@ -100,7 +105,8 @@ endif() set(EXPR_OP1 "/") if((NOT MSVC OR PP_NMAKE) AND - NOT CMAKE_C_COMPILER_ID STREQUAL "Intel") + NOT CMAKE_C_COMPILER_ID STREQUAL "Intel" AND + NOT CLANG_GNULIKE_WINDOWS) # MSVC cl, Intel icl: % # When the cl compiler is invoked from the command line then % must # be written %% (to distinguish from %ENV% syntax). However cl does diff --git a/Tests/Preprocess/preprocess.c b/Tests/Preprocess/preprocess.c index 2913f93..958c77e 100644 --- a/Tests/Preprocess/preprocess.c +++ b/Tests/Preprocess/preprocess.c @@ -10,7 +10,8 @@ int check_defines_C(void) { int result = 1; if (strcmp(FILE_STRING, STRING_VALUE) != 0) { - fprintf(stderr, "FILE_STRING has wrong value in C [%s]\n", FILE_STRING); + fprintf(stderr, "FILE_STRING has wrong value in C [%s] vs [%s]\n", + FILE_STRING, STRING_VALUE); result = 0; } if (strcmp(TARGET_STRING, STRING_VALUE) != 0) { diff --git a/Tests/RunCMake/CommandLineTar/RunCMakeTest.cmake b/Tests/RunCMake/CommandLineTar/RunCMakeTest.cmake index 4d1b396..a64af95 100644 --- a/Tests/RunCMake/CommandLineTar/RunCMakeTest.cmake +++ b/Tests/RunCMake/CommandLineTar/RunCMakeTest.cmake @@ -27,6 +27,7 @@ run_cmake(gnutar) run_cmake(gnutar-gz) run_cmake(pax) run_cmake(pax-xz) +run_cmake(pax-zstd) run_cmake(paxr) run_cmake(paxr-bz2) run_cmake(zip) diff --git a/Tests/RunCMake/CommandLineTar/pax-zstd.cmake b/Tests/RunCMake/CommandLineTar/pax-zstd.cmake new file mode 100644 index 0000000..c2a304d --- /dev/null +++ b/Tests/RunCMake/CommandLineTar/pax-zstd.cmake @@ -0,0 +1,10 @@ +set(OUTPUT_NAME "test.tar.zstd") + +set(COMPRESSION_FLAGS cvf) +set(COMPRESSION_OPTIONS --format=pax --zstd) + +set(DECOMPRESSION_FLAGS xvf) + +include(${CMAKE_CURRENT_LIST_DIR}/roundtrip.cmake) + +check_magic("28b52ffd0058" LIMIT 6 HEX) diff --git a/Tests/RunCMake/GenerateExportHeader/GEH.cmake b/Tests/RunCMake/GenerateExportHeader/GEH.cmake index ae9a84c..b3f1c7f 100644 --- a/Tests/RunCMake/GenerateExportHeader/GEH.cmake +++ b/Tests/RunCMake/GenerateExportHeader/GEH.cmake @@ -51,6 +51,11 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND set(CMAKE_CXX_STANDARD 11) endif() +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") + set(CMAKE_CXX_STANDARD 14) +endif() + add_subdirectory(lib_shared_and_static) if(CMAKE_SYSTEM_NAME MATCHES "AIX" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU" diff --git a/Tests/RunCMake/Ninja/greeting.c b/Tests/RunCMake/Ninja/greeting.c index ba3e55b..1124d14 100644 --- a/Tests/RunCMake/Ninja/greeting.c +++ b/Tests/RunCMake/Ninja/greeting.c @@ -6,4 +6,5 @@ __declspec(dllexport) void greeting(void) { printf("Hello world!\n"); + fflush(stdout); } diff --git a/Tests/RunCMake/Ninja/greeting2.c b/Tests/RunCMake/Ninja/greeting2.c index c6ed87d..cc8409c 100644 --- a/Tests/RunCMake/Ninja/greeting2.c +++ b/Tests/RunCMake/Ninja/greeting2.c @@ -3,4 +3,5 @@ void greeting2(void) { printf("Hello world 2!\n"); + fflush(stdout); } diff --git a/Tests/RunCMake/try_compile/LinkOptions.cmake b/Tests/RunCMake/try_compile/LinkOptions.cmake index 488cab1..7fae35c 100644 --- a/Tests/RunCMake/try_compile/LinkOptions.cmake +++ b/Tests/RunCMake/try_compile/LinkOptions.cmake @@ -5,7 +5,9 @@ cmake_policy(SET CMP0054 NEW) set (lib_name "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}lib${CMAKE_STATIC_LIBRARY_SUFFIX}") if (CMAKE_SYSTEM_NAME STREQUAL "Windows") - if (RunCMake_C_COMPILER_ID STREQUAL "MSVC" OR "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") + if (RunCMake_C_COMPILER_ID STREQUAL "MSVC" + OR ("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" AND + NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")) if (CMAKE_SIZEOF_VOID_P EQUAL 4) set (undef_flag /INCLUDE:_func) else() diff --git a/Tests/RunCMake/try_run/LinkOptions.cmake b/Tests/RunCMake/try_run/LinkOptions.cmake index 9939a42..b9a87f3 100644 --- a/Tests/RunCMake/try_run/LinkOptions.cmake +++ b/Tests/RunCMake/try_run/LinkOptions.cmake @@ -5,7 +5,9 @@ cmake_policy(SET CMP0054 NEW) set (lib_name "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}lib${CMAKE_STATIC_LIBRARY_SUFFIX}") if (CMAKE_SYSTEM_NAME STREQUAL "Windows") - if (RunCMake_C_COMPILER_ID STREQUAL "MSVC" OR "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") + if (RunCMake_C_COMPILER_ID STREQUAL "MSVC" + OR ("x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC" AND + NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC")) if (CMAKE_SIZEOF_VOID_P EQUAL 4) set (undef_flag /INCLUDE:_func) else() diff --git a/Tests/Tutorial/Complete/CMakeLists.txt b/Tests/Tutorial/Complete/CMakeLists.txt index 9658e65..1c97545 100644 --- a/Tests/Tutorial/Complete/CMakeLists.txt +++ b/Tests/Tutorial/Complete/CMakeLists.txt @@ -7,8 +7,7 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) option(BUILD_SHARED_LIBS "Build using shared libraries" ON) diff --git a/Tests/Tutorial/Consumer/CMakeLists.txt b/Tests/Tutorial/Consumer/CMakeLists.txt index 4033b4d..5097917 100644 --- a/Tests/Tutorial/Consumer/CMakeLists.txt +++ b/Tests/Tutorial/Consumer/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) if(NOT DEFINED CMAKE_CXX_STANDARD) - set(CMAKE_CXX_STANDARD 11) - set(CMAKE_CXX_STANDARD_REQUIRED True) + set(CMAKE_CXX_STANDARD 14) endif() diff --git a/Tests/Tutorial/Step10/CMakeLists.txt b/Tests/Tutorial/Step10/CMakeLists.txt index b1d46c4..79aadd5 100644 --- a/Tests/Tutorial/Step10/CMakeLists.txt +++ b/Tests/Tutorial/Step10/CMakeLists.txt @@ -7,8 +7,7 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) option(BUILD_SHARED_LIBS "Build using shared libraries" ON) diff --git a/Tests/Tutorial/Step11/CMakeLists.txt b/Tests/Tutorial/Step11/CMakeLists.txt index b1d46c4..79aadd5 100644 --- a/Tests/Tutorial/Step11/CMakeLists.txt +++ b/Tests/Tutorial/Step11/CMakeLists.txt @@ -7,8 +7,7 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) option(BUILD_SHARED_LIBS "Build using shared libraries" ON) diff --git a/Tests/Tutorial/Step2/CMakeLists.txt b/Tests/Tutorial/Step2/CMakeLists.txt index 48afaa3..8e50e7c 100644 --- a/Tests/Tutorial/Step2/CMakeLists.txt +++ b/Tests/Tutorial/Step2/CMakeLists.txt @@ -1,9 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) - +set(CMAKE_CXX_STANDARD 14) # the version number. set(Tutorial_VERSION_MAJOR 1) set(Tutorial_VERSION_MINOR 0) diff --git a/Tests/Tutorial/Step2/directions.txt b/Tests/Tutorial/Step2/directions.txt index bb6662c..48de7a2 100644 --- a/Tests/Tutorial/Step2/directions.txt +++ b/Tests/Tutorial/Step2/directions.txt @@ -44,8 +44,7 @@ the following: cmake_minimum_required(VERSION 3.3) project(Tutorial) - set(CMAKE_CXX_STANDARD 11) - set(CMAKE_CXX_STANDARD_REQUIRED True) + set(CMAKE_CXX_STANDARD 14) # the version number. set(Tutorial_VERSION_MAJOR 1) diff --git a/Tests/Tutorial/Step3/CMakeLists.txt b/Tests/Tutorial/Step3/CMakeLists.txt index f904ea7..baa0a44 100644 --- a/Tests/Tutorial/Step3/CMakeLists.txt +++ b/Tests/Tutorial/Step3/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # should we use our own math functions option(USE_MYMATH "Use tutorial provided math implementation" ON) diff --git a/Tests/Tutorial/Step4/CMakeLists.txt b/Tests/Tutorial/Step4/CMakeLists.txt index 34eab55..9ce60b9 100644 --- a/Tests/Tutorial/Step4/CMakeLists.txt +++ b/Tests/Tutorial/Step4/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # should we use our own math functions option(USE_MYMATH "Use tutorial provided math implementation" ON) diff --git a/Tests/Tutorial/Step5/CMakeLists.txt b/Tests/Tutorial/Step5/CMakeLists.txt index 63e5410..828b9fc 100644 --- a/Tests/Tutorial/Step5/CMakeLists.txt +++ b/Tests/Tutorial/Step5/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # should we use our own math functions option(USE_MYMATH "Use tutorial provided math implementation" ON) diff --git a/Tests/Tutorial/Step6/CMakeLists.txt b/Tests/Tutorial/Step6/CMakeLists.txt index 503a312..a78b0ff 100644 --- a/Tests/Tutorial/Step6/CMakeLists.txt +++ b/Tests/Tutorial/Step6/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # the version number. set(Tutorial_VERSION_MAJOR 1) diff --git a/Tests/Tutorial/Step7/CMakeLists.txt b/Tests/Tutorial/Step7/CMakeLists.txt index f2d3839..33aa039 100644 --- a/Tests/Tutorial/Step7/CMakeLists.txt +++ b/Tests/Tutorial/Step7/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # the version number. set(Tutorial_VERSION_MAJOR 1) diff --git a/Tests/Tutorial/Step8/CMakeLists.txt b/Tests/Tutorial/Step8/CMakeLists.txt index c66bf96..03dc7c0 100644 --- a/Tests/Tutorial/Step8/CMakeLists.txt +++ b/Tests/Tutorial/Step8/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # the version number. set(Tutorial_VERSION_MAJOR 1) diff --git a/Tests/Tutorial/Step9/CMakeLists.txt b/Tests/Tutorial/Step9/CMakeLists.txt index 309d513..4981fe2 100644 --- a/Tests/Tutorial/Step9/CMakeLists.txt +++ b/Tests/Tutorial/Step9/CMakeLists.txt @@ -1,8 +1,7 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 14) # the version number. set(Tutorial_VERSION_MAJOR 1) diff --git a/Utilities/Release/push.bash b/Utilities/Release/push.bash new file mode 100755 index 0000000..1c8efe9 --- /dev/null +++ b/Utilities/Release/push.bash @@ -0,0 +1,70 @@ +#!/usr/bin/env bash + +usage='usage: push.bash [<options>] [--] <dest> + +Options: + + --dir <dir> Specify subdirectory under destination. + Defaults to "v<version>". + --version <ver> CMake <major>.<minor> version number to push. + Defaults to version of source tree. +' + +die() { + echo "$@" 1>&2; exit 1 +} + +cmake_source_dir="${BASH_SOURCE%/*}/../.." + +cmake_version_component() +{ + sed -n " +/^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\))/\1/;p;} +" "${cmake_source_dir}/Source/CMakeVersion.cmake" +} + + +version='' +dir='' +while test "$#" != 0; do + case "$1" in + --dir) shift; dir="$1" ;; + --version) shift; version="$1" ;; + --) shift ; break ;; + -*) die "$usage" ;; + *) break ;; + esac + shift +done +test "$#" = 1 || die "$usage" +readonly dest="$1" + +if test -z "$version"; then + cmake_version_major="$(cmake_version_component MAJOR)" + cmake_version_minor="$(cmake_version_component MINOR)" + version="${cmake_version_major}.${cmake_version_minor}" +fi +readonly version + +if test -z "$dir"; then + dir="v${version}" +fi +readonly dir + +for f in cmake-${version}*; do + if ! test -f "${f}"; then + continue + fi + + echo "pushing '${f}'" + + # Make a copy with a new timestamp and atomically rename into place. + tf="${dest}/${dir}/.tmp.${f}" + df="${dest}/${dir}/${f}" + cp "${f}" "${tf}" + mv "${tf}" "${df}" + + # Pause to give each file a distinct time stamp even with 1s resolution + # so that sorting by time also sorts alphabetically. + sleep 1.1 +done diff --git a/Utilities/Release/upload_release.cmake b/Utilities/Release/upload_release.cmake deleted file mode 100644 index 3613ae7..0000000 --- a/Utilities/Release/upload_release.cmake +++ /dev/null @@ -1,39 +0,0 @@ -set(CTEST_RUN_CURRENT_SCRIPT 0) -if(NOT VERSION) - set(VERSION 3.14) -endif() -if(NOT DEFINED PROJECT_PREFIX) - set(PROJECT_PREFIX cmake-${VERSION}) -endif() -if(NOT DEFINED DIR) - set(DIR "v${VERSION}") -endif() -file(GLOB FILES ${CMAKE_CURRENT_SOURCE_DIR} "${PROJECT_PREFIX}*") -list(SORT FILES) -list(REVERSE FILES) -message("${FILES}") -set(UPLOAD_LOC - "kitware@www.cmake.org:/projects/FTP/pub/cmake/${DIR}") -set(count 0) -foreach(file ${FILES}) - if(NOT IS_DIRECTORY ${file}) - message("upload ${file} ${UPLOAD_LOC}") - execute_process(COMMAND - scp ${file} ${UPLOAD_LOC} - RESULT_VARIABLE result) - if("${result}" GREATER 0) - message(FATAL_ERROR "failed to upload file to ${UPLOAD_LOC}") - endif() - - # Pause to give each upload a distinct (to the nearest second) - # time stamp - if(COMMAND ctest_sleep) - ctest_sleep(2) - endif() - - math(EXPR count "${count} + 1") - endif() -endforeach() -if(${count} EQUAL 0) - message(FATAL_ERROR "Error no files uploaded.") -endif() diff --git a/Utilities/cmjsoncpp/include/json/config.h b/Utilities/cmjsoncpp/include/json/config.h index 34f7314..2cc8462 100644 --- a/Utilities/cmjsoncpp/include/json/config.h +++ b/Utilities/cmjsoncpp/include/json/config.h @@ -79,11 +79,6 @@ # pragma warning(disable : 4786) # endif // MSVC 6 -# if _MSC_VER >= 1500 // MSVC 2008 - /// Indicates that the following function is deprecated. -# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message)) -# endif - #endif // defined(_MSC_VER) // In c++11 the override keyword allows you to explicity define that a function @@ -137,7 +132,10 @@ # elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) # define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__)) # endif // GNUC version -#endif // __clang__ || __GNUC__ +#elif defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008 + /// Indicates that the following function is deprecated. +# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message)) +#endif // __clang__ || __GNUC__ || _MSC_VER #undef JSONCPP_DEPRECATED // no deprecations in CMake copy #if !defined(JSONCPP_DEPRECATED) |