diff options
197 files changed, 1920 insertions, 1055 deletions
diff --git a/.clang-tidy b/.clang-tidy index dace6f1..520b1a9 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -14,7 +14,6 @@ modernize-*,\ -modernize-raw-string-literal,\ -modernize-return-braced-init-list,\ -modernize-use-auto,\ --modernize-use-equals-delete,\ -modernize-use-noexcept,\ -modernize-use-transparent-functors,\ -modernize-use-using,\ @@ -34,4 +33,6 @@ HeaderFilterRegex: 'Source/cm[^/]*\.(h|hxx|cxx)$' CheckOptions: - key: modernize-use-default-member-init.UseAssignment value: '1' + - key: modernize-use-equals-default.IgnoreMacros + value: '0' ... diff --git a/CMakeLists.txt b/CMakeLists.txt index 75a0b52..bd130ec 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -332,6 +332,9 @@ macro (CMAKE_BUILD_UTILITIES) set(KWSYS_USE_ConsoleBuf 1) set(KWSYS_HEADER_ROOT ${CMake_BINARY_DIR}/Source) set(KWSYS_INSTALL_DOC_DIR "${CMAKE_DOC_DIR}") + if(CMake_NO_CXX_STANDARD) + set(KWSYS_CXX_STANDARD "") + endif() add_subdirectory(Source/kwsys) set(kwsys_folder "Utilities/KWSys") CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE} "${kwsys_folder}") diff --git a/Help/command/set.rst b/Help/command/set.rst index dd5ea13..c0e02e2 100644 --- a/Help/command/set.rst +++ b/Help/command/set.rst @@ -86,7 +86,7 @@ Set Environment Variable .. code-block:: cmake - set(ENV{<variable>} <value>...) + set(ENV{<variable>} [<value>]) Sets an :manual:`Environment Variable <cmake-env-variables(7)>` to the given value. @@ -95,3 +95,10 @@ Subsequent calls of ``$ENV{<variable>}`` will return this new value. This command affects only the current CMake process, not the process from which CMake was called, nor the system environment at large, nor the environment of subsequent build or test processes. + +If no argument is given after ``ENV{<variable>}`` or if ``<value>`` is +an empty string, then this command will clear any existing value of the +environment variable. + +Arguments after ``<value>`` are ignored. If extra arguments are found, +then an author warning is issued. diff --git a/Help/dev/source.rst b/Help/dev/source.rst index 6697d38..47baff4 100644 --- a/Help/dev/source.rst +++ b/Help/dev/source.rst @@ -30,16 +30,6 @@ building on older toolchains some constructs need to be handled with care: The ``std::auto_ptr`` template is deprecated in C++11. Use ``std::unique_ptr``. -* Use ``CM_DISABLE_COPY(Class)`` to mark classes as non-copyable. - - The ``CM_DISABLE_COPY`` macro should be used in the private section of a - class to make sure that attempts to copy or assign an instance of the class - lead to compiler errors even if the compiler does not support *deleted* - functions. As a guideline, all polymorphic classes should be made - non-copyable in order to avoid slicing. Classes that are composed of or - derived from non-copyable classes must also be made non-copyable explicitly - with ``CM_DISABLE_COPY``. - Source Tree Layout ================== diff --git a/Help/manual/cmake-variables.7.rst b/Help/manual/cmake-variables.7.rst index de4ce3d..1698734 100644 --- a/Help/manual/cmake-variables.7.rst +++ b/Help/manual/cmake-variables.7.rst @@ -55,7 +55,6 @@ Variables that Provide Information /variable/CMAKE_GENERATOR_INSTANCE /variable/CMAKE_GENERATOR_PLATFORM /variable/CMAKE_GENERATOR_TOOLSET - /variable/CMAKE_HOME_DIRECTORY /variable/CMAKE_IMPORT_LIBRARY_PREFIX /variable/CMAKE_IMPORT_LIBRARY_SUFFIX /variable/CMAKE_JOB_POOL_COMPILE @@ -103,7 +102,6 @@ Variables that Provide Information /variable/CMAKE_VERBOSE_MAKEFILE /variable/CMAKE_VERSION /variable/CMAKE_VS_DEVENV_COMMAND - /variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION /variable/CMAKE_VS_MSBUILD_COMMAND /variable/CMAKE_VS_NsightTegra_VERSION /variable/CMAKE_VS_PLATFORM_NAME @@ -192,7 +190,6 @@ Variables that Change Behavior /variable/CMAKE_MFC_FLAG /variable/CMAKE_MAXIMUM_RECURSION_DEPTH /variable/CMAKE_MODULE_PATH - /variable/CMAKE_NOT_USING_CONFIG_FLAGS /variable/CMAKE_POLICY_DEFAULT_CMPNNNN /variable/CMAKE_POLICY_WARNING_CMPNNNN /variable/CMAKE_PREFIX_PATH @@ -276,6 +273,7 @@ Variables that Describe the System /variable/MSVC_IDE /variable/MSVC_TOOLSET_VERSION /variable/MSVC_VERSION + /variable/MSYS /variable/UNIX /variable/WIN32 /variable/WINCE @@ -451,7 +449,6 @@ Variables for Languages /variable/CMAKE_Fortran_MODDIR_DEFAULT /variable/CMAKE_Fortran_MODDIR_FLAG /variable/CMAKE_Fortran_MODOUT_FLAG - /variable/CMAKE_INTERNAL_PLATFORM_ABI /variable/CMAKE_LANG_ANDROID_TOOLCHAIN_MACHINE /variable/CMAKE_LANG_ANDROID_TOOLCHAIN_PREFIX /variable/CMAKE_LANG_ANDROID_TOOLCHAIN_SUFFIX @@ -459,15 +456,12 @@ Variables for Languages /variable/CMAKE_LANG_ARCHIVE_CREATE /variable/CMAKE_LANG_ARCHIVE_FINISH /variable/CMAKE_LANG_COMPILER - /variable/CMAKE_LANG_COMPILER_ABI - /variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID /variable/CMAKE_LANG_COMPILER_EXTERNAL_TOOLCHAIN /variable/CMAKE_LANG_COMPILER_ID /variable/CMAKE_LANG_COMPILER_LOADED /variable/CMAKE_LANG_COMPILER_PREDEFINES_COMMAND /variable/CMAKE_LANG_COMPILER_TARGET /variable/CMAKE_LANG_COMPILER_VERSION - /variable/CMAKE_LANG_COMPILER_VERSION_INTERNAL /variable/CMAKE_LANG_COMPILE_OBJECT /variable/CMAKE_LANG_CREATE_SHARED_LIBRARY /variable/CMAKE_LANG_CREATE_SHARED_MODULE @@ -496,7 +490,6 @@ Variables for Languages /variable/CMAKE_LANG_LINKER_WRAPPER_FLAG_SEP /variable/CMAKE_LANG_LINK_EXECUTABLE /variable/CMAKE_LANG_OUTPUT_EXTENSION - /variable/CMAKE_LANG_PLATFORM_ID /variable/CMAKE_LANG_SIMULATE_ID /variable/CMAKE_LANG_SIMULATE_VERSION /variable/CMAKE_LANG_SIZEOF_DATA_PTR @@ -608,3 +601,23 @@ Variable Expansion Operators /variable/CACHE /variable/ENV + +Internal Variables +================== + +CMake has many internal variables. Most of them are undocumented. +Some of them, however, were at some point described as normal +variables, and therefore may be encountered in legacy code. They +are subject to change, and not recommended for use in project code. + +.. toctree:: + :maxdepth: 1 + + /variable/CMAKE_HOME_DIRECTORY + /variable/CMAKE_INTERNAL_PLATFORM_ABI + /variable/CMAKE_LANG_COMPILER_ABI + /variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID + /variable/CMAKE_LANG_COMPILER_VERSION_INTERNAL + /variable/CMAKE_LANG_PLATFORM_ID + /variable/CMAKE_NOT_USING_CONFIG_FLAGS + /variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION diff --git a/Help/release/dev/fetchcontent-reduce-boilerplate.rst b/Help/release/dev/fetchcontent-reduce-boilerplate.rst new file mode 100644 index 0000000..6157668 --- /dev/null +++ b/Help/release/dev/fetchcontent-reduce-boilerplate.rst @@ -0,0 +1,8 @@ +fetchcontent-reduce-boilerplate +------------------------------- + +* The FetchContent module gained a new :command:`FetchContent_MakeAvailable` + command. This new command accepts a list of dependency names, which it then + iterates over, populating and adding each one to the main build using the + canonical pattern. This significantly reduces the amount of boilerplate + needed in the project. diff --git a/Help/variable/CMAKE_HOME_DIRECTORY.rst b/Help/variable/CMAKE_HOME_DIRECTORY.rst index fdc5d81..b03d956 100644 --- a/Help/variable/CMAKE_HOME_DIRECTORY.rst +++ b/Help/variable/CMAKE_HOME_DIRECTORY.rst @@ -1,6 +1,9 @@ CMAKE_HOME_DIRECTORY -------------------- -Path to top of source tree. +Path to top of source tree. Same as :variable:`CMAKE_SOURCE_DIR`. -This is the path to the top level of the source tree. +This is an internal cache entry used to locate the source directory +when loading a ``CMakeCache.txt`` from a build tree. It should not +be used in project code. The variable :variable:`CMAKE_SOURCE_DIR` +has the same value and should be preferred. diff --git a/Help/variable/CMAKE_LANG_COMPILER_ID.rst b/Help/variable/CMAKE_LANG_COMPILER_ID.rst index 033e81c..5323880 100644 --- a/Help/variable/CMAKE_LANG_COMPILER_ID.rst +++ b/Help/variable/CMAKE_LANG_COMPILER_ID.rst @@ -17,6 +17,7 @@ include: Clang = LLVM Clang (clang.llvm.org) Cray = Cray Compiler (cray.com) Embarcadero, Borland = Embarcadero (embarcadero.com) + Flang = Flang LLVM Fortran Compiler G95 = G95 Fortran (g95.org) GNU = GNU Compiler Collection (gcc.gnu.org) GHS = Green Hills Software (www.ghs.com) @@ -28,7 +29,6 @@ include: NVIDIA = NVIDIA CUDA Compiler (nvidia.com) OpenWatcom = Open Watcom (openwatcom.org) PGI = The Portland Group (pgroup.com) - Flang = Flang Fortran Compiler PathScale = PathScale (pathscale.com) SDCC = Small Device C Compiler (sdcc.sourceforge.net) SunPro = Oracle Solaris Studio (oracle.com) diff --git a/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst b/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst index be89f85..16fcc03 100644 --- a/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst +++ b/Help/variable/CMAKE_LANG_CREATE_SHARED_LIBRARY.rst @@ -4,4 +4,5 @@ CMAKE_<LANG>_CREATE_SHARED_LIBRARY Rule variable to create a shared library. This is a rule variable that tells CMake how to create a shared -library for the language ``<LANG>``. +library for the language ``<LANG>``. This rule variable is a ``;`` delimited +list of commands to run to perform the linking step. diff --git a/Help/variable/CMAKE_LANG_CREATE_SHARED_MODULE.rst b/Help/variable/CMAKE_LANG_CREATE_SHARED_MODULE.rst index ae5f69d..807229d 100644 --- a/Help/variable/CMAKE_LANG_CREATE_SHARED_MODULE.rst +++ b/Help/variable/CMAKE_LANG_CREATE_SHARED_MODULE.rst @@ -4,4 +4,5 @@ CMAKE_<LANG>_CREATE_SHARED_MODULE Rule variable to create a shared module. This is a rule variable that tells CMake how to create a shared -library for the language ``<LANG>``. +library for the language ``<LANG>``. This rule variable is a ``;`` delimited +list of commands to run. diff --git a/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst b/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst index 50121e2..b4a74eb 100644 --- a/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst +++ b/Help/variable/CMAKE_Swift_LANGUAGE_VERSION.rst @@ -1,5 +1,9 @@ CMAKE_Swift_LANGUAGE_VERSION ---------------------------- -Set to the Swift language version number. If not set, the legacy "2.3" -version is assumed. +Set to the Swift language version number. If not set, the oldest legacy +version known to be available in the host Xcode version is assumed: + +* Swift ``4.0`` for Xcode 10.2 and above. +* Swift ``3.0`` for Xcode 8.3 and above. +* Swift ``2.3`` for Xcode 8.2 and below. diff --git a/Help/variable/MSYS.rst b/Help/variable/MSYS.rst new file mode 100644 index 0000000..25ddc7f --- /dev/null +++ b/Help/variable/MSYS.rst @@ -0,0 +1,4 @@ +MSYS +---- + +``True`` when using the :generator:`MSYS Makefiles` generator. diff --git a/Modules/CMakeDetermineCompilerABI.cmake b/Modules/CMakeDetermineCompilerABI.cmake index e55b83f..fd1d5fb 100644 --- a/Modules/CMakeDetermineCompilerABI.cmake +++ b/Modules/CMakeDetermineCompilerABI.cmake @@ -89,16 +89,18 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src) endif() # Parse implicit include directory for this language, if available. - set (implicit_incdirs "") if(CMAKE_${lang}_VERBOSE_FLAG) + set (implicit_incdirs "") cmake_parse_implicit_include_info("${OUTPUT}" "${lang}" implicit_incdirs log rv) file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log "Parsed ${lang} implicit include dir info from above output: rv=${rv}\n${log}\n\n") - if("${rv}" STREQUAL "done") # update parent if parse completed ok - set(CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES "${implicit_incdirs}" PARENT_SCOPE) + if("${rv}" STREQUAL "done") + # We parsed implicit include directories, so override the default initializer. + set(_CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES_INIT "${implicit_incdirs}") endif() endif() + set(CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES "${_CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES_INIT}" PARENT_SCOPE) # Parse implicit linker information for this language, if available. set(implicit_dirs "") diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index 5eb7ac9..2f84c8e 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -332,6 +332,8 @@ Id flags: ${testflags} ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS} if("${lang}" STREQUAL "Swift") if(CMAKE_Swift_LANGUAGE_VERSION) set(id_lang_version "SWIFT_VERSION = ${CMAKE_Swift_LANGUAGE_VERSION};") + elseif(XCODE_VERSION VERSION_GREATER_EQUAL 10.2) + set(id_lang_version "SWIFT_VERSION = 4.0;") elseif(XCODE_VERSION VERSION_GREATER_EQUAL 8.3) set(id_lang_version "SWIFT_VERSION = 3.0;") else() diff --git a/Modules/CMakeParseImplicitIncludeInfo.cmake b/Modules/CMakeParseImplicitIncludeInfo.cmake index 211406d..21e24b7 100644 --- a/Modules/CMakeParseImplicitIncludeInfo.cmake +++ b/Modules/CMakeParseImplicitIncludeInfo.cmake @@ -27,9 +27,52 @@ function(cmake_parse_implicit_include_line line lang id_var log_var state_var) endif() endif() + # PGI compiler + if("${CMAKE_${lang}_COMPILER_ID}" STREQUAL "PGI") + # pgc++ verbose output differs + if(("${lang}" STREQUAL "C" OR "${lang}" STREQUAL "Fortran") AND + "${line}" MATCHES "^/" AND + "${line}" MATCHES "/pgc |/pgf901 |/pgftnc " AND + "${line}" MATCHES " -cmdline ") + # cmdline has unparsed cmdline, remove it + string(REGEX REPLACE "-cmdline .*" "" line "${line}") + if("${line}" MATCHES " -nostdinc ") + set(rv "") # defined, but empty + else() + string(REGEX MATCHALL " -stdinc ([^ ]*)" incs "${line}") + foreach(inc IN LISTS incs) + string(REGEX REPLACE " -stdinc ([^ ]*)" "\\1" idir "${inc}") + string(REPLACE ":" ";" idir "${idir}") + list(APPEND rv ${idir}) + endforeach() + endif() + if(DEFINED rv) + string(APPEND log " got implicit includes via PGI C/F parser!\n") + else() + string(APPEND log " warning: PGI C/F parse failed!\n") + endif() + elseif("${lang}" STREQUAL "CXX" AND "${line}" MATCHES "^/" AND + "${line}" MATCHES "/pggpp1 " AND "${line}" MATCHES " -I") + # oddly, -Mnostdinc does not get rid of system -I's, at least in + # PGI 18.10.1 ... + string(REGEX MATCHALL " (-I ?)([^ ]*)" incs "${line}") + foreach(inc IN LISTS incs) + string(REGEX REPLACE " (-I ?)([^ ]*)" "\\2" idir "${inc}") + if(NOT "${idir}" STREQUAL "-") # filter out "-I-" + list(APPEND rv "${idir}") + endif() + endforeach() + if(DEFINED rv) + string(APPEND log " got implicit includes via PGI CXX parser!\n") + else() + string(APPEND log " warning: PGI CXX parse failed!\n") + endif() + endif() + endif() + # SunPro compiler if("${CMAKE_${lang}_COMPILER_ID}" STREQUAL "SunPro" AND - "${line}" MATCHES "-D__SUNPRO_C") + ("${line}" MATCHES "-D__SUNPRO_C" OR "${line}" MATCHES "-D__SUNPRO_F") ) string(REGEX MATCHALL " (-I ?)([^ ]*)" incs "${line}") foreach(inc IN LISTS incs) string(REGEX REPLACE " (-I ?)([^ ]*)" "\\2" idir "${inc}") @@ -38,8 +81,10 @@ function(cmake_parse_implicit_include_line line lang id_var log_var state_var) endif() endforeach() if(rv) - # /usr/include appears to be hardwired in - list(APPEND rv "/usr/include") + if ("${lang}" STREQUAL "C" OR "${lang}" STREQUAL "CXX") + # /usr/include appears to be hardwired in + list(APPEND rv "/usr/include") + endif() string(APPEND log " got implicit includes via sunpro parser!\n") else() string(APPEND log " warning: sunpro parse failed!\n") diff --git a/Modules/Compiler/Cray-C.cmake b/Modules/Compiler/Cray-C.cmake index d34154c..b3c96ee 100644 --- a/Modules/Compiler/Cray-C.cmake +++ b/Modules/Compiler/Cray-C.cmake @@ -8,13 +8,13 @@ string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG") string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG") if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1) - set(CMAKE_C90_STANDARD_COMPILE_OPTION -h noc99,conform) - set(CMAKE_C90_EXTENSION_COMPILE_OPTION -h noc99,gnu) - set(CMAKE_C99_STANDARD_COMPILE_OPTION -h c99,conform) - set(CMAKE_C99_EXTENSION_COMPILE_OPTION -h c99,gnu) + set(CMAKE_C90_STANDARD_COMPILE_OPTION "-h noc99,conform") + set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-h noc99,gnu") + set(CMAKE_C99_STANDARD_COMPILE_OPTION "-h c99,conform") + set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-h c99,gnu") if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.5) - set(CMAKE_C11_STANDARD_COMPILE_OPTION -h std=c11,conform) - set(CMAKE_C11_EXTENSION_COMPILE_OPTION -h std=c11,gnu) + set(CMAKE_C11_STANDARD_COMPILE_OPTION "-h std=c11,conform") + set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-h std=c11,gnu") endif () endif () diff --git a/Modules/Compiler/Cray-CXX.cmake b/Modules/Compiler/Cray-CXX.cmake index ff97e92..bbb5718 100644 --- a/Modules/Compiler/Cray-CXX.cmake +++ b/Modules/Compiler/Cray-CXX.cmake @@ -2,21 +2,21 @@ # file Copyright.txt or https://cmake.org/licensing for details. include(Compiler/Cray) -__compiler_cray(C) +__compiler_cray(CXX) string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG") string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG") if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1) - set(CMAKE_CXX98_STANDARD_COMPILE_OPTION -h conform) - set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -h gnu) + set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-h conform") + set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-h gnu") if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.4) - set(CMAKE_CXX11_STANDARD_COMPILE_OPTION -h std=c++11) - set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -h std=c++11,gnu) + set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-h std=c++11") + set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-h std=c++11,gnu") endif() if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.6) - set(CMAKE_CXX14_STANDARD_COMPILE_OPTION -h std=c++14) - set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -h std=c++14,gnu) + set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-h std=c++14") + set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-h std=c++14,gnu") endif () endif () diff --git a/Modules/Compiler/CrayPrgEnv-C.cmake b/Modules/Compiler/CrayPrgEnv-C.cmake index 6b461ce..76aa93b 100644 --- a/Modules/Compiler/CrayPrgEnv-C.cmake +++ b/Modules/Compiler/CrayPrgEnv-C.cmake @@ -4,8 +4,4 @@ endif() set(__craylinux_crayprgenv_c 1) include(Compiler/CrayPrgEnv) -macro(__CrayPrgEnv_setup_C compiler_cmd link_cmd) - __CrayPrgEnv_setup(C - ${CMAKE_ROOT}/Modules/CMakeCCompilerABI.c - ${compiler_cmd} ${link_cmd}) -endmacro() +__CrayPrgEnv_setup(C) diff --git a/Modules/Compiler/CrayPrgEnv-CXX.cmake b/Modules/Compiler/CrayPrgEnv-CXX.cmake index aad85b6..442370e 100644 --- a/Modules/Compiler/CrayPrgEnv-CXX.cmake +++ b/Modules/Compiler/CrayPrgEnv-CXX.cmake @@ -4,8 +4,4 @@ endif() set(__craylinux_crayprgenv_cxx 1) include(Compiler/CrayPrgEnv) -macro(__CrayPrgEnv_setup_CXX compiler_cmd link_cmd) - __CrayPrgEnv_setup(CXX - ${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp - ${compiler_cmd} ${link_cmd}) -endmacro() +__CrayPrgEnv_setup(CXX) diff --git a/Modules/Compiler/CrayPrgEnv-Cray-C.cmake b/Modules/Compiler/CrayPrgEnv-Cray-C.cmake deleted file mode 100644 index 547a4b4..0000000 --- a/Modules/Compiler/CrayPrgEnv-Cray-C.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_cray_c) - return() -endif() -set(__craylinux_crayprgenv_cray_c 1) - -include(Compiler/CrayPrgEnv-C) -__CrayPrgEnv_setup_C("/opt/cray/cce/.*/ccfe" "/opt/cray/cce/.*/ld") diff --git a/Modules/Compiler/CrayPrgEnv-Cray-CXX.cmake b/Modules/Compiler/CrayPrgEnv-Cray-CXX.cmake deleted file mode 100644 index df8452c..0000000 --- a/Modules/Compiler/CrayPrgEnv-Cray-CXX.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_cray_cxx) - return() -endif() -set(__craylinux_crayprgenv_cray_cxx 1) - -include(Compiler/CrayPrgEnv-CXX) -__CrayPrgEnv_setup_CXX("/opt/cray/cce/.*/ccfe" "/opt/cray/cce/.*/ld") diff --git a/Modules/Compiler/CrayPrgEnv-Cray-Fortran.cmake b/Modules/Compiler/CrayPrgEnv-Cray-Fortran.cmake deleted file mode 100644 index 9f46a04..0000000 --- a/Modules/Compiler/CrayPrgEnv-Cray-Fortran.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_cray_fortran) - return() -endif() -set(__craylinux_crayprgenv_cray_fortran 1) - -include(Compiler/CrayPrgEnv-Fortran) -__CrayPrgEnv_setup_Fortran("/opt/cray/cce/.*/ftnfe" "/opt/cray/cce/.*/ld") diff --git a/Modules/Compiler/CrayPrgEnv-Fortran.cmake b/Modules/Compiler/CrayPrgEnv-Fortran.cmake index 9c4d269..85f82d3 100644 --- a/Modules/Compiler/CrayPrgEnv-Fortran.cmake +++ b/Modules/Compiler/CrayPrgEnv-Fortran.cmake @@ -4,8 +4,4 @@ endif() set(__craylinux_crayprgenv_fortran 1) include(Compiler/CrayPrgEnv) -macro(__CrayPrgEnv_setup_Fortran compiler_cmd link_cmd) - __CrayPrgEnv_setup(Fortran - ${CMAKE_ROOT}/Modules/CMakeFortranCompilerABI.F - ${compiler_cmd} ${link_cmd}) -endmacro() +__CrayPrgEnv_setup(Fortran) diff --git a/Modules/Compiler/CrayPrgEnv-GNU-C.cmake b/Modules/Compiler/CrayPrgEnv-GNU-C.cmake deleted file mode 100644 index 248081b..0000000 --- a/Modules/Compiler/CrayPrgEnv-GNU-C.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_gnu_c) - return() -endif() -set(__craylinux_crayprgenv_gnu_c 1) - -include(Compiler/CrayPrgEnv-C) -__CrayPrgEnv_setup_C("/opt/gcc/.*/cc1" "/opt/gcc/.*/collect2") diff --git a/Modules/Compiler/CrayPrgEnv-GNU-CXX.cmake b/Modules/Compiler/CrayPrgEnv-GNU-CXX.cmake deleted file mode 100644 index be4eb6d..0000000 --- a/Modules/Compiler/CrayPrgEnv-GNU-CXX.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_gnu_cxx) - return() -endif() -set(__craylinux_crayprgenv_gnu_cxx 1) - -include(Compiler/CrayPrgEnv-CXX) -__CrayPrgEnv_setup_CXX("/opt/gcc/.*/cc1plus" "/opt/gcc/.*/collect2") diff --git a/Modules/Compiler/CrayPrgEnv-GNU-Fortran.cmake b/Modules/Compiler/CrayPrgEnv-GNU-Fortran.cmake deleted file mode 100644 index 8bd23ff..0000000 --- a/Modules/Compiler/CrayPrgEnv-GNU-Fortran.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_gnu_fortran) - return() -endif() -set(__craylinux_crayprgenv_gnu_fortran 1) - -include(Compiler/CrayPrgEnv-Fortran) -__CrayPrgEnv_setup_Fortran("/opt/gcc/.*/f951" "/opt/gcc/.*/collect2") diff --git a/Modules/Compiler/CrayPrgEnv-Intel-C.cmake b/Modules/Compiler/CrayPrgEnv-Intel-C.cmake deleted file mode 100644 index 83c4e38..0000000 --- a/Modules/Compiler/CrayPrgEnv-Intel-C.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_intel_c) - return() -endif() -set(__craylinux_crayprgenv_intel_c 1) - -include(Compiler/CrayPrgEnv-C) -__CrayPrgEnv_setup_C("/opt/intel/.*/mcpcom" "^ld ") diff --git a/Modules/Compiler/CrayPrgEnv-Intel-CXX.cmake b/Modules/Compiler/CrayPrgEnv-Intel-CXX.cmake deleted file mode 100644 index 3c3c3e6..0000000 --- a/Modules/Compiler/CrayPrgEnv-Intel-CXX.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_intel_cxx) - return() -endif() -set(__craylinux_crayprgenv_intel_cxx 1) - -include(Compiler/CrayPrgEnv-CXX) -__CrayPrgEnv_setup_CXX("/opt/intel/.*/mcpcom" "^ld ") diff --git a/Modules/Compiler/CrayPrgEnv-Intel-Fortran.cmake b/Modules/Compiler/CrayPrgEnv-Intel-Fortran.cmake deleted file mode 100644 index 08a316d..0000000 --- a/Modules/Compiler/CrayPrgEnv-Intel-Fortran.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_intel_fortran) - return() -endif() -set(__craylinux_crayprgenv_intel_fortran 1) - -include(Compiler/CrayPrgEnv-Fortran) -__CrayPrgEnv_setup_Fortran("/opt/intel/.*/fortcom" "^ld ") diff --git a/Modules/Compiler/CrayPrgEnv-PGI-C.cmake b/Modules/Compiler/CrayPrgEnv-PGI-C.cmake deleted file mode 100644 index f45767c..0000000 --- a/Modules/Compiler/CrayPrgEnv-PGI-C.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_pgi_c) - return() -endif() -set(__craylinux_crayprgenv_pgi_c 1) - -include(Compiler/CrayPrgEnv-C) -__CrayPrgEnv_setup_C("/opt/pgi/[^ ]*/pgc" "/usr/bin/ld") diff --git a/Modules/Compiler/CrayPrgEnv-PGI-CXX.cmake b/Modules/Compiler/CrayPrgEnv-PGI-CXX.cmake deleted file mode 100644 index a2a286f..0000000 --- a/Modules/Compiler/CrayPrgEnv-PGI-CXX.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_pgi_cxx) - return() -endif() -set(__craylinux_crayprgenv_pgi_cxx 1) - -include(Compiler/CrayPrgEnv-CXX) -__CrayPrgEnv_setup_CXX("/opt/pgi/[^ ]*/pgcpp" "/usr/bin/ld") diff --git a/Modules/Compiler/CrayPrgEnv-PGI-Fortran.cmake b/Modules/Compiler/CrayPrgEnv-PGI-Fortran.cmake deleted file mode 100644 index f6ba7c0..0000000 --- a/Modules/Compiler/CrayPrgEnv-PGI-Fortran.cmake +++ /dev/null @@ -1,7 +0,0 @@ -if(__craylinux_crayprgenv_pgi_fortran) - return() -endif() -set(__craylinux_crayprgenv_pgi_fortran 1) - -include(Compiler/CrayPrgEnv-Fortran) -__CrayPrgEnv_setup_Fortran("/opt/pgi/[^ ]*/pgf" "/usr/bin/ld") diff --git a/Modules/Compiler/CrayPrgEnv.cmake b/Modules/Compiler/CrayPrgEnv.cmake index 05e3fc7..6c1c770 100644 --- a/Modules/Compiler/CrayPrgEnv.cmake +++ b/Modules/Compiler/CrayPrgEnv.cmake @@ -4,54 +4,7 @@ if(__craylinux_crayprgenv) endif() set(__craylinux_crayprgenv 1) -macro(__cray_extract_args cmd tag_regex out_var make_absolute) - string(REGEX MATCHALL "${tag_regex}" args "${cmd}") - foreach(arg IN LISTS args) - string(REGEX REPLACE "^${tag_regex}$" "\\2" param "${arg}") - if(make_absolute) - get_filename_component(param "${param}" ABSOLUTE) - endif() - list(APPEND ${out_var} ${param}) - endforeach() -endmacro() - -function(__cray_extract_implicit src compiler_cmd link_cmd lang include_dirs_var link_dirs_var link_libs_var) - set(BIN "${CMAKE_PLATFORM_INFO_DIR}/CrayExtractImplicit_${lang}.bin") - execute_process( - COMMAND ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_VERBOSE_FLAG} -o ${BIN} - RESULT_VARIABLE result - OUTPUT_VARIABLE output - ERROR_VARIABLE error - ) - if(EXISTS "${BIN}") - file(REMOVE "${BIN}") - endif() - set(include_dirs) - set(link_dirs) - set(link_libs) - string(REGEX REPLACE "\r?\n" ";" output_lines "${output}\n${error}") - foreach(line IN LISTS output_lines) - if("${line}" MATCHES "${compiler_cmd}") - __cray_extract_args("${line}" " -(I ?|isystem )([^ ]*)" include_dirs 1) - set(processed_include 1) - endif() - if("${line}" MATCHES "${link_cmd}") - __cray_extract_args("${line}" " -(L ?)([^ ]*)" link_dirs 1) - __cray_extract_args("${line}" " -(l ?)([^ ]*)" link_libs 0) - set(processed_link 1) - endif() - if(processed_include AND processed_link) - break() - endif() - endforeach() - - set(${include_dirs_var} "${include_dirs}" PARENT_SCOPE) - set(${link_dirs_var} "${link_dirs}" PARENT_SCOPE) - set(${link_libs_var} "${link_libs}" PARENT_SCOPE) - set(CRAY_${lang}_EXTRACTED_IMPLICIT 1 CACHE INTERNAL "" FORCE) -endfunction() - -macro(__CrayPrgEnv_setup lang test_src compiler_cmd link_cmd) +macro(__CrayPrgEnv_setup lang) if(DEFINED ENV{CRAYPE_VERSION}) message(STATUS "Cray Programming Environment $ENV{CRAYPE_VERSION} ${lang}") elseif(DEFINED ENV{ASYNCPE_VERSION}) @@ -81,12 +34,4 @@ macro(__CrayPrgEnv_setup lang test_src compiler_cmd link_cmd) set(CMAKE_FIND_LIBRARY_SUFFIXES ".a") set(CMAKE_LINK_SEARCH_START_STATIC TRUE) endif() - if(NOT CRAY_${lang}_EXTRACTED_IMPLICIT) - __cray_extract_implicit( - ${test_src} ${compiler_cmd} ${link_cmd} ${lang} - CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES - CMAKE_${lang}_IMPLICIT_LINK_DIRECTORIES - CMAKE_${lang}_IMPLICIT_LINK_LIBRARIES - ) - endif() endmacro() diff --git a/Modules/FetchContent.cmake b/Modules/FetchContent.cmake index c65ae9e..5716b01 100644 --- a/Modules/FetchContent.cmake +++ b/Modules/FetchContent.cmake @@ -20,9 +20,12 @@ configure step to use the content in commands like :command:`add_subdirectory`, :command:`include` or :command:`file` operations. Content population details would normally be defined separately from the -command that performs the actual population. Projects should also -check whether the content has already been populated somewhere else in the -project hierarchy. Typical usage would look something like this: +command that performs the actual population. This separation ensures that +all of the dependency details are defined before anything may try to use those +details to populate content. This is particularly important in more complex +project hierarchies where dependencies may be shared between multiple projects. + +The following shows a typical example of declaring content details: .. code-block:: cmake @@ -32,21 +35,37 @@ project hierarchy. Typical usage would look something like this: GIT_TAG release-1.8.0 ) +For most typical cases, populating the content can then be done with a single +command like so: + +.. code-block:: cmake + + FetchContent_MakeAvailable(googletest) + +The above command not only populates the content, it also adds it to the main +build (if possible) so that the main build can use the populated project's +targets, etc. In some cases, the main project may need to have more precise +control over the population or may be required to explicitly define the +population steps (e.g. if CMake versions earlier than 3.14 need to be +supported). The typical pattern of such custom steps looks like this: + +.. code-block:: cmake + FetchContent_GetProperties(googletest) if(NOT googletest_POPULATED) FetchContent_Populate(googletest) add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR}) endif() -When using the above pattern with a hierarchical project arrangement, -projects at higher levels in the hierarchy are able to define or override -the population details of content specified anywhere lower in the project -hierarchy. The ability to detect whether content has already been -populated ensures that even if multiple child projects want certain content -to be available, the first one to populate it wins. The other child project -can simply make use of the already available content instead of repeating -the population for itself. See the -:ref:`Examples <fetch-content-examples>` section which demonstrates +Regardless of which population method is used, when using the +declare-populate pattern with a hierarchical project arrangement, projects at +higher levels in the hierarchy are able to override the population details of +content specified anywhere lower in the project hierarchy. The ability to +detect whether content has already been populated ensures that even if +multiple child projects want certain content to be available, the first one +to populate it wins. The other child project can simply make use of the +already available content instead of repeating the population for itself. +See the :ref:`Examples <fetch-content-examples>` section which demonstrates this scenario. The ``FetchContent`` module also supports defining and populating @@ -113,6 +132,38 @@ Declaring Content Details Populating The Content ^^^^^^^^^^^^^^^^^^^^^^ +For most common scenarios, population means making content available to the +main build according to previously declared details for that dependency. +There are two main patterns for populating content, one based on calling +:command:`FetchContent_GetProperties` and +:command:`FetchContent_Populate` for more precise control and the other on +calling :command:`FetchContent_MakeAvailable` for a simpler, more automated +approach. The former generally follows this canonical pattern: + +.. _`fetch-content-canonical-pattern`: + +.. code-block:: cmake + + # Check if population has already been performed + FetchContent_GetProperties(<name>) + string(TOLOWER "<name>" lcName) + if(NOT ${lcName}_POPULATED) + # Fetch the content using previously declared details + FetchContent_Populate(<name>) + + # Set custom variables, policies, etc. + # ... + + # Bring the populated content into the build + add_subdirectory(${${lcName}_SOURCE_DIR} ${${lcName}_BINARY_DIR}) + endif() + +The above is such a common pattern that, where no custom steps are needed +between the calls to :command:`FetchContent_Populate` and +:command:`add_subdirectory`, equivalent logic can be obtained by calling +:command:`FetchContent_MakeAvailable` instead (and should be preferred where +it meets the needs of the project). + .. command:: FetchContent_Populate .. code-block:: cmake @@ -309,9 +360,6 @@ Populating The Content on the command line invoking the script. -Retrieve Population Properties -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - .. command:: FetchContent_GetProperties When using saved content details, a call to :command:`FetchContent_Populate` @@ -343,28 +391,65 @@ Retrieve Population Properties FetchContent_GetProperties(foobar) if(NOT foobar_POPULATED) FetchContent_Populate(foobar) - - # Set any custom variables, etc. here, then - # populate the content as part of this build - - add_subdirectory(${foobar_SOURCE_DIR} ${foobar_BINARY_DIR}) + ... endif() The above pattern allows other parts of the overall project hierarchy to re-use the same content and ensure that it is only populated once. +.. command:: FetchContent_MakeAvailable + + .. code-block:: cmake + + FetchContent_MakeAvailable( <name1> [<name2>...] ) + + This command implements the common pattern typically needed for most + dependencies. It iterates over each of the named dependencies in turn + and for each one it loosely follows the same + :ref:`canonical pattern <fetch-content-canonical-pattern>` as + presented at the beginning of this section. One small difference to + that pattern is that it will only call :command:`add_subdirectory` on the + populated content if there is a ``CMakeLists.txt`` file in its top level + source directory. This allows the command to be used for dependencies + that make downloaded content available at a known location but which do + not need or support being added directly to the build. + + .. _`fetch-content-examples`: Examples ^^^^^^^^ -Consider a project hierarchy where ``projA`` is the top level project and it -depends on projects ``projB`` and ``projC``. Both ``projB`` and ``projC`` -can be built standalone and they also both depend on another project -``projD``. For simplicity, this example will assume that all four projects -are available on a company git server. The ``CMakeLists.txt`` of each project -might have sections like the following: +This first fairly straightforward example ensures that some popular testing +frameworks are available to the main build: + +.. code-block:: cmake + + include(FetchContent) + FetchContent_Declare( + googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG release-1.8.0 + ) + FetchContent_Declare( + Catch2 + GIT_REPOSITORY https://github.com/catchorg/Catch2.git + GIT_TAG v2.5.0 + ) + + # After the following call, the CMake targets defined by googletest and + # Catch2 will be defined and available to the rest of the build + FetchContent_MakeAvailable(googletest Catch2) + + +In more complex project hierarchies, the dependency relationships can be more +complicated. Consider a hierarchy where ``projA`` is the top level project and +it depends directly on projects ``projB`` and ``projC``. Both ``projB`` and +``projC`` can be built standalone and they also both depend on another project +``projD``. ``projB`` additionally depends on ``projE``. This example assumes +that all five projects are available on a company git server. The +``CMakeLists.txt`` of each project might have sections like the following: *projA*: @@ -373,31 +458,27 @@ might have sections like the following: include(FetchContent) FetchContent_Declare( projB - GIT_REPOSITORY git@mycompany.com/git/projB.git + GIT_REPOSITORY git@mycompany.com:git/projB.git GIT_TAG 4a89dc7e24ff212a7b5167bef7ab079d ) FetchContent_Declare( projC - GIT_REPOSITORY git@mycompany.com/git/projC.git + GIT_REPOSITORY git@mycompany.com:git/projC.git GIT_TAG 4ad4016bd1d8d5412d135cf8ceea1bb9 ) FetchContent_Declare( projD - GIT_REPOSITORY git@mycompany.com/git/projD.git + GIT_REPOSITORY git@mycompany.com:git/projD.git GIT_TAG origin/integrationBranch ) + FetchContent_Declare( + projE + GIT_REPOSITORY git@mycompany.com:git/projE.git + GIT_TAG origin/release/2.3-rc1 + ) - FetchContent_GetProperties(projB) - if(NOT projb_POPULATED) - FetchContent_Populate(projB) - add_subdirectory(${projb_SOURCE_DIR} ${projb_BINARY_DIR}) - endif() - - FetchContent_GetProperties(projC) - if(NOT projc_POPULATED) - FetchContent_Populate(projC) - add_subdirectory(${projc_SOURCE_DIR} ${projc_BINARY_DIR}) - endif() + # Order is important, see notes in the discussion further below + FetchContent_MakeAvailable(projD projB projC) *projB*: @@ -406,16 +487,16 @@ might have sections like the following: include(FetchContent) FetchContent_Declare( projD - GIT_REPOSITORY git@mycompany.com/git/projD.git + GIT_REPOSITORY git@mycompany.com:git/projD.git GIT_TAG 20b415f9034bbd2a2e8216e9a5c9e632 ) + FetchContent_Declare( + projE + GIT_REPOSITORY git@mycompany.com:git/projE.git + GIT_TAG 68e20f674a48be38d60e129f600faf7d + ) - FetchContent_GetProperties(projD) - if(NOT projd_POPULATED) - FetchContent_Populate(projD) - add_subdirectory(${projd_SOURCE_DIR} ${projd_BINARY_DIR}) - endif() - + FetchContent_MakeAvailable(projD projE) *projC*: @@ -424,48 +505,77 @@ might have sections like the following: include(FetchContent) FetchContent_Declare( projD - GIT_REPOSITORY git@mycompany.com/git/projD.git + GIT_REPOSITORY git@mycompany.com:git/projD.git GIT_TAG 7d9a17ad2c962aa13e2fbb8043fb6b8a ) + # This particular version of projD requires workarounds FetchContent_GetProperties(projD) if(NOT projd_POPULATED) FetchContent_Populate(projD) + + # Copy an additional/replacement file into the populated source + file(COPY someFile.c DESTINATION ${projd_SOURCE_DIR}/src) + add_subdirectory(${projd_SOURCE_DIR} ${projd_BINARY_DIR}) endif() A few key points should be noted in the above: - ``projB`` and ``projC`` define different content details for ``projD``, - but ``projA`` also defines a set of content details for ``projD`` and - because ``projA`` will define them first, the details from ``projB`` and + but ``projA`` also defines a set of content details for ``projD``. + Because ``projA`` will define them first, the details from ``projB`` and ``projC`` will not be used. The override details defined by ``projA`` are not required to match either of those from ``projB`` or ``projC``, but it is up to the higher level project to ensure that the details it does define still make sense for the child projects. -- While ``projA`` defined content details for ``projD``, it did not need - to explicitly call ``FetchContent_Populate(projD)`` itself. Instead, it - leaves that to a child project to do (in this case it will be ``projB`` - since it is added to the build ahead of ``projC``). If ``projA`` needed to - customize how the ``projD`` content was brought into the build as well - (e.g. define some CMake variables before calling - :command:`add_subdirectory` after populating), it would do the call to - ``FetchContent_Populate()``, etc. just as it did for the ``projB`` and - ``projC`` content. For higher level projects, it is usually enough to - just define the override content details and leave the actual population - to the child projects. This saves repeating the same thing at each level - of the project hierarchy unnecessarily. -- Even though ``projA`` is the top level project in this example, it still - checks whether ``projB`` and ``projC`` have already been populated before - going ahead to do those populations. This makes ``projA`` able to be more - easily incorporated as a child of some other higher level project in the - future if required. Always protect a call to - :command:`FetchContent_Populate` with a check to - :command:`FetchContent_GetProperties`, even in what may be considered a top - level project at the time. - - -The following example demonstrates how one might download and unpack a +- In the ``projA`` call to :command:`FetchContent_MakeAvailable`, ``projD`` + is listed ahead of ``projB`` and ``projC`` to ensure that ``projA`` is in + control of how ``projD`` is populated. +- While ``projA`` defines content details for ``projE``, it does not need + to explicitly call ``FetchContent_MakeAvailable(projE)`` or + ``FetchContent_Populate(projD)`` itself. Instead, it leaves that to the + child ``projB``. For higher level projects, it is often enough to just + define the override content details and leave the actual population to the + child projects. This saves repeating the same thing at each level of the + project hierarchy unnecessarily. + + +Projects don't always need to add the populated content to the build. +Sometimes the project just wants to make the downloaded content available at +a predictable location. The next example ensures that a set of standard +company toolchain files (and potentially even the toolchain binaries +themselves) is available early enough to be used for that same build. + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.14) + + include(FetchContent) + FetchContent_Declare( + mycom_toolchains + URL https://intranet.mycompany.com//toolchains_1.3.2.tar.gz + ) + FetchContent_MakeAvailable(mycom_toolchains) + + project(CrossCompileExample) + +The project could be configured to use one of the downloaded toolchains like +so: + +.. code-block:: shell + + cmake -DCMAKE_TOOLCHAIN_FILE=_deps/mycom_toolchains-src/toolchain_arm.cmake /path/to/src + +When CMake processes the ``CMakeLists.txt`` file, it will download and unpack +the tarball into ``_deps/mycompany_toolchains-src`` relative to the build +directory. The :variable:`CMAKE_TOOLCHAIN_FILE` variable is not used until +the :command:`project` command is reached, at which point CMake looks for the +named toolchain file relative to the build directory. Because the tarball has +already been downloaded and unpacked by then, the toolchain file will be in +place, even the very first time that ``cmake`` is run in the build directory. + +Lastly, the following example demonstrates how one might download and unpack a firmware tarball using CMake's :manual:`script mode <cmake(1)>`. The call to :command:`FetchContent_Populate` specifies all the content details and the unpacked firmware will be placed in a ``firmware`` directory below the @@ -921,3 +1031,31 @@ function(FetchContent_Populate contentName) set(${contentNameLower}_POPULATED True PARENT_SCOPE) endfunction() + +# Arguments are assumed to be the names of dependencies that have been +# declared previously and should be populated. It is not an error if +# any of them have already been populated (they will just be skipped in +# that case). The command is implemented as a macro so that the variables +# defined by the FetchContent_GetProperties() and FetchContent_Populate() +# calls will be available to the caller. +macro(FetchContent_MakeAvailable) + + foreach(contentName IN ITEMS ${ARGV}) + string(TOLOWER ${contentName} contentNameLower) + FetchContent_GetProperties(${contentName}) + if(NOT ${contentNameLower}_POPULATED) + FetchContent_Populate(${contentName}) + + # Only try to call add_subdirectory() if the populated content + # can be treated that way. Protecting the call with the check + # allows this function to be used for projects that just want + # to ensure the content exists, such as to provide content at + # a known location. + if(EXISTS ${${contentNameLower}_SOURCE_DIR}/CMakeLists.txt) + add_subdirectory(${${contentNameLower}_SOURCE_DIR} + ${${contentNameLower}_BINARY_DIR}) + endif() + endif() + endforeach() + +endmacro() diff --git a/Modules/FindBLAS.cmake b/Modules/FindBLAS.cmake index b6348fd..0aa4f50 100644 --- a/Modules/FindBLAS.cmake +++ b/Modules/FindBLAS.cmake @@ -13,62 +13,76 @@ list of libraries searched for is taken from the autoconf macro file, acx_blas.m4 (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_blas.html). -This module sets the following variables: - -:: - - BLAS_FOUND - set to true if a library implementing the BLAS interface - is found - BLAS_LINKER_FLAGS - uncached list of required linker flags (excluding -l - and -L). - BLAS_LIBRARIES - uncached list of libraries (using full path name) to - link against to use BLAS (may be empty if compiler implicitly links - BLAS) - BLAS95_LIBRARIES - uncached list of libraries (using full path name) - to link against to use BLAS95 interface - BLAS95_FOUND - set to true if a library implementing the BLAS f95 interface - is found - -The following variables can be used to control this module: - -:: - - BLA_STATIC if set on this determines what kind of linkage we do (static) - BLA_VENDOR if set checks only the specified vendor, if not set checks - all the possibilities - BLA_F95 if set on tries to find the f95 interfaces for BLAS/LAPACK - BLA_PREFER_PKGCONFIG if set pkg-config will be used to search for a BLAS - library first and if one is found that is preferred - -List of vendors (BLA_VENDOR) valid in this module: - -* Goto -* OpenBLAS -* FLAME -* ATLAS PhiPACK -* CXML -* DXML -* SunPerf -* SCSL -* SGIMATH -* IBMESSL -* Intel10_32 (intel mkl v10 32 bit) -* Intel10_64lp (intel mkl v10+ 64 bit, threaded code, lp64 model) -* Intel10_64lp_seq (intel mkl v10+ 64 bit, sequential code, lp64 model) -* Intel10_64ilp (intel mkl v10+ 64 bit, threaded code, ilp64 model) -* Intel10_64ilp_seq (intel mkl v10+ 64 bit, sequential code, ilp64 model) -* Intel (older versions of mkl 32 and 64 bit) -* ACML -* ACML_MP -* ACML_GPU -* Apple -* NAS -* Generic +Input Variables +^^^^^^^^^^^^^^^ + +The following variables may be set to influence this module's behavior: + +``BLA_STATIC`` + if ``ON`` use static linkage + +``BLA_VENDOR`` + If set, checks only the specified vendor, if not set checks all the + possibilities. List of vendors valid in this module: + + * Goto + * OpenBLAS + * FLAME + * ATLAS PhiPACK + * CXML + * DXML + * SunPerf + * SCSL + * SGIMATH + * IBMESSL + * Intel10_32 (intel mkl v10 32 bit) + * Intel10_64lp (intel mkl v10+ 64 bit, threaded code, lp64 model) + * Intel10_64lp_seq (intel mkl v10+ 64 bit, sequential code, lp64 model) + * Intel10_64ilp (intel mkl v10+ 64 bit, threaded code, ilp64 model) + * Intel10_64ilp_seq (intel mkl v10+ 64 bit, sequential code, ilp64 model) + * Intel (obsolete versions of mkl 32 and 64 bit) + * ACML + * ACML_MP + * ACML_GPU + * Apple + * NAS + * Generic + +``BLA_F95`` + if ``ON`` tries to find the BLAS95 interfaces + +``BLA_PREFER_PKGCONFIG`` + if set pkg-config will be used to search for a BLAS library first + and if one is found that is preferred + +Result Variables +^^^^^^^^^^^^^^^^ + +This module defines the following variables: + +``BLAS_FOUND`` + library implementing the BLAS interface is found +``BLAS_LINKER_FLAGS`` + uncached list of required linker flags (excluding -l and -L). +``BLAS_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use BLAS (may be empty if compiler implicitly links BLAS) +``BLAS95_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use BLAS95 interface +``BLAS95_FOUND`` + library implementing the BLAS95 interface is found .. note:: - C/CXX should be enabled to use Intel mkl + C or CXX must be enabled to use Intel MKL + For example, to use Intel MKL libraries and/or Intel compiler: + + .. code-block:: cmake + + set(BLA_VENDOR Intel10_64lp) + find_package(BLAS) #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/CheckFunctionExists.cmake) @@ -167,7 +181,6 @@ macro(Check_Fortran_Libraries LIBRARIES _prefix _name _flags _list _thread) check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS) endif() set(CMAKE_REQUIRED_LIBRARIES) - mark_as_advanced(${_prefix}${_combined_name}_WORKS) set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) endif() if(_libraries_work) diff --git a/Modules/FindLAPACK.cmake b/Modules/FindLAPACK.cmake index 7619664..d6646ea 100644 --- a/Modules/FindLAPACK.cmake +++ b/Modules/FindLAPACK.cmake @@ -14,35 +14,62 @@ The approach follows that taken for the autoconf macro file, acx_lapack.m4 (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html). -This module sets the following variables: - -:: - - LAPACK_FOUND - set to true if a library implementing the LAPACK interface - is found - LAPACK_LINKER_FLAGS - uncached list of required linker flags (excluding -l - and -L). - LAPACK_LIBRARIES - uncached list of libraries (using full path name) to - link against to use LAPACK - LAPACK95_LIBRARIES - uncached list of libraries (using full path name) to - link against to use LAPACK95 - LAPACK95_FOUND - set to true if a library implementing the LAPACK f95 - interface is found - BLA_STATIC if set on this determines what kind of linkage we do (static) - BLA_VENDOR if set checks only the specified vendor, if not set checks - all the possibilities - BLA_F95 if set on tries to find the f95 interfaces for BLAS/LAPACK - -List of vendors (BLA_VENDOR) valid in this module: - -* Intel(mkl) -* OpenBLAS -* FLAME -* ACML -* Apple -* NAS -* Generic - +Input Variables +^^^^^^^^^^^^^^^ + +The following variables may be set to influence this module's behavior: + +``BLA_STATIC`` + if ``ON`` use static linkage + +``BLA_VENDOR`` + If set, checks only the specified vendor, if not set checks all the + possibilities. List of vendors valid in this module: + + * ``Intel10_32`` (intel mkl v10 32 bit) + * ``Intel10_64lp`` (intel mkl v10+ 64 bit, threaded code, lp64 model) + * ``Intel10_64lp_seq`` (intel mkl v10+ 64 bit, sequential code, lp64 model) + * ``Intel10_64ilp`` (intel mkl v10+ 64 bit, threaded code, ilp64 model) + * ``Intel10_64ilp_seq`` (intel mkl v10+ 64 bit, sequential code, ilp64 model) + * ``Intel`` (obsolete versions of mkl 32 and 64 bit) + * ``OpenBLAS`` + * ``FLAME`` + * ``ACML`` + * ``Apple`` + * ``NAS`` + * ``Generic`` + +``BLA_F95`` + if ``ON`` tries to find BLAS95/LAPACK95 + +Result Variables +^^^^^^^^^^^^^^^^ + +This module defines the following variables: + +``LAPACK_FOUND`` + library implementing the LAPACK interface is found +``LAPACK_LINKER_FLAGS`` + uncached list of required linker flags (excluding -l and -L). +``LAPACK_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use LAPACK +``LAPACK95_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use LAPACK95 +``LAPACK95_FOUND`` + library implementing the LAPACK95 interface is found + +.. note:: + + C or CXX must be enabled to use Intel MKL + + For example, to use Intel MKL libraries and/or Intel compiler: + + .. code-block:: cmake + + set(BLA_VENDOR Intel10_64lp) + find_package(LAPACK) #]=======================================================================] set(_lapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) @@ -113,7 +140,7 @@ foreach(_library ${_list}) set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif () else () - if (CMAKE_SYSTEM_NAME STREQUAL "Linux") + if (CMAKE_SYSTEM_NAME STREQUAL "Linux") # for ubuntu's libblas3gf and liblapack3gf packages set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf) endif () @@ -142,7 +169,6 @@ if(_libraries_work) check_fortran_function_exists(${_name} ${_prefix}${_combined_name}_WORKS) endif () set(CMAKE_REQUIRED_LIBRARIES) - mark_as_advanced(${_prefix}${_combined_name}_WORKS) set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) #message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}") endif() diff --git a/Modules/FindXalanC.cmake b/Modules/FindXalanC.cmake index 0eba3d9..3adaa44 100644 --- a/Modules/FindXalanC.cmake +++ b/Modules/FindXalanC.cmake @@ -76,7 +76,7 @@ find_path(XalanC_INCLUDE_DIR DOC "Xalan-C++ include directory") mark_as_advanced(XalanC_INCLUDE_DIR) -if(XalanC_INCLUDE_DIR) +if(XalanC_INCLUDE_DIR AND EXISTS "${XalanC_INCLUDE_DIR}/xalanc/Include/XalanVersion.hpp") _XalanC_GET_VERSION("${XalanC_INCLUDE_DIR}/xalanc/Include/XalanVersion.hpp") endif() diff --git a/Modules/FindXercesC.cmake b/Modules/FindXercesC.cmake index 085fafc..47bfd62 100644 --- a/Modules/FindXercesC.cmake +++ b/Modules/FindXercesC.cmake @@ -74,7 +74,7 @@ find_path(XercesC_INCLUDE_DIR DOC "Xerces-C++ include directory") mark_as_advanced(XercesC_INCLUDE_DIR) -if(XercesC_INCLUDE_DIR) +if(XercesC_INCLUDE_DIR AND EXISTS "${XercesC_INCLUDE_DIR}/xercesc/util/XercesVersion.hpp") _XercesC_GET_VERSION("${XercesC_INCLUDE_DIR}/xercesc/util/XercesVersion.hpp") endif() diff --git a/Modules/Platform/UnixPaths.cmake b/Modules/Platform/UnixPaths.cmake index fc22fce..4ae4514 100644 --- a/Modules/Platform/UnixPaths.cmake +++ b/Modules/Platform/UnixPaths.cmake @@ -69,14 +69,17 @@ list(APPEND CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES ) # Default per-language values. These may be later replaced after -# parsing the implicit link directories from compiler output. -list(APPEND CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES +# parsing the implicit directory information from compiler output. +set(_CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES_INIT + ${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES} /usr/include ) -list(APPEND CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES +set(_CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES_INIT + ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES} /usr/include ) -list(APPEND CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES +set(_CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES_INIT + ${CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES} /usr/include ) diff --git a/Modules/Platform/Windows-Intel-C.cmake b/Modules/Platform/Windows-Intel-C.cmake index 767fec5..06d8f50 100644 --- a/Modules/Platform/Windows-Intel-C.cmake +++ b/Modules/Platform/Windows-Intel-C.cmake @@ -1,2 +1,4 @@ include(Platform/Windows-Intel) __windows_compiler_intel(C) +set(CMAKE_NINJA_DEPTYPE_C intel) # special value handled by CMake +set(CMAKE_DEPFILE_FLAGS_C "-QMMD -QMT <OBJECT> -QMF <DEPFILE>") diff --git a/Modules/Platform/Windows-Intel-CXX.cmake b/Modules/Platform/Windows-Intel-CXX.cmake index 84cd303..666de6e 100644 --- a/Modules/Platform/Windows-Intel-CXX.cmake +++ b/Modules/Platform/Windows-Intel-CXX.cmake @@ -1,3 +1,5 @@ include(Platform/Windows-Intel) set(_COMPILE_CXX " /TP") __windows_compiler_intel(CXX) +set(CMAKE_NINJA_DEPTYPE_CXX intel) # special value handled by CMake +set(CMAKE_DEPFILE_FLAGS_CXX "-QMMD -QMT <OBJECT> -QMF <DEPFILE>") diff --git a/Modules/UseJava.cmake b/Modules/UseJava.cmake index 2bcd28e..5600b4c 100644 --- a/Modules/UseJava.cmake +++ b/Modules/UseJava.cmake @@ -446,7 +446,7 @@ function (__java_copy_file src dest comment) endfunction () function(__java_lcat VAR) - foreach(_line ${ARGN}) + foreach(_line IN LISTS ARGN) string(APPEND ${VAR} "${_line}\n") endforeach() @@ -568,7 +568,7 @@ function(add_jar _TARGET_NAME) set(CMAKE_JAVA_INCLUDE_FLAG_SEP ":") endif() - foreach (JAVA_INCLUDE_DIR ${CMAKE_JAVA_INCLUDE_PATH}) + foreach (JAVA_INCLUDE_DIR IN LISTS CMAKE_JAVA_INCLUDE_PATH) string(APPEND CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_FLAG_SEP}${JAVA_INCLUDE_DIR}") endforeach() @@ -592,7 +592,7 @@ function(add_jar _TARGET_NAME) set(_JAVA_COMPILE_DEPENDS) set(_JAVA_RESOURCE_FILES) set(_JAVA_RESOURCE_FILES_RELATIVE) - foreach(_JAVA_SOURCE_FILE ${_JAVA_SOURCE_FILES}) + foreach(_JAVA_SOURCE_FILE IN LISTS _JAVA_SOURCE_FILES) get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT) get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE) get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH) @@ -607,7 +607,7 @@ function(add_jar _TARGET_NAME) file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL}) string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN) string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN) - if (${_BIN_LEN} LESS ${_SRC_LEN}) + if (_BIN_LEN LESS _SRC_LEN) set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH}) else () set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH}) @@ -637,7 +637,7 @@ function(add_jar _TARGET_NAME) endif () endforeach() - foreach(_JAVA_INCLUDE_JAR ${_add_jar_INCLUDE_JARS}) + foreach(_JAVA_INCLUDE_JAR IN LISTS _add_jar_INCLUDE_JARS) if (TARGET ${_JAVA_INCLUDE_JAR}) get_target_property(_JAVA_JAR_PATH ${_JAVA_INCLUDE_JAR} JAR_FILE) if (_JAVA_JAR_PATH) @@ -705,7 +705,7 @@ function(add_jar _TARGET_NAME) # create the jar file set(_JAVA_JAR_OUTPUT_PATH - ${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME}) + "${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME}") if (CMAKE_JNI_TARGET) add_custom_command( OUTPUT ${_JAVA_JAR_OUTPUT_PATH} @@ -903,15 +903,15 @@ function (find_jar VARIABLE) set(_state "name") - foreach (arg ${ARGN}) - if (${_state} STREQUAL "name") - if (${arg} STREQUAL "VERSIONS") + foreach (arg IN LISTS ARGN) + if (_state STREQUAL "name") + if (arg STREQUAL "VERSIONS") set(_state "versions") - elseif (${arg} STREQUAL "NAMES") + elseif (arg STREQUAL "NAMES") set(_state "names") - elseif (${arg} STREQUAL "PATHS") + elseif (arg STREQUAL "PATHS") set(_state "paths") - elseif (${arg} STREQUAL "DOC") + elseif (arg STREQUAL "DOC") set(_state "doc") else () set(_jar_names ${arg}) @@ -919,22 +919,22 @@ function (find_jar VARIABLE) set(_jar_doc "Finding ${arg} jar") endif () endif () - elseif (${_state} STREQUAL "versions") - if (${arg} STREQUAL "NAMES") + elseif (_state STREQUAL "versions") + if (arg STREQUAL "NAMES") set(_state "names") - elseif (${arg} STREQUAL "PATHS") + elseif (arg STREQUAL "PATHS") set(_state "paths") - elseif (${arg} STREQUAL "DOC") + elseif (arg STREQUAL "DOC") set(_state "doc") else () set(_jar_versions ${_jar_versions} ${arg}) endif () - elseif (${_state} STREQUAL "names") - if (${arg} STREQUAL "VERSIONS") + elseif (_state STREQUAL "names") + if (arg STREQUAL "VERSIONS") set(_state "versions") - elseif (${arg} STREQUAL "PATHS") + elseif (arg STREQUAL "PATHS") set(_state "paths") - elseif (${arg} STREQUAL "DOC") + elseif (arg STREQUAL "DOC") set(_state "doc") else () set(_jar_names ${_jar_names} ${arg}) @@ -942,22 +942,22 @@ function (find_jar VARIABLE) set(_jar_doc "Finding ${arg} jar") endif () endif () - elseif (${_state} STREQUAL "paths") - if (${arg} STREQUAL "VERSIONS") + elseif (_state STREQUAL "paths") + if (arg STREQUAL "VERSIONS") set(_state "versions") - elseif (${arg} STREQUAL "NAMES") + elseif (arg STREQUAL "NAMES") set(_state "names") - elseif (${arg} STREQUAL "DOC") + elseif (arg STREQUAL "DOC") set(_state "doc") else () set(_jar_paths ${_jar_paths} ${arg}) endif () - elseif (${_state} STREQUAL "doc") - if (${arg} STREQUAL "VERSIONS") + elseif (_state STREQUAL "doc") + if (arg STREQUAL "VERSIONS") set(_state "versions") - elseif (${arg} STREQUAL "NAMES") + elseif (arg STREQUAL "NAMES") set(_state "names") - elseif (${arg} STREQUAL "PATHS") + elseif (arg STREQUAL "PATHS") set(_state "paths") else () set(_jar_doc ${arg}) @@ -969,8 +969,8 @@ function (find_jar VARIABLE) message(FATAL_ERROR "find_jar: No name to search for given") endif () - foreach (jar_name ${_jar_names}) - foreach (version ${_jar_versions}) + foreach (jar_name IN LISTS _jar_names) + foreach (version IN LISTS _jar_versions) set(_jar_files ${_jar_files} ${jar_name}-${version}.jar) endforeach () set(_jar_files ${_jar_files} ${jar_name}.jar) @@ -997,252 +997,252 @@ function(create_javadoc _target) set(_state "package") - foreach (arg ${ARGN}) - if (${_state} STREQUAL "package") - if (${arg} STREQUAL "PACKAGES") + foreach (arg IN LISTS ARGN) + if (_state STREQUAL "package") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_packages ${arg}) set(_state "packages") endif () - elseif (${_state} STREQUAL "packages") - if (${arg} STREQUAL "FILES") + elseif (_state STREQUAL "packages") + if (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_packages ${arg}) endif () - elseif (${_state} STREQUAL "files") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "files") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_files ${arg}) endif () - elseif (${_state} STREQUAL "sourcepath") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "sourcepath") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_sourcepath ${arg}) endif () - elseif (${_state} STREQUAL "classpath") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "classpath") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () list(APPEND _javadoc_classpath ${arg}) endif () - elseif (${_state} STREQUAL "installpath") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "installpath") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_installpath ${arg}) endif () - elseif (${_state} STREQUAL "doctitle") + elseif (_state STREQUAL "doctitle") if (${arg} STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_doctitle ${arg}) endif () - elseif (${_state} STREQUAL "windowtitle") + elseif (_state STREQUAL "windowtitle") if (${arg} STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_windowtitle ${arg}) endif () - elseif (${_state} STREQUAL "author") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "author") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_author ${arg}) endif () - elseif (${_state} STREQUAL "use") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "use") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_use ${arg}) endif () - elseif (${_state} STREQUAL "version") - if (${arg} STREQUAL "PACKAGES") + elseif (_state STREQUAL "version") + if (arg STREQUAL "PACKAGES") set(_state "packages") - elseif (${arg} STREQUAL "FILES") + elseif (arg STREQUAL "FILES") set(_state "files") - elseif (${arg} STREQUAL "SOURCEPATH") + elseif (arg STREQUAL "SOURCEPATH") set(_state "sourcepath") - elseif (${arg} STREQUAL "CLASSPATH") + elseif (arg STREQUAL "CLASSPATH") set(_state "classpath") - elseif (${arg} STREQUAL "INSTALLPATH") + elseif (arg STREQUAL "INSTALLPATH") set(_state "installpath") - elseif (${arg} STREQUAL "DOCTITLE") + elseif (arg STREQUAL "DOCTITLE") set(_state "doctitle") - elseif (${arg} STREQUAL "WINDOWTITLE") + elseif (arg STREQUAL "WINDOWTITLE") set(_state "windowtitle") - elseif (${arg} STREQUAL "AUTHOR") + elseif (arg STREQUAL "AUTHOR") set(_state "author") - elseif (${arg} STREQUAL "USE") + elseif (arg STREQUAL "USE") set(_state "use") - elseif (${arg} STREQUAL "VERSION") + elseif (arg STREQUAL "VERSION") set(_state "version") else () set(_javadoc_version ${arg}) @@ -1255,7 +1255,7 @@ function(create_javadoc _target) if (_javadoc_sourcepath) set(_start TRUE) - foreach(_path ${_javadoc_sourcepath}) + foreach(_path IN LISTS _javadoc_sourcepath) if (_start) set(_sourcepath ${_path}) set(_start FALSE) @@ -1268,7 +1268,7 @@ function(create_javadoc _target) if (_javadoc_classpath) set(_start TRUE) - foreach(_path ${_javadoc_classpath}) + foreach(_path IN LISTS _javadoc_classpath) if (_start) set(_classpath ${_path}) set(_start FALSE) @@ -1435,7 +1435,7 @@ function(export_jars) # Set content of generated exports file string(REPLACE ";" " " __targets__ "${_export_jars_TARGETS}") set(__targetdefs__ "") - foreach(_target ${_export_jars_TARGETS}) + foreach(_target IN LISTS _export_jars_TARGETS) get_target_property(_jarpath ${_target} JAR_FILE) get_filename_component(_jarpath ${_jarpath} PATH) __java_export_jar(__targetdefs__ ${_target} "${_jarpath}") @@ -1473,7 +1473,7 @@ function(install_jar_exports) endif() # Determine relative path from installed export file to install prefix - if(IS_ABSOLUTE ${_install_jar_exports_DESTINATION}) + if(IS_ABSOLUTE "${_install_jar_exports_DESTINATION}") file(RELATIVE_PATH _relpath ${_install_jar_exports_DESTINATION} ${CMAKE_INSTALL_PREFIX} @@ -1492,7 +1492,7 @@ function(install_jar_exports) # Set content of generated exports file string(REPLACE ";" " " __targets__ "${_install_jar_exports_TARGETS}") set(__targetdefs__ "set(_prefix \${CMAKE_CURRENT_LIST_DIR}/${_relpath})\n\n") - foreach(_target ${_install_jar_exports_TARGETS}) + foreach(_target IN LISTS _install_jar_exports_TARGETS) get_target_property(_dir ${_target} INSTALL_DESTINATION) __java_export_jar(__targetdefs__ ${_target} "\${_prefix}/${_dir}") endforeach() diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 9e64efa..39a5b3d 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 13) -set(CMake_VERSION_PATCH 20190130) +set(CMake_VERSION_PATCH 20190205) #set(CMake_VERSION_RC 1) diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx index 24d19d9..01e3ea4 100644 --- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx +++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx @@ -286,8 +286,7 @@ protected: content = cmSystemTools::TrimWhitespace(content); std::string source = this->basePath + "/" + content; std::string destination = this->path + "/" + content; - if (!cmSystemTools::CopyFileIfDifferent(source.data(), - destination.data())) { + if (!cmSystemTools::CopyFileIfDifferent(source, destination)) { this->hasErrors = true; } } diff --git a/Source/CPack/cmCPackDragNDropGenerator.cxx b/Source/CPack/cmCPackDragNDropGenerator.cxx index 80b9ef3..013ad81 100644 --- a/Source/CPack/cmCPackDragNDropGenerator.cxx +++ b/Source/CPack/cmCPackDragNDropGenerator.cxx @@ -210,8 +210,7 @@ int cmCPackDragNDropGenerator::PackageFiles() bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source, std::ostringstream& target) { - if (!cmSystemTools::CopyFileIfDifferent(source.str().c_str(), - target.str().c_str())) { + if (!cmSystemTools::CopyFileIfDifferent(source.str(), target.str())) { cmCPackLogger(cmCPackLog::LOG_ERROR, "Error copying " << source.str() << " to " << target.str() << std::endl); diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index 4728f69..57c0545 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -43,12 +43,6 @@ cmCPackGenerator::~cmCPackGenerator() this->MakefileMap = nullptr; } -void cmCPackGeneratorProgress(const char* msg, float prog, void* ptr) -{ - cmCPackGenerator* self = static_cast<cmCPackGenerator*>(ptr); - self->DisplayVerboseOutput(msg, prog); -} - void cmCPackGenerator::DisplayVerboseOutput(const char* msg, float progress) { (void)progress; @@ -392,8 +386,7 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories( std::move(inFileRelative)); } /* If it is not a symlink then do a plain copy */ - else if (!(cmSystemTools::CopyFileIfDifferent(inFile.c_str(), - filePath.c_str()) && + else if (!(cmSystemTools::CopyFileIfDifferent(inFile, filePath) && cmSystemTools::CopyFileTime(inFile.c_str(), filePath.c_str()))) { cmCPackLogger(cmCPackLog::LOG_ERROR, @@ -696,7 +689,9 @@ int cmCPackGenerator::InstallCMakeProject( cm.SetHomeOutputDirectory(""); cm.GetCurrentSnapshot().SetDefaultDefinitions(); cm.AddCMakePaths(); - cm.SetProgressCallback(cmCPackGeneratorProgress, this); + cm.SetProgressCallback([this](const char* msg, float prog) { + this->DisplayVerboseOutput(msg, prog); + }); cm.SetTrace(this->Trace); cm.SetTraceExpand(this->TraceExpand); cmGlobalGenerator gg(&cm); @@ -1077,8 +1072,7 @@ int cmCPackGenerator::DoPackage() << (tempPackageFileName ? tempPackageFileName : "(NULL)") << " to " << (packageFileName ? packageFileName : "(NULL)") << std::endl); - if (!cmSystemTools::CopyFileIfDifferent(tempPackageFileName, - packageFileName)) { + if (!cmSystemTools::CopyFileIfDifferent(pkgFileName, tmpPF)) { cmCPackLogger( cmCPackLog::LOG_ERROR, "Problem copying the package: " diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index d4c867b..0413422 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -90,12 +90,8 @@ int cpackDefinitionArgument(const char* argument, const char* cValue, return 1; } -static void cpackProgressCallback(const char* message, float progress, - void* clientdata) +static void cpackProgressCallback(const char* message, float /*unused*/) { - (void)progress; - (void)clientdata; - std::cout << "-- " << message << std::endl; } @@ -212,7 +208,7 @@ int main(int argc, char const* const* argv) cmake cminst(cmake::RoleScript, cmState::CPack); cminst.SetHomeDirectory(""); cminst.SetHomeOutputDirectory(""); - cminst.SetProgressCallback(cpackProgressCallback, nullptr); + cminst.SetProgressCallback(cpackProgressCallback); cminst.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator cmgg(&cminst); cmMakefile globalMF(&cmgg, cminst.GetCurrentSnapshot()); diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx index 312d126..2fd4c7a 100644 --- a/Source/CTest/cmCTestBuildAndTestHandler.cxx +++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx @@ -109,27 +109,6 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring, return 0; } -void CMakeMessageCallback(const char* m, const char* /*unused*/, - bool& /*unused*/, void* s) -{ - std::string* out = static_cast<std::string*>(s); - *out += m; - *out += "\n"; -} - -void CMakeProgressCallback(const char* msg, float /*unused*/, void* s) -{ - std::string* out = static_cast<std::string*>(s); - *out += msg; - *out += "\n"; -} - -void CMakeOutputCallback(const char* m, size_t len, void* s) -{ - std::string* out = static_cast<std::string*>(s); - out->append(m, len); -} - class cmCTestBuildAndTestCaptureRAII { cmake& CM; @@ -138,17 +117,27 @@ public: cmCTestBuildAndTestCaptureRAII(cmake& cm, std::string& s) : CM(cm) { - cmSystemTools::SetMessageCallback(CMakeMessageCallback, &s); - cmSystemTools::SetStdoutCallback(CMakeOutputCallback, &s); - cmSystemTools::SetStderrCallback(CMakeOutputCallback, &s); - this->CM.SetProgressCallback(CMakeProgressCallback, &s); + cmSystemTools::SetMessageCallback( + [&s](const char* msg, const char* /*unused*/) { + s += msg; + s += "\n"; + }); + + cmSystemTools::SetStdoutCallback([&s](std::string const& m) { s += m; }); + cmSystemTools::SetStderrCallback([&s](std::string const& m) { s += m; }); + + this->CM.SetProgressCallback([&s](const char* msg, float /*unused*/) { + s += msg; + s += "\n"; + }); } + ~cmCTestBuildAndTestCaptureRAII() { - this->CM.SetProgressCallback(nullptr, nullptr); - cmSystemTools::SetStderrCallback(nullptr, nullptr); - cmSystemTools::SetStdoutCallback(nullptr, nullptr); - cmSystemTools::SetMessageCallback(nullptr, nullptr); + this->CM.SetProgressCallback(nullptr); + cmSystemTools::SetStderrCallback(nullptr); + cmSystemTools::SetStdoutCallback(nullptr); + cmSystemTools::SetMessageCallback(nullptr); } }; diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index 84f3652..33b8b4a 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -263,15 +263,6 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg) return retVal; } -static void ctestScriptProgressCallback(const char* m, float /*unused*/, - void* cd) -{ - cmCTest* ctest = static_cast<cmCTest*>(cd); - if (m && *m) { - cmCTestLog(ctest, HANDLER_OUTPUT, "-- " << m << std::endl); - } -} - void cmCTestScriptHandler::CreateCMake() { // create a cmake instance to read the configuration script @@ -297,7 +288,11 @@ void cmCTestScriptHandler::CreateCMake() this->ParentMakefile->GetRecursionDepth()); } - this->CMake->SetProgressCallback(ctestScriptProgressCallback, this->CTest); + this->CMake->SetProgressCallback([this](const char* m, float /*unused*/) { + if (m && *m) { + cmCTestLog(this->CTest, HANDLER_OUTPUT, "-- " << m << std::endl); + } + }); this->AddCTestCommand("ctest_build", new cmCTestBuildCommand); this->AddCTestCommand("ctest_configure", new cmCTestConfigureCommand); diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx index dbf4a28..f2982a6 100644 --- a/Source/CursesDialog/ccmake.cxx +++ b/Source/CursesDialog/ccmake.cxx @@ -65,13 +65,6 @@ void onsig(int /*unused*/) } } -void CMakeMessageHandler(const char* message, const char* title, - bool& /*unused*/, void* clientData) -{ - cmCursesForm* self = static_cast<cmCursesForm*>(clientData); - self->AddError(message, title); -} - int main(int argc, char const* const* argv) { cmsys::Encoding::CommandLineArguments encoding_args = @@ -156,7 +149,10 @@ int main(int argc, char const* const* argv) return 1; } - cmSystemTools::SetMessageCallback(CMakeMessageHandler, myform); + cmSystemTools::SetMessageCallback( + [myform](const char* message, const char* title) { + myform->AddError(message, title); + }); cmCursesForm::CurrentForm = myform; diff --git a/Source/CursesDialog/cmCursesBoolWidget.h b/Source/CursesDialog/cmCursesBoolWidget.h index cdb9478..8c96256 100644 --- a/Source/CursesDialog/cmCursesBoolWidget.h +++ b/Source/CursesDialog/cmCursesBoolWidget.h @@ -12,11 +12,12 @@ class cmCursesMainForm; class cmCursesBoolWidget : public cmCursesWidget { - CM_DISABLE_COPY(cmCursesBoolWidget) - public: cmCursesBoolWidget(int width, int height, int left, int top); + cmCursesBoolWidget(cmCursesBoolWidget const&) = delete; + cmCursesBoolWidget& operator=(cmCursesBoolWidget const&) = delete; + // Description: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h index 54b2f1f..0a69d3a 100644 --- a/Source/CursesDialog/cmCursesCacheEntryComposite.h +++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h @@ -13,14 +13,17 @@ class cmake; class cmCursesCacheEntryComposite { - CM_DISABLE_COPY(cmCursesCacheEntryComposite) - public: cmCursesCacheEntryComposite(const std::string& key, int labelwidth, int entrywidth); cmCursesCacheEntryComposite(const std::string& key, cmake* cm, bool isNew, int labelwidth, int entrywidth); ~cmCursesCacheEntryComposite(); + + cmCursesCacheEntryComposite(cmCursesCacheEntryComposite const&) = delete; + cmCursesCacheEntryComposite& operator=(cmCursesCacheEntryComposite const&) = + delete; + const char* GetValue(); friend class cmCursesMainForm; diff --git a/Source/CursesDialog/cmCursesDummyWidget.h b/Source/CursesDialog/cmCursesDummyWidget.h index c509ae7..07b7288 100644 --- a/Source/CursesDialog/cmCursesDummyWidget.h +++ b/Source/CursesDialog/cmCursesDummyWidget.h @@ -12,11 +12,12 @@ class cmCursesMainForm; class cmCursesDummyWidget : public cmCursesWidget { - CM_DISABLE_COPY(cmCursesDummyWidget) - public: cmCursesDummyWidget(int width, int height, int left, int top); + cmCursesDummyWidget(cmCursesDummyWidget const&) = delete; + cmCursesDummyWidget& operator=(cmCursesDummyWidget const&) = delete; + // Description: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was diff --git a/Source/CursesDialog/cmCursesFilePathWidget.h b/Source/CursesDialog/cmCursesFilePathWidget.h index 0a30402..3f71259 100644 --- a/Source/CursesDialog/cmCursesFilePathWidget.h +++ b/Source/CursesDialog/cmCursesFilePathWidget.h @@ -9,10 +9,11 @@ class cmCursesFilePathWidget : public cmCursesPathWidget { - CM_DISABLE_COPY(cmCursesFilePathWidget) - public: cmCursesFilePathWidget(int width, int height, int left, int top); + + cmCursesFilePathWidget(cmCursesFilePathWidget const&) = delete; + cmCursesFilePathWidget& operator=(cmCursesFilePathWidget const&) = delete; }; #endif // cmCursesFilePathWidget_h diff --git a/Source/CursesDialog/cmCursesForm.h b/Source/CursesDialog/cmCursesForm.h index 249b349..ddb67de 100644 --- a/Source/CursesDialog/cmCursesForm.h +++ b/Source/CursesDialog/cmCursesForm.h @@ -11,12 +11,13 @@ class cmCursesForm { - CM_DISABLE_COPY(cmCursesForm) - public: cmCursesForm(); virtual ~cmCursesForm(); + cmCursesForm(cmCursesForm const&) = delete; + cmCursesForm& operator=(cmCursesForm const&) = delete; + // Description: // Handle user input. virtual void HandleInput() = 0; diff --git a/Source/CursesDialog/cmCursesLabelWidget.h b/Source/CursesDialog/cmCursesLabelWidget.h index aab559b..2ee9cfc 100644 --- a/Source/CursesDialog/cmCursesLabelWidget.h +++ b/Source/CursesDialog/cmCursesLabelWidget.h @@ -14,13 +14,14 @@ class cmCursesMainForm; class cmCursesLabelWidget : public cmCursesWidget { - CM_DISABLE_COPY(cmCursesLabelWidget) - public: cmCursesLabelWidget(int width, int height, int left, int top, const std::string& name); ~cmCursesLabelWidget() override; + cmCursesLabelWidget(cmCursesLabelWidget const&) = delete; + cmCursesLabelWidget& operator=(cmCursesLabelWidget const&) = delete; + // Description: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was diff --git a/Source/CursesDialog/cmCursesLongMessageForm.h b/Source/CursesDialog/cmCursesLongMessageForm.h index 2bcc15a..466b4e1 100644 --- a/Source/CursesDialog/cmCursesLongMessageForm.h +++ b/Source/CursesDialog/cmCursesLongMessageForm.h @@ -13,13 +13,14 @@ class cmCursesLongMessageForm : public cmCursesForm { - CM_DISABLE_COPY(cmCursesLongMessageForm) - public: cmCursesLongMessageForm(std::vector<std::string> const& messages, const char* title); ~cmCursesLongMessageForm() override; + cmCursesLongMessageForm(cmCursesLongMessageForm const&) = delete; + cmCursesLongMessageForm& operator=(cmCursesLongMessageForm const&) = delete; + // Description: // Handle user input. void HandleInput() override; diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx index 188ad69..8ca7802 100644 --- a/Source/CursesDialog/cmCursesMainForm.cxx +++ b/Source/CursesDialog/cmCursesMainForm.cxx @@ -506,12 +506,8 @@ void cmCursesMainForm::UpdateStatusBar(const char* message) pos_form_cursor(this->Form); } -void cmCursesMainForm::UpdateProgress(const char* msg, float prog, void* vp) +void cmCursesMainForm::UpdateProgress(const char* msg, float prog) { - cmCursesMainForm* cm = static_cast<cmCursesMainForm*>(vp); - if (!cm) { - return; - } char tmp[1024]; const char* cmsg = tmp; if (prog >= 0) { @@ -519,8 +515,8 @@ void cmCursesMainForm::UpdateProgress(const char* msg, float prog, void* vp) } else { cmsg = msg; } - cm->UpdateStatusBar(cmsg); - cm->PrintKeys(1); + this->UpdateStatusBar(cmsg); + this->PrintKeys(1); curses_move(1, 1); touchwin(stdscr); refresh(); @@ -536,8 +532,8 @@ int cmCursesMainForm::Configure(int noconfigure) this->PrintKeys(1); touchwin(stdscr); refresh(); - this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress, - this); + this->CMakeInstance->SetProgressCallback( + [this](const char* msg, float prog) { this->UpdateProgress(msg, prog); }); // always save the current gui values to disk this->FillCacheManagerFromUI(); @@ -560,7 +556,7 @@ int cmCursesMainForm::Configure(int noconfigure) } else { retVal = this->CMakeInstance->Configure(); } - this->CMakeInstance->SetProgressCallback(nullptr, nullptr); + this->CMakeInstance->SetProgressCallback(nullptr); keypad(stdscr, true); /* Use key symbols as KEY_DOWN */ @@ -606,8 +602,8 @@ int cmCursesMainForm::Generate() this->PrintKeys(1); touchwin(stdscr); refresh(); - this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress, - this); + this->CMakeInstance->SetProgressCallback( + [this](const char* msg, float prog) { this->UpdateProgress(msg, prog); }); // Get rid of previous errors this->Errors = std::vector<std::string>(); @@ -615,7 +611,7 @@ int cmCursesMainForm::Generate() // run the generate process int retVal = this->CMakeInstance->Generate(); - this->CMakeInstance->SetProgressCallback(nullptr, nullptr); + this->CMakeInstance->SetProgressCallback(nullptr); keypad(stdscr, true); /* Use key symbols as KEY_DOWN */ if (retVal != 0 || !this->Errors.empty()) { diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h index 824025b..cc6482f 100644 --- a/Source/CursesDialog/cmCursesMainForm.h +++ b/Source/CursesDialog/cmCursesMainForm.h @@ -23,12 +23,13 @@ class cmake; */ class cmCursesMainForm : public cmCursesForm { - CM_DISABLE_COPY(cmCursesMainForm) - public: cmCursesMainForm(std::vector<std::string> args, int initwidth); ~cmCursesMainForm() override; + cmCursesMainForm(cmCursesMainForm const&) = delete; + cmCursesMainForm& operator=(cmCursesMainForm const&) = delete; + /** * Set the widgets which represent the cache entries. */ @@ -101,8 +102,7 @@ public: /** * Progress callback */ - static void UpdateProgressOld(const char* msg, float prog, void*); - static void UpdateProgress(const char* msg, float prog, void*); + void UpdateProgress(const char* msg, float prog); protected: // Copy the cache values from the user interface to the actual diff --git a/Source/CursesDialog/cmCursesOptionsWidget.h b/Source/CursesDialog/cmCursesOptionsWidget.h index 3e50e2d..0128d6a 100644 --- a/Source/CursesDialog/cmCursesOptionsWidget.h +++ b/Source/CursesDialog/cmCursesOptionsWidget.h @@ -15,11 +15,12 @@ class cmCursesMainForm; class cmCursesOptionsWidget : public cmCursesWidget { - CM_DISABLE_COPY(cmCursesOptionsWidget) - public: cmCursesOptionsWidget(int width, int height, int left, int top); + cmCursesOptionsWidget(cmCursesOptionsWidget const&) = delete; + cmCursesOptionsWidget& operator=(cmCursesOptionsWidget const&) = delete; + // Description: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was diff --git a/Source/CursesDialog/cmCursesPathWidget.h b/Source/CursesDialog/cmCursesPathWidget.h index bfa0ea3..1eace03 100644 --- a/Source/CursesDialog/cmCursesPathWidget.h +++ b/Source/CursesDialog/cmCursesPathWidget.h @@ -14,11 +14,12 @@ class cmCursesMainForm; class cmCursesPathWidget : public cmCursesStringWidget { - CM_DISABLE_COPY(cmCursesPathWidget) - public: cmCursesPathWidget(int width, int height, int left, int top); + cmCursesPathWidget(cmCursesPathWidget const&) = delete; + cmCursesPathWidget& operator=(cmCursesPathWidget const&) = delete; + /** * This method is called when different keys are pressed. The * subclass can have a special implementation handler for this. diff --git a/Source/CursesDialog/cmCursesStringWidget.h b/Source/CursesDialog/cmCursesStringWidget.h index 90310f6..021515b 100644 --- a/Source/CursesDialog/cmCursesStringWidget.h +++ b/Source/CursesDialog/cmCursesStringWidget.h @@ -20,11 +20,12 @@ class cmCursesMainForm; class cmCursesStringWidget : public cmCursesWidget { - CM_DISABLE_COPY(cmCursesStringWidget) - public: cmCursesStringWidget(int width, int height, int left, int top); + cmCursesStringWidget(cmCursesStringWidget const&) = delete; + cmCursesStringWidget& operator=(cmCursesStringWidget const&) = delete; + /** * Handle user input. Called by the container of this widget * when this widget has focus. Returns true if the input was diff --git a/Source/CursesDialog/cmCursesWidget.h b/Source/CursesDialog/cmCursesWidget.h index a44c5e6..f761f6d 100644 --- a/Source/CursesDialog/cmCursesWidget.h +++ b/Source/CursesDialog/cmCursesWidget.h @@ -14,12 +14,13 @@ class cmCursesMainForm; class cmCursesWidget { - CM_DISABLE_COPY(cmCursesWidget) - public: cmCursesWidget(int width, int height, int left, int top); virtual ~cmCursesWidget(); + cmCursesWidget(cmCursesWidget const&) = delete; + cmCursesWidget& operator=(cmCursesWidget const&) = delete; + /** * Handle user input. Called by the container of this widget * when this widget has focus. Returns true if the input was diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx index 2eecce6..a073c30 100644 --- a/Source/QtDialog/QCMake.cxx +++ b/Source/QtDialog/QCMake.cxx @@ -23,16 +23,26 @@ QCMake::QCMake(QObject* p) cmSystemTools::DisableRunCommandOutput(); cmSystemTools::SetRunCommandHideConsole(true); - cmSystemTools::SetMessageCallback(QCMake::messageCallback, this); - cmSystemTools::SetStdoutCallback(QCMake::stdoutCallback, this); - cmSystemTools::SetStderrCallback(QCMake::stderrCallback, this); + + cmSystemTools::SetMessageCallback( + [this](const char* msg, const char* title) { + this->messageCallback(msg, title); + }); + cmSystemTools::SetStdoutCallback( + [this](std::string const& msg) { this->stdoutCallback(msg); }); + cmSystemTools::SetStderrCallback( + [this](std::string const& msg) { this->stderrCallback(msg); }); this->CMakeInstance = new cmake(cmake::RoleProject, cmState::Project); this->CMakeInstance->SetCMakeEditCommand( cmSystemTools::GetCMakeGUICommand()); - this->CMakeInstance->SetProgressCallback(QCMake::progressCallback, this); + this->CMakeInstance->SetProgressCallback( + [this](const char* msg, float percent) { + this->progressCallback(msg, percent); + }); - cmSystemTools::SetInterruptCallback(QCMake::interruptCallback, this); + cmSystemTools::SetInterruptCallback( + [this] { return this->interruptCallback(); }); std::vector<cmake::GeneratorInfo> generators; this->CMakeInstance->GetRegisteredGenerators( @@ -330,46 +340,40 @@ void QCMake::interrupt() this->InterruptFlag.ref(); } -bool QCMake::interruptCallback(void* cd) +bool QCMake::interruptCallback() { - QCMake* self = reinterpret_cast<QCMake*>(cd); #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0) - return self->InterruptFlag; + return this->InterruptFlag; #else - return self->InterruptFlag.load(); + return this->InterruptFlag.load(); #endif } -void QCMake::progressCallback(const char* msg, float percent, void* cd) +void QCMake::progressCallback(const char* msg, float percent) { - QCMake* self = reinterpret_cast<QCMake*>(cd); if (percent >= 0) { - emit self->progressChanged(QString::fromLocal8Bit(msg), percent); + emit this->progressChanged(QString::fromLocal8Bit(msg), percent); } else { - emit self->outputMessage(QString::fromLocal8Bit(msg)); + emit this->outputMessage(QString::fromLocal8Bit(msg)); } QCoreApplication::processEvents(); } -void QCMake::messageCallback(const char* msg, const char* /*title*/, - bool& /*stop*/, void* cd) +void QCMake::messageCallback(const char* msg, const char* /*title*/) { - QCMake* self = reinterpret_cast<QCMake*>(cd); - emit self->errorMessage(QString::fromLocal8Bit(msg)); + emit this->errorMessage(QString::fromLocal8Bit(msg)); QCoreApplication::processEvents(); } -void QCMake::stdoutCallback(const char* msg, size_t len, void* cd) +void QCMake::stdoutCallback(std::string const& msg) { - QCMake* self = reinterpret_cast<QCMake*>(cd); - emit self->outputMessage(QString::fromLocal8Bit(msg, int(len))); + emit this->outputMessage(QString::fromStdString(msg)); QCoreApplication::processEvents(); } -void QCMake::stderrCallback(const char* msg, size_t len, void* cd) +void QCMake::stderrCallback(std::string const& msg) { - QCMake* self = reinterpret_cast<QCMake*>(cd); - emit self->outputMessage(QString::fromLocal8Bit(msg, int(len))); + emit this->outputMessage(QString::fromStdString(msg)); QCoreApplication::processEvents(); } diff --git a/Source/QtDialog/QCMake.h b/Source/QtDialog/QCMake.h index c84da58..ef4d2a1 100644 --- a/Source/QtDialog/QCMake.h +++ b/Source/QtDialog/QCMake.h @@ -167,12 +167,12 @@ signals: protected: cmake* CMakeInstance; - static bool interruptCallback(void*); - static void progressCallback(const char* msg, float percent, void* cd); - static void messageCallback(const char* msg, const char* title, bool&, - void* cd); - static void stdoutCallback(const char* msg, size_t len, void* cd); - static void stderrCallback(const char* msg, size_t len, void* cd); + bool interruptCallback(); + void progressCallback(const char* msg, float percent); + void messageCallback(const char* msg, const char* title); + void stdoutCallback(std::string const& msg); + void stderrCallback(std::string const& msg); + bool WarnUninitializedMode; bool WarnUnusedMode; bool WarnUnusedAllMode; diff --git a/Source/cmCLocaleEnvironmentScope.h b/Source/cmCLocaleEnvironmentScope.h index ec81cb9..93032c1 100644 --- a/Source/cmCLocaleEnvironmentScope.h +++ b/Source/cmCLocaleEnvironmentScope.h @@ -10,12 +10,14 @@ class cmCLocaleEnvironmentScope { - CM_DISABLE_COPY(cmCLocaleEnvironmentScope) - public: cmCLocaleEnvironmentScope(); ~cmCLocaleEnvironmentScope(); + cmCLocaleEnvironmentScope(cmCLocaleEnvironmentScope const&) = delete; + cmCLocaleEnvironmentScope& operator=(cmCLocaleEnvironmentScope const&) = + delete; + private: std::string GetEnv(std::string const& key); void SetEnv(std::string const& key, std::string const& value); diff --git a/Source/cmCPackPropertiesGenerator.h b/Source/cmCPackPropertiesGenerator.h index e580e04..ad943c5 100644 --- a/Source/cmCPackPropertiesGenerator.h +++ b/Source/cmCPackPropertiesGenerator.h @@ -20,13 +20,15 @@ class cmLocalGenerator; */ class cmCPackPropertiesGenerator : public cmScriptGenerator { - CM_DISABLE_COPY(cmCPackPropertiesGenerator) - public: cmCPackPropertiesGenerator(cmLocalGenerator* lg, cmInstalledFile const& installedFile, std::vector<std::string> const& configurations); + cmCPackPropertiesGenerator(cmCPackPropertiesGenerator const&) = delete; + cmCPackPropertiesGenerator& operator=(cmCPackPropertiesGenerator const&) = + delete; + protected: void GenerateScriptForConfig(std::ostream& os, const std::string& config, Indent indent) override; diff --git a/Source/cmCommand.h b/Source/cmCommand.h index 07333bb..9ccd773 100644 --- a/Source/cmCommand.h +++ b/Source/cmCommand.h @@ -24,8 +24,6 @@ struct cmListFileArgument; */ class cmCommand { - CM_DISABLE_COPY(cmCommand) - public: /** * Construct the command. By default it has no makefile. @@ -37,6 +35,9 @@ public: */ virtual ~cmCommand() = default; + cmCommand(cmCommand const&) = delete; + cmCommand& operator=(cmCommand const&) = delete; + /** * Specify the makefile. */ diff --git a/Source/cmCommandArgumentParserHelper.h b/Source/cmCommandArgumentParserHelper.h index 4dc238e..25e6892 100644 --- a/Source/cmCommandArgumentParserHelper.h +++ b/Source/cmCommandArgumentParserHelper.h @@ -12,8 +12,6 @@ class cmMakefile; class cmCommandArgumentParserHelper { - CM_DISABLE_COPY(cmCommandArgumentParserHelper) - public: struct ParserType { @@ -23,6 +21,10 @@ public: cmCommandArgumentParserHelper(); ~cmCommandArgumentParserHelper(); + cmCommandArgumentParserHelper(cmCommandArgumentParserHelper const&) = delete; + cmCommandArgumentParserHelper& operator=( + cmCommandArgumentParserHelper const&) = delete; + int ParseString(const char* str, int verb); // For the lexer: diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h index 9579861..dc934be 100644 --- a/Source/cmCommandArgumentsHelper.h +++ b/Source/cmCommandArgumentsHelper.h @@ -103,7 +103,6 @@ private: std::vector<std::string> Vector; unsigned int DataStart; const char* Ignore; - cmCAStringVector(); bool DoConsume(const std::string& arg, unsigned int index) override; void DoReset() override; }; @@ -125,7 +124,6 @@ private: unsigned int DataStart; bool DoConsume(const std::string& arg, unsigned int index) override; void DoReset() override; - cmCAString(); }; /** cmCAEnabler is to be used for options which are off by default and can be @@ -143,7 +141,6 @@ private: bool Enabled; bool DoConsume(const std::string& arg, unsigned int index) override; void DoReset() override; - cmCAEnabler(); }; /** cmCADisable is to be used for options which are on by default and can be @@ -161,7 +158,6 @@ private: bool Enabled; bool DoConsume(const std::string& arg, unsigned int index) override; void DoReset() override; - cmCADisabler(); }; /** Group of arguments, needed for ordering. E.g. WIN32, EXCLUDE_FROM_ALL and diff --git a/Source/cmConfigure.cmake.h.in b/Source/cmConfigure.cmake.h.in index 9d00c21..19b1cd4 100644 --- a/Source/cmConfigure.cmake.h.in +++ b/Source/cmConfigure.cmake.h.in @@ -26,8 +26,4 @@ #define CM_FALLTHROUGH cmsys_FALLTHROUGH -#define CM_DISABLE_COPY(Class) \ - Class(Class const&) = delete; \ - Class& operator=(Class const&) = delete; - #endif diff --git a/Source/cmConnection.h b/Source/cmConnection.h index 3a7f1b9..092b913 100644 --- a/Source/cmConnection.h +++ b/Source/cmConnection.h @@ -60,11 +60,12 @@ public: class cmConnection { - CM_DISABLE_COPY(cmConnection) - public: cmConnection() = default; + cmConnection(cmConnection const&) = delete; + cmConnection& operator=(cmConnection const&) = delete; + virtual void WriteData(const std::string& data) = 0; virtual ~cmConnection(); diff --git a/Source/cmCryptoHash.h b/Source/cmCryptoHash.h index 1f2a1b5..b712f09 100644 --- a/Source/cmCryptoHash.h +++ b/Source/cmCryptoHash.h @@ -15,8 +15,6 @@ */ class cmCryptoHash { - CM_DISABLE_COPY(cmCryptoHash) - public: enum Algo { @@ -35,6 +33,9 @@ public: cmCryptoHash(Algo algo); ~cmCryptoHash(); + cmCryptoHash(cmCryptoHash const&) = delete; + cmCryptoHash& operator=(cmCryptoHash const&) = delete; + /// @brief Returns a new hash generator of the requested type /// @arg algo Hash type name. Supported hash types are /// MD5, SHA1, SHA224, SHA256, SHA384, SHA512, diff --git a/Source/cmDepends.h b/Source/cmDepends.h index c5e1d5b..20c91ca 100644 --- a/Source/cmDepends.h +++ b/Source/cmDepends.h @@ -24,13 +24,14 @@ class cmLocalGenerator; */ class cmDepends { - CM_DISABLE_COPY(cmDepends) - public: /** Instances need to know the build directory name and the relative path from the build directory to the target file. */ cmDepends(cmLocalGenerator* lg = nullptr, std::string targetDir = ""); + cmDepends(cmDepends const&) = delete; + cmDepends& operator=(cmDepends const&) = delete; + /** Set the local generator for the directory in which we are scanning dependencies. This is not a full local generator; it has been setup to do relative path conversions for the current diff --git a/Source/cmDependsC.h b/Source/cmDependsC.h index 411458a..eee5ae1 100644 --- a/Source/cmDependsC.h +++ b/Source/cmDependsC.h @@ -22,8 +22,6 @@ class cmLocalGenerator; */ class cmDependsC : public cmDepends { - CM_DISABLE_COPY(cmDependsC) - public: /** Checking instances need to know the build directory name and the relative path from the build directory to the target file. */ @@ -35,6 +33,9 @@ public: /** Virtual destructor to cleanup subclasses properly. */ ~cmDependsC() override; + cmDependsC(cmDependsC const&) = delete; + cmDependsC& operator=(cmDependsC const&) = delete; + protected: // Implement writing/checking methods required by superclass. bool WriteDependencies(const std::set<std::string>& sources, diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h index f5f5be2..bf09904 100644 --- a/Source/cmDependsFortran.h +++ b/Source/cmDependsFortran.h @@ -21,8 +21,6 @@ class cmLocalGenerator; */ class cmDependsFortran : public cmDepends { - CM_DISABLE_COPY(cmDependsFortran) - public: /** Checking instances need to know the build directory name and the relative path from the build directory to the target file. */ @@ -37,6 +35,9 @@ public: /** Virtual destructor to cleanup subclasses properly. */ ~cmDependsFortran() override; + cmDependsFortran(cmDependsFortran const&) = delete; + cmDependsFortran& operator=(cmDependsFortran const&) = delete; + /** Callback from build system after a .mod file has been generated by a Fortran90 compiler to copy the .mod file to the corresponding stamp file. */ diff --git a/Source/cmDependsJava.h b/Source/cmDependsJava.h index 1928c51..109ef13 100644 --- a/Source/cmDependsJava.h +++ b/Source/cmDependsJava.h @@ -17,8 +17,6 @@ */ class cmDependsJava : public cmDepends { - CM_DISABLE_COPY(cmDependsJava) - public: /** Checking instances need to know the build directory name and the relative path from the build directory to the target file. */ @@ -27,6 +25,9 @@ public: /** Virtual destructor to cleanup subclasses properly. */ ~cmDependsJava() override; + cmDependsJava(cmDependsJava const&) = delete; + cmDependsJava& operator=(cmDependsJava const&) = delete; + protected: // Implement writing/checking methods required by superclass. bool WriteDependencies(const std::set<std::string>& sources, diff --git a/Source/cmDynamicLoader.h b/Source/cmDynamicLoader.h index e9fe97a..4b89388 100644 --- a/Source/cmDynamicLoader.h +++ b/Source/cmDynamicLoader.h @@ -14,8 +14,6 @@ class cmDynamicLoader { - CM_DISABLE_COPY(cmDynamicLoader) - public: // Description: // Load a dynamic library into the current process. diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx index 397508c..e408de3 100644 --- a/Source/cmExtraCodeBlocksGenerator.cxx +++ b/Source/cmExtraCodeBlocksGenerator.cxx @@ -362,7 +362,7 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile( // don't add source files from UTILITY target which have the // GENERATED property set: if (gt->GetType() == cmStateEnums::UTILITY && - s->GetPropertyAsBool("GENERATED")) { + s->GetIsGenerated()) { continue; } diff --git a/Source/cmExtraKateGenerator.cxx b/Source/cmExtraKateGenerator.cxx index e28a865..23ba6b7 100644 --- a/Source/cmExtraKateGenerator.cxx +++ b/Source/cmExtraKateGenerator.cxx @@ -256,7 +256,7 @@ std::string cmExtraKateGenerator::GenerateFilesString( const std::vector<cmSourceFile*>& sources = makefile->GetSourceFiles(); for (cmSourceFile* sf : sources) { - if (sf->GetPropertyAsBool("GENERATED")) { + if (sf->GetIsGenerated()) { continue; } diff --git a/Source/cmFileAPICodemodel.cxx b/Source/cmFileAPICodemodel.cxx index 4597d4f..45e8303 100644 --- a/Source/cmFileAPICodemodel.cxx +++ b/Source/cmFileAPICodemodel.cxx @@ -882,7 +882,7 @@ Json::Value Target::DumpSource(cmGeneratorTarget::SourceAndKind const& sk, std::string const path = sk.Source.Value->GetFullPath(); source["path"] = RelativeIfUnder(this->TopSource, path); - if (sk.Source.Value->GetPropertyAsBool("GENERATED")) { + if (sk.Source.Value->GetIsGenerated()) { source["isGenerated"] = true; } this->AddBacktrace(source, sk.Source.Backtrace); diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index c2318cd..0f911c1 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -3758,8 +3758,7 @@ bool cmFileCommand::HandleCreateLinkCommand( // Check if copy-on-error is enabled in the arguments. if (!completed && copyOnErrorArg.IsEnabled()) { - completed = - cmSystemTools::cmCopyFile(fileName.c_str(), newFileName.c_str()); + completed = cmSystemTools::cmCopyFile(fileName, newFileName); if (!completed) { result = "Copy failed: " + cmSystemTools::GetLastSystemError(); } diff --git a/Source/cmFileLock.h b/Source/cmFileLock.h index 491a40b..2130d65 100644 --- a/Source/cmFileLock.h +++ b/Source/cmFileLock.h @@ -21,12 +21,13 @@ class cmFileLockResult; */ class cmFileLock { - CM_DISABLE_COPY(cmFileLock) - public: cmFileLock(); ~cmFileLock(); + cmFileLock(cmFileLock const&) = delete; + cmFileLock& operator=(cmFileLock const&) = delete; + /** * @brief Lock the file. * @param timeoutSec Lock timeout. If -1 try until success or fatal error. diff --git a/Source/cmFileLockPool.h b/Source/cmFileLockPool.h index 0197354..41203ba 100644 --- a/Source/cmFileLockPool.h +++ b/Source/cmFileLockPool.h @@ -13,12 +13,13 @@ class cmFileLockResult; class cmFileLockPool { - CM_DISABLE_COPY(cmFileLockPool) - public: cmFileLockPool(); ~cmFileLockPool(); + cmFileLockPool(cmFileLockPool const&) = delete; + cmFileLockPool& operator=(cmFileLockPool const&) = delete; + //@{ /** * @brief Function scope control. @@ -58,12 +59,13 @@ private: class ScopePool { - CM_DISABLE_COPY(ScopePool) - public: ScopePool(); ~ScopePool(); + ScopePool(ScopePool const&) = delete; + ScopePool& operator=(ScopePool const&) = delete; + cmFileLockResult Lock(const std::string& filename, unsigned long timeoutSec); cmFileLockResult Release(const std::string& filename); diff --git a/Source/cmFileMonitor.h b/Source/cmFileMonitor.h index 632e751..7ffc929 100644 --- a/Source/cmFileMonitor.h +++ b/Source/cmFileMonitor.h @@ -14,12 +14,14 @@ class cmRootWatcher; class cmFileMonitor { - CM_DISABLE_COPY(cmFileMonitor) public: cmFileMonitor(uv_loop_t* l); ~cmFileMonitor(); + cmFileMonitor(cmFileMonitor const&) = delete; + cmFileMonitor& operator=(cmFileMonitor const&) = delete; + using Callback = std::function<void(const std::string&, int, int)>; void MonitorPaths(const std::vector<std::string>& paths, Callback const& cb); void StopMonitoring(); diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index f9ac310..c2e0712 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -693,7 +693,7 @@ bool cmFindPackageCommand::FindModule(bool& found) std::string var = this->Name; var += "_FIND_MODULE"; this->Makefile->AddDefinition(var, "1"); - bool result = this->ReadListFile(mfile.c_str(), DoPolicyScope); + bool result = this->ReadListFile(mfile, DoPolicyScope); this->Makefile->RemoveDefinition(var); return result; } @@ -776,7 +776,7 @@ bool cmFindPackageCommand::HandlePackageMode() this->StoreVersionFound(); // Parse the configuration file. - if (this->ReadListFile(this->FileFound.c_str(), DoPolicyScope)) { + if (this->ReadListFile(this->FileFound, DoPolicyScope)) { // The package has been found. found = true; @@ -1036,7 +1036,8 @@ bool cmFindPackageCommand::FindAppBundleConfig() return false; } -bool cmFindPackageCommand::ReadListFile(const char* f, PolicyScopeRule psr) +bool cmFindPackageCommand::ReadListFile(const std::string& f, + PolicyScopeRule psr) { const bool noPolicyScope = !this->PolicyScope || psr == NoPolicyScope; if (this->Makefile->ReadDependentFile(f, noPolicyScope)) { @@ -1590,7 +1591,7 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file, // Load the version check file. Pass NoPolicyScope because we do // our own policy push/pop independent of CMP0011. bool suitable = false; - if (this->ReadListFile(version_file.c_str(), NoPolicyScope)) { + if (this->ReadListFile(version_file, NoPolicyScope)) { // Check the output variables. bool okay = this->Makefile->IsOn("PACKAGE_VERSION_EXACT"); bool unsuitable = this->Makefile->IsOn("PACKAGE_VERSION_UNSUITABLE"); diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h index 83d8431..a11d253 100644 --- a/Source/cmFindPackageCommand.h +++ b/Source/cmFindPackageCommand.h @@ -110,7 +110,7 @@ private: NoPolicyScope, DoPolicyScope }; - bool ReadListFile(const char* f, PolicyScopeRule psr); + bool ReadListFile(const std::string& f, PolicyScopeRule psr); void StoreVersionFound(); void ComputePrefixes(); diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h index fd11889..5b1eb51 100644 --- a/Source/cmGeneratedFileStream.h +++ b/Source/cmGeneratedFileStream.h @@ -97,6 +97,8 @@ public: */ ~cmGeneratedFileStream() override; + cmGeneratedFileStream(cmGeneratedFileStream const&) = delete; + /** * Open an output file by name. This should be used only with a * non-open stream. It automatically generates a name for the @@ -134,9 +136,6 @@ public: * the output file to be changed during the use of cmGeneratedFileStream. */ void SetName(const std::string& fname); - -private: - cmGeneratedFileStream(cmGeneratedFileStream const&); // not implemented }; #endif diff --git a/Source/cmGeneratorExpression.h b/Source/cmGeneratorExpression.h index e5463a7..fd36c4b 100644 --- a/Source/cmGeneratorExpression.h +++ b/Source/cmGeneratorExpression.h @@ -32,13 +32,14 @@ struct cmGeneratorExpressionEvaluator; */ class cmGeneratorExpression { - CM_DISABLE_COPY(cmGeneratorExpression) - public: /** Construct. */ cmGeneratorExpression(cmListFileBacktrace backtrace = cmListFileBacktrace()); ~cmGeneratorExpression(); + cmGeneratorExpression(cmGeneratorExpression const&) = delete; + cmGeneratorExpression& operator=(cmGeneratorExpression const&) = delete; + std::unique_ptr<cmCompiledGeneratorExpression> Parse( std::string const& input); std::unique_ptr<cmCompiledGeneratorExpression> Parse(const char* input); @@ -78,9 +79,13 @@ private: class cmCompiledGeneratorExpression { - CM_DISABLE_COPY(cmCompiledGeneratorExpression) - public: + ~cmCompiledGeneratorExpression(); + + cmCompiledGeneratorExpression(cmCompiledGeneratorExpression const&) = delete; + cmCompiledGeneratorExpression& operator=( + cmCompiledGeneratorExpression const&) = delete; + const std::string& Evaluate( cmLocalGenerator* lg, const std::string& config, bool quiet = false, cmGeneratorTarget const* headTarget = nullptr, @@ -109,8 +114,6 @@ public: return this->AllTargetsSeen; } - ~cmCompiledGeneratorExpression(); - std::string const& GetInput() const { return this->Input; } cmListFileBacktrace GetBacktrace() const { return this->Backtrace; } @@ -165,8 +168,6 @@ private: class cmGeneratorExpressionInterpreter { - CM_DISABLE_COPY(cmGeneratorExpressionInterpreter) - public: cmGeneratorExpressionInterpreter(cmLocalGenerator* localGenerator, std::string config, @@ -179,6 +180,11 @@ public: { } + cmGeneratorExpressionInterpreter(cmGeneratorExpressionInterpreter const&) = + delete; + cmGeneratorExpressionInterpreter& operator=( + cmGeneratorExpressionInterpreter const&) = delete; + const std::string& Evaluate(const char* expression, const std::string& property); const std::string& Evaluate(const std::string& expression, diff --git a/Source/cmGeneratorExpressionEvaluator.h b/Source/cmGeneratorExpressionEvaluator.h index 0f553f2..4530152 100644 --- a/Source/cmGeneratorExpressionEvaluator.h +++ b/Source/cmGeneratorExpressionEvaluator.h @@ -19,6 +19,11 @@ struct cmGeneratorExpressionEvaluator cmGeneratorExpressionEvaluator() = default; virtual ~cmGeneratorExpressionEvaluator() = default; + cmGeneratorExpressionEvaluator(cmGeneratorExpressionEvaluator const&) = + delete; + cmGeneratorExpressionEvaluator& operator=( + cmGeneratorExpressionEvaluator const&) = delete; + enum Type { Text, @@ -29,9 +34,6 @@ struct cmGeneratorExpressionEvaluator virtual std::string Evaluate(cmGeneratorExpressionContext* context, cmGeneratorExpressionDAGChecker*) const = 0; - -private: - CM_DISABLE_COPY(cmGeneratorExpressionEvaluator) }; struct TextContent : public cmGeneratorExpressionEvaluator diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx index eb66ed5..aac188e 100644 --- a/Source/cmGeneratorExpressionNode.cxx +++ b/Source/cmGeneratorExpressionNode.cxx @@ -95,7 +95,7 @@ static const struct ZeroNode installInterfaceNode; #define BOOLEAN_OP_NODE(OPNAME, OP, SUCCESS_VALUE, FAILURE_VALUE) \ static const struct OP##Node : public cmGeneratorExpressionNode \ { \ - OP##Node() {} \ + OP##Node() {} /* NOLINT(modernize-use-equals-default) */ \ virtual int NumExpectedParameters() const { return OneOrMoreParameters; } \ \ std::string Evaluate(const std::vector<std::string>& parameters, \ diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 86f10dc..78040c3 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -3859,6 +3859,13 @@ std::string cmGeneratorTarget::GetObjectDirectory( // find and replace $(PROJECT_NAME) xcode placeholder const std::string projectName = this->LocalGenerator->GetProjectName(); cmSystemTools::ReplaceString(obj_dir, "$(PROJECT_NAME)", projectName); + // Replace Xcode's placeholder for the object file directory since + // installation and export scripts need to know the real directory. + // Xcode has build-time settings (e.g. for sanitizers) that affect this, + // but we use the default here. Users that want to enable sanitizers + // will do so at the cost of object library installation and export. + cmSystemTools::ReplaceString(obj_dir, "$(OBJECT_FILE_DIR_normal:base)", + "Objects-normal"); #endif return obj_dir; } diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h index d72e051..59d38af 100644 --- a/Source/cmGeneratorTarget.h +++ b/Source/cmGeneratorTarget.h @@ -27,12 +27,13 @@ class cmTarget; class cmGeneratorTarget { - CM_DISABLE_COPY(cmGeneratorTarget) - public: cmGeneratorTarget(cmTarget*, cmLocalGenerator* lg); ~cmGeneratorTarget(); + cmGeneratorTarget(cmGeneratorTarget const&) = delete; + cmGeneratorTarget& operator=(cmGeneratorTarget const&) = delete; + cmLocalGenerator* GetLocalGenerator() const; cmGlobalGenerator* GetGlobalGenerator() const; diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 2b5c98f..386a3f7 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -567,11 +567,6 @@ void cmGlobalGenerator::EnableLanguage( return; } - // Find the native build tool for this generator. - if (!this->FindMakeProgram(mf)) { - return; - } - // Tell the generator about the target system. std::string system = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME"); if (!this->SetSystemName(system, mf)) { @@ -592,6 +587,11 @@ void cmGlobalGenerator::EnableLanguage( cmSystemTools::SetFatalErrorOccured(); return; } + + // Find the native build tool for this generator. + if (!this->FindMakeProgram(mf)) { + return; + } } // Check that the languages are supported by the generator and its diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index 4fd0673..6498024 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -454,6 +454,7 @@ cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm) , NinjaSupportsConsolePool(false) , NinjaSupportsImplicitOuts(false) , NinjaSupportsManifestRestat(false) + , NinjaSupportsMultilineDepfile(false) , NinjaSupportsDyndeps(0) { #ifdef _WIN32 @@ -581,6 +582,9 @@ void cmGlobalNinjaGenerator::CheckNinjaFeatures() this->NinjaSupportsManifestRestat = !cmSystemTools::VersionCompare( cmSystemTools::OP_LESS, this->NinjaVersion.c_str(), RequiredNinjaVersionForManifestRestat().c_str()); + this->NinjaSupportsMultilineDepfile = !cmSystemTools::VersionCompare( + cmSystemTools::OP_LESS, this->NinjaVersion.c_str(), + RequiredNinjaVersionForMultilineDepfile().c_str()); { // Our ninja branch adds ".dyndep-#" to its version number, // where '#' is a feature-specific version number. Extract it. @@ -1478,6 +1482,11 @@ bool cmGlobalNinjaGenerator::SupportsManifestRestat() const return this->NinjaSupportsManifestRestat; } +bool cmGlobalNinjaGenerator::SupportsMultilineDepfile() const +{ + return this->NinjaSupportsMultilineDepfile; +} + void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os) { WriteRule(*this->RulesFileStream, "CLEAN", ninjaCmd() + " -t clean", diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index b3aa88f..c619e67 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -345,9 +345,14 @@ public: static std::string RequiredNinjaVersionForConsolePool() { return "1.5"; } static std::string RequiredNinjaVersionForImplicitOuts() { return "1.7"; } static std::string RequiredNinjaVersionForManifestRestat() { return "1.8"; } + static std::string RequiredNinjaVersionForMultilineDepfile() + { + return "1.9"; + } bool SupportsConsolePool() const; bool SupportsImplicitOuts() const; bool SupportsManifestRestat() const; + bool SupportsMultilineDepfile() const; std::string NinjaOutputPath(std::string const& path) const; bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); } @@ -461,6 +466,7 @@ private: bool NinjaSupportsConsolePool; bool NinjaSupportsImplicitOuts; bool NinjaSupportsManifestRestat; + bool NinjaSupportsMultilineDepfile; unsigned long NinjaSupportsDyndeps; private: diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx index e3dd2f9..77be592 100644 --- a/Source/cmGlobalVisualStudioGenerator.cxx +++ b/Source/cmGlobalVisualStudioGenerator.cxx @@ -262,9 +262,8 @@ void cmGlobalVisualStudioGenerator::ConfigureCMakeVisualStudioMacros() // purposes but newer versions distributed with CMake will replace // older versions in user directories. int res; - if (!cmSystemTools::FileTimeCompare(src.c_str(), dst.c_str(), &res) || - res > 0) { - if (!cmSystemTools::CopyFileAlways(src.c_str(), dst.c_str())) { + if (!cmSystemTools::FileTimeCompare(src, dst, &res) || res > 0) { + if (!cmSystemTools::CopyFileAlways(src, dst)) { std::ostringstream oss; oss << "Could not copy from: " << src << std::endl; oss << " to: " << dst << std::endl; diff --git a/Source/cmGlobalVisualStudioVersionedGenerator.cxx b/Source/cmGlobalVisualStudioVersionedGenerator.cxx index bc6b453..12d9304 100644 --- a/Source/cmGlobalVisualStudioVersionedGenerator.cxx +++ b/Source/cmGlobalVisualStudioVersionedGenerator.cxx @@ -471,6 +471,18 @@ std::string cmGlobalVisualStudioVersionedGenerator::FindMSBuildCommand() // Ask Visual Studio Installer tool. std::string vs; if (vsSetupAPIHelper.GetVSInstanceInfo(vs)) { + std::string const& hostArch = + this->GetPlatformToolsetHostArchitectureString(); + if (hostArch == "x64") { + msbuild = vs + "/MSBuild/Current/Bin/amd64/MSBuild.exe"; + if (cmSystemTools::FileExists(msbuild)) { + return msbuild; + } + msbuild = vs + "/MSBuild/15.0/Bin/amd64/MSBuild.exe"; + if (cmSystemTools::FileExists(msbuild)) { + return msbuild; + } + } msbuild = vs + "/MSBuild/Current/Bin/MSBuild.exe"; if (cmSystemTools::FileExists(msbuild)) { return msbuild; diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index 6d15b8c..16f8a0e 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -485,6 +485,7 @@ std::string cmGlobalXCodeGenerator::PostBuildMakeTarget( } #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK" +#define OBJECT_LIBRARY_ARTIFACT_DIR std::string() void cmGlobalXCodeGenerator::AddExtraTargets( cmLocalGenerator* root, std::vector<cmLocalGenerator*>& gens) @@ -509,6 +510,7 @@ void cmGlobalXCodeGenerator::AddExtraTargets( makeHelper.push_back(dir); makeHelper.push_back("-f"); makeHelper.push_back(this->CurrentXCodeHackMakefile); + makeHelper.push_back("OBJDIR=$(OBJDIR)"); makeHelper.push_back(""); // placeholder, see below // Add ZERO_CHECK @@ -752,8 +754,6 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( class XCodeGeneratorExpressionInterpreter : public cmGeneratorExpressionInterpreter { - CM_DISABLE_COPY(XCodeGeneratorExpressionInterpreter) - public: XCodeGeneratorExpressionInterpreter(cmSourceFile* sourceFile, cmLocalGenerator* localGenerator, @@ -765,6 +765,11 @@ public: { } + XCodeGeneratorExpressionInterpreter( + XCodeGeneratorExpressionInterpreter const&) = delete; + XCodeGeneratorExpressionInterpreter& operator=( + XCodeGeneratorExpressionInterpreter const&) = delete; + using cmGeneratorExpressionInterpreter::Evaluate; const std::string& Evaluate(const char* expression, @@ -1661,6 +1666,7 @@ void cmGlobalXCodeGenerator::AddCommandsToBuildPhase( makecmd += cdir; makecmd += " -f "; makecmd += this->ConvertToRelativeForMake((makefile + "$CONFIGURATION")); + makecmd += " OBJDIR=$(basename \"$OBJECT_FILE_DIR_normal\")"; makecmd += " all"; buildphase->AddAttribute("shellScript", this->CreateString(makecmd)); buildphase->AddAttribute("showEnvVarsInLog", this->CreateString("0")); @@ -1968,8 +1974,8 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt, pnbase = gtgt->GetName(); pnsuffix = ".a"; - std::string pncdir = - this->GetObjectsNormalDirectory(this->CurrentProject, configName, gtgt); + std::string pncdir = this->GetObjectsDirectory( + this->CurrentProject, configName, gtgt, OBJECT_LIBRARY_ARTIFACT_DIR); buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR", this->CreateString(pncdir)); } @@ -2454,7 +2460,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateUtilityTarget( this->AddXCodeProjBuildRule(gtgt, sources); for (auto sourceFile : sources) { - if (!sourceFile->GetPropertyAsBool("GENERATED")) { + if (!sourceFile->GetIsGenerated()) { this->CreateXCodeFileReference(sourceFile, gtgt); } } @@ -3136,6 +3142,8 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects( if (const char* vers = this->CurrentMakefile->GetDefinition( "CMAKE_Swift_LANGUAGE_VERSION")) { swiftVersion = vers; + } else if (this->XcodeVersion >= 102) { + swiftVersion = "4.0"; } else if (this->XcodeVersion >= 83) { swiftVersion = "3.0"; } else { @@ -3199,9 +3207,9 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects( return true; } -std::string cmGlobalXCodeGenerator::GetObjectsNormalDirectory( +std::string cmGlobalXCodeGenerator::GetObjectsDirectory( const std::string& projName, const std::string& configName, - const cmGeneratorTarget* t) const + const cmGeneratorTarget* t, const std::string& variant) const { std::string dir = t->GetLocalGenerator()->GetCurrentBinaryDirectory(); dir += "/"; @@ -3210,8 +3218,8 @@ std::string cmGlobalXCodeGenerator::GetObjectsNormalDirectory( dir += configName; dir += "/"; dir += t->GetName(); - dir += ".build/Objects-normal/"; - + dir += ".build/"; + dir += variant; return dir; } @@ -3338,8 +3346,9 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget( for (auto objLib : objlibs) { const std::string objLibName = objLib->GetName(); - std::string d = this->GetObjectsNormalDirectory(this->CurrentProject, - configName, objLib); + std::string d = + this->GetObjectsDirectory(this->CurrentProject, configName, objLib, + OBJECT_LIBRARY_ARTIFACT_DIR); d += "lib"; d += objLibName; d += ".a"; @@ -3356,8 +3365,8 @@ void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget( // if building for more than one architecture // then remove those executables as well if (this->Architectures.size() > 1) { - std::string universal = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, gt); + std::string universal = this->GetObjectsDirectory( + this->CurrentProject, configName, gt, "$(OBJDIR)/"); for (const auto& architecture : this->Architectures) { std::string universalFile = universal; universalFile += architecture; @@ -3761,8 +3770,8 @@ void cmGlobalXCodeGenerator::ComputeTargetObjectDirectory( cmGeneratorTarget* gt) const { std::string configName = this->GetCMakeCFGIntDir(); - std::string dir = - this->GetObjectsNormalDirectory("$(PROJECT_NAME)", configName, gt); + std::string dir = this->GetObjectsDirectory( + "$(PROJECT_NAME)", configName, gt, "$(OBJECT_FILE_DIR_normal:base)/"); dir += this->ObjectDirArch; dir += "/"; gt->ObjectDirectory = dir; diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h index 92ff258..e1e412d 100644 --- a/Source/cmGlobalXCodeGenerator.h +++ b/Source/cmGlobalXCodeGenerator.h @@ -264,9 +264,10 @@ private: { } - std::string GetObjectsNormalDirectory(const std::string& projName, - const std::string& configName, - const cmGeneratorTarget* t) const; + std::string GetObjectsDirectory(const std::string& projName, + const std::string& configName, + const cmGeneratorTarget* t, + const std::string& variant) const; static std::string GetDeploymentPlatform(const cmMakefile* mf); diff --git a/Source/cmInstallCommandArguments.h b/Source/cmInstallCommandArguments.h index 8e974af..9c0d417 100644 --- a/Source/cmInstallCommandArguments.h +++ b/Source/cmInstallCommandArguments.h @@ -45,7 +45,6 @@ public: cmCommandArgumentGroup ArgumentGroup; private: - cmInstallCommandArguments(); // disabled cmCAString Destination; cmCAString Component; cmCAString NamelinkComponent; diff --git a/Source/cmInstallGenerator.h b/Source/cmInstallGenerator.h index e5b88c3..9bd7ac3 100644 --- a/Source/cmInstallGenerator.h +++ b/Source/cmInstallGenerator.h @@ -21,8 +21,6 @@ class cmMakefile; */ class cmInstallGenerator : public cmScriptGenerator { - CM_DISABLE_COPY(cmInstallGenerator) - public: enum MessageLevel { @@ -38,6 +36,9 @@ public: bool exclude_from_all); ~cmInstallGenerator() override; + cmInstallGenerator(cmInstallGenerator const&) = delete; + cmInstallGenerator& operator=(cmInstallGenerator const&) = delete; + virtual bool HaveInstall(); virtual void CheckCMP0082(bool& haveSubdirectoryInstall, bool& haveInstallAfterSubdirectory); diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx index 10df70b..59701a1 100644 --- a/Source/cmInstallTargetGenerator.cxx +++ b/Source/cmInstallTargetGenerator.cxx @@ -19,6 +19,7 @@ #include "cmStateTypes.h" #include "cmSystemTools.h" #include "cmTarget.h" +#include "cmake.h" cmInstallTargetGenerator::cmInstallTargetGenerator( std::string targetName, const char* dest, bool implib, @@ -209,8 +210,34 @@ void cmInstallTargetGenerator::GenerateScriptForConfig( // An import library looks like a static library. type = cmInstallType_STATIC_LIBRARY; } else if (this->Target->IsFrameworkOnApple()) { - // There is a bug in cmInstallCommand if this fails. - assert(this->NamelinkMode == NamelinkModeNone); + // FIXME: In principle we should be able to + // assert(this->NamelinkMode == NamelinkModeNone); + // but since the current install() command implementation checks + // the FRAMEWORK property immediately instead of delaying until + // generate time, it is possible for project code to set the + // property after calling install(). In such a case, the install() + // command will use the LIBRARY code path and create two install + // generators, one for the namelink component (NamelinkModeOnly) + // and one for the primary artifact component (NamelinkModeSkip). + // Historically this was not diagnosed and resulted in silent + // installation of a framework to the LIBRARY destination. + // Retain that behavior and warn about the case. + switch (this->NamelinkMode) { + case NamelinkModeNone: + // Normal case. + break; + case NamelinkModeOnly: + // Assume the NamelinkModeSkip instance will warn and install. + return; + case NamelinkModeSkip: { + std::string e = "Target '" + this->Target->GetName() + + "' was changed to a FRAMEWORK sometime after install(). " + "This may result in the wrong install DESTINATION. " + "Set the FRAMEWORK property earlier."; + this->Target->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage( + MessageType::AUTHOR_WARNING, e, this->GetBacktrace()); + } break; + } // Install the whole framework directory. type = cmInstallType_DIRECTORY; @@ -765,10 +792,22 @@ void cmInstallTargetGenerator::AddStripRule(std::ostream& os, Indent indent, return; } + std::string stripArgs; + + // macOS 'strip' is picky, executables need '-u -r' and dylibs need '-x'. + if (this->Target->Target->GetMakefile()->IsOn("APPLE")) { + if (this->Target->GetType() == cmStateEnums::SHARED_LIBRARY || + this->Target->GetType() == cmStateEnums::MODULE_LIBRARY) { + stripArgs = "-x "; + } else if (this->Target->GetType() == cmStateEnums::EXECUTABLE) { + stripArgs = "-u -r "; + } + } + os << indent << "if(CMAKE_INSTALL_DO_STRIP)\n"; os << indent << " execute_process(COMMAND \"" << this->Target->Target->GetMakefile()->GetDefinition("CMAKE_STRIP") - << "\" \"" << toDestDirPath << "\")\n"; + << "\" " << stripArgs << "\"" << toDestDirPath << "\")\n"; os << indent << "endif()\n"; } diff --git a/Source/cmJsonObjects.cxx b/Source/cmJsonObjects.cxx index 4b6b4d5..d723ced 100644 --- a/Source/cmJsonObjects.cxx +++ b/Source/cmJsonObjects.cxx @@ -323,7 +323,7 @@ static Json::Value DumpSourceFilesList( fileData.SetDefines(defines); } - fileData.IsGenerated = file->GetPropertyAsBool("GENERATED"); + fileData.IsGenerated = file->GetIsGenerated(); std::vector<std::string>& groupFileList = fileGroups[fileData]; groupFileList.push_back(file->GetFullPath()); } diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h index a016358..2355c32 100644 --- a/Source/cmLinkLineComputer.h +++ b/Source/cmLinkLineComputer.h @@ -16,13 +16,14 @@ class cmOutputConverter; class cmLinkLineComputer { - CM_DISABLE_COPY(cmLinkLineComputer) - public: cmLinkLineComputer(cmOutputConverter* outputConverter, cmStateDirectory const& stateDir); virtual ~cmLinkLineComputer(); + cmLinkLineComputer(cmLinkLineComputer const&) = delete; + cmLinkLineComputer& operator=(cmLinkLineComputer const&) = delete; + void SetUseWatcomQuote(bool useWatcomQuote); void SetForResponse(bool forResponse); void SetRelink(bool relink); diff --git a/Source/cmLinkLineDeviceComputer.h b/Source/cmLinkLineDeviceComputer.h index 81b48b3..cf66f64 100644 --- a/Source/cmLinkLineDeviceComputer.h +++ b/Source/cmLinkLineDeviceComputer.h @@ -18,13 +18,15 @@ class cmStateDirectory; class cmLinkLineDeviceComputer : public cmLinkLineComputer { - CM_DISABLE_COPY(cmLinkLineDeviceComputer) - public: cmLinkLineDeviceComputer(cmOutputConverter* outputConverter, cmStateDirectory const& stateDir); ~cmLinkLineDeviceComputer() override; + cmLinkLineDeviceComputer(cmLinkLineDeviceComputer const&) = delete; + cmLinkLineDeviceComputer& operator=(cmLinkLineDeviceComputer const&) = + delete; + std::string ComputeLinkLibraries(cmComputeLinkInformation& cli, std::string const& stdLibString) override; @@ -34,13 +36,15 @@ public: class cmNinjaLinkLineDeviceComputer : public cmLinkLineDeviceComputer { - CM_DISABLE_COPY(cmNinjaLinkLineDeviceComputer) - public: cmNinjaLinkLineDeviceComputer(cmOutputConverter* outputConverter, cmStateDirectory const& stateDir, cmGlobalNinjaGenerator const* gg); + cmNinjaLinkLineDeviceComputer(cmNinjaLinkLineDeviceComputer const&) = delete; + cmNinjaLinkLineDeviceComputer& operator=( + cmNinjaLinkLineDeviceComputer const&) = delete; + std::string ConvertToLinkReference(std::string const& input) const override; private: diff --git a/Source/cmLocale.h b/Source/cmLocale.h index 174f0f0..3580ec8 100644 --- a/Source/cmLocale.h +++ b/Source/cmLocale.h @@ -10,16 +10,18 @@ class cmLocaleRAII { - CM_DISABLE_COPY(cmLocaleRAII) - public: cmLocaleRAII() : OldLocale(setlocale(LC_CTYPE, nullptr)) { setlocale(LC_CTYPE, ""); } + ~cmLocaleRAII() { setlocale(LC_CTYPE, this->OldLocale.c_str()); } + cmLocaleRAII(cmLocaleRAII const&) = delete; + cmLocaleRAII& operator=(cmLocaleRAII const&) = delete; + private: std::string OldLocale; }; diff --git a/Source/cmMSVC60LinkLineComputer.h b/Source/cmMSVC60LinkLineComputer.h index 31223ec..d767914 100644 --- a/Source/cmMSVC60LinkLineComputer.h +++ b/Source/cmMSVC60LinkLineComputer.h @@ -15,12 +15,14 @@ class cmStateDirectory; class cmMSVC60LinkLineComputer : public cmLinkLineComputer { - CM_DISABLE_COPY(cmMSVC60LinkLineComputer) - public: cmMSVC60LinkLineComputer(cmOutputConverter* outputConverter, cmStateDirectory const& stateDir); + cmMSVC60LinkLineComputer(cmMSVC60LinkLineComputer const&) = delete; + cmMSVC60LinkLineComputer& operator=(cmMSVC60LinkLineComputer const&) = + delete; + std::string ConvertToLinkReference(std::string const& input) const override; }; diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index 3ae8034..ab139c0 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -3749,8 +3749,7 @@ int cmMakefile::ConfigureFile(const char* infile, const char* outfile, } if (copyonly) { - if (!cmSystemTools::CopyFileIfDifferent(sinfile.c_str(), - soutfile.c_str())) { + if (!cmSystemTools::CopyFileIfDifferent(sinfile, soutfile)) { return 0; } } else { @@ -3801,8 +3800,7 @@ int cmMakefile::ConfigureFile(const char* infile, const char* outfile, // close the files before attempting to copy fin.close(); fout.close(); - if (!cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(), - soutfile.c_str())) { + if (!cmSystemTools::CopyFileIfDifferent(tempOutputFile, soutfile)) { res = 0; } else { cmSystemTools::SetPermissions(soutfile, perm); diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 2bd44e2..70a5689 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -65,8 +65,6 @@ public: */ class cmMakefile { - CM_DISABLE_COPY(cmMakefile) - public: /* Mark a variable as used */ void MarkVariableAsUsed(const std::string& var); @@ -84,6 +82,9 @@ public: */ ~cmMakefile(); + cmMakefile(cmMakefile const&) = delete; + cmMakefile& operator=(cmMakefile const&) = delete; + cmDirectoryId GetDirectoryId() const; bool ReadListFile(const std::string& filename); @@ -780,15 +781,18 @@ public: /** Helper class to push and pop scopes automatically. */ class ScopePushPop { - CM_DISABLE_COPY(ScopePushPop) public: ScopePushPop(cmMakefile* m) : Makefile(m) { this->Makefile->PushScope(); } + ~ScopePushPop() { this->Makefile->PopScope(); } + ScopePushPop(ScopePushPop const&) = delete; + ScopePushPop& operator=(ScopePushPop const&) = delete; + private: cmMakefile* Makefile; }; diff --git a/Source/cmNinjaLinkLineComputer.h b/Source/cmNinjaLinkLineComputer.h index 0ed53f4..b2b2e84 100644 --- a/Source/cmNinjaLinkLineComputer.h +++ b/Source/cmNinjaLinkLineComputer.h @@ -16,13 +16,14 @@ class cmStateDirectory; class cmNinjaLinkLineComputer : public cmLinkLineComputer { - CM_DISABLE_COPY(cmNinjaLinkLineComputer) - public: cmNinjaLinkLineComputer(cmOutputConverter* outputConverter, cmStateDirectory const& stateDir, cmGlobalNinjaGenerator const* gg); + cmNinjaLinkLineComputer(cmNinjaLinkLineComputer const&) = delete; + cmNinjaLinkLineComputer& operator=(cmNinjaLinkLineComputer const&) = delete; + std::string ConvertToLinkReference(std::string const& input) const override; private: diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index edb0ef3..5d76dc2 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -173,8 +173,28 @@ void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags, bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const { - return (this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" + - lang) == "msvc"); + std::string const& deptype = + this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" + lang); + if (deptype == "msvc") { + return true; + } + if (deptype == "intel") { + // Ninja does not really define "intel", but we use it to switch based + // on whether this environment supports "gcc" or "msvc" deptype. + if (!this->GetGlobalGenerator()->SupportsMultilineDepfile()) { + // This ninja version is too old to support the Intel depfile format. + // Fall back to msvc deptype. + return true; + } + if ((this->Makefile->GetHomeDirectory().find(' ') != std::string::npos) || + (this->Makefile->GetHomeOutputDirectory().find(' ') != + std::string::npos)) { + // The Intel compiler does not properly escape spaces in a depfile. + // Fall back to msvc deptype. + return true; + } + } + return false; } // TODO: Refactor with @@ -630,10 +650,6 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) } } else { deptype = "gcc"; - const char* langdeptype = mf->GetDefinition("CMAKE_NINJA_DEPTYPE_" + lang); - if (langdeptype) { - deptype = langdeptype; - } depfile = "$DEP_FILE"; const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang; std::string depfileFlags = mf->GetSafeDefinition(flagsName); @@ -984,7 +1000,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement( // (either attached to this source file or another one), assume that one of // the target dependencies, OBJECT_DEPENDS or header file custom commands // will rebuild the file. - if (source->GetPropertyAsBool("GENERATED") && + if (source->GetIsGenerated() && !source->GetPropertyAsBool("__CMAKE_GENERATED_BY_CMAKE") && !source->GetCustomCommand() && !this->GetGlobalGenerator()->HasCustomCommandOutput(sourceFileName)) { diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx index d2133ed..6acc7ef 100644 --- a/Source/cmQTWrapCPPCommand.cxx +++ b/Source/cmQTWrapCPPCommand.cxx @@ -50,7 +50,7 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args, if (cmSystemTools::FileIsFullPath(*j)) { hname = *j; } else { - if (curr && curr->GetPropertyAsBool("GENERATED")) { + if (curr && curr->GetIsGenerated()) { hname = this->Makefile->GetCurrentBinaryDirectory(); } else { hname = this->Makefile->GetCurrentSourceDirectory(); diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx index 25dcd1a..43b1fb9 100644 --- a/Source/cmQTWrapUICommand.cxx +++ b/Source/cmQTWrapUICommand.cxx @@ -58,7 +58,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args, if (cmSystemTools::FileIsFullPath(*j)) { uiName = *j; } else { - if (curr && curr->GetPropertyAsBool("GENERATED")) { + if (curr && curr->GetIsGenerated()) { uiName = this->Makefile->GetCurrentBinaryDirectory(); } else { uiName = this->Makefile->GetCurrentSourceDirectory(); diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx index 1d7f6d1..41d29e8 100644 --- a/Source/cmQtAutoGenInitializer.cxx +++ b/Source/cmQtAutoGenInitializer.cxx @@ -686,7 +686,7 @@ bool cmQtAutoGenInitializer::InitScanFiles() if ((this->Moc.Enabled && !sf->GetPropertyAsBool("SKIP_AUTOMOC")) || (this->Uic.Enabled && !sf->GetPropertyAsBool("SKIP_AUTOUIC"))) { // Register source - const bool generated = sf->GetPropertyAsBool("GENERATED"); + const bool generated = sf->GetIsGenerated(); if (fileType == cmSystemTools::HEADER_FILE_FORMAT) { if (generated) { this->AutogenTarget.HeadersGenerated.push_back(absPath); @@ -712,7 +712,7 @@ bool cmQtAutoGenInitializer::InitScanFiles() qrc.QrcFile = cmSystemTools::GetRealPath(fPath); qrc.QrcName = cmSystemTools::GetFilenameWithoutLastExtension(qrc.QrcFile); - qrc.Generated = sf->GetPropertyAsBool("GENERATED"); + qrc.Generated = sf->GetIsGenerated(); // RCC options { std::string const opts = sf->GetSafeProperty("AUTORCC_OPTIONS"); @@ -1370,7 +1370,7 @@ void cmQtAutoGenInitializer::AddGeneratedSource(std::string const& filename, this->Target->AddSource(filename, prepend); } -static unsigned int CharPtrToInt(const char* const input) +static unsigned int CharPtrToUInt(const char* const input) { unsigned long tmp = 0; if (input != nullptr && cmSystemTools::StringToULong(input, &tmp)) { @@ -1379,36 +1379,43 @@ static unsigned int CharPtrToInt(const char* const input) return 0; } -static unsigned int StringToInt(const std::string& input) -{ - return input.empty() ? 0 : CharPtrToInt(input.c_str()); -} - -static std::vector<cmQtAutoGenInitializer::IntegerVersion> GetKnownQtVersions( +static std::vector<cmQtAutoGen::IntegerVersion> GetKnownQtVersions( cmGeneratorTarget const* target) { cmMakefile* makefile = target->Target->GetMakefile(); - - std::vector<cmQtAutoGenInitializer::IntegerVersion> result; - for (const std::string& prefix : - std::vector<std::string>({ "Qt6Core", "Qt5Core", "QT" })) { - auto tmp = cmQtAutoGenInitializer::IntegerVersion( - StringToInt(makefile->GetSafeDefinition(prefix + "_VERSION_MAJOR")), - StringToInt(makefile->GetSafeDefinition(prefix + "_VERSION_MINOR"))); - if (tmp.Major != 0) { - result.push_back(tmp); + std::vector<cmQtAutoGen::IntegerVersion> result; + // Adds a version to the result (nullptr safe) + auto addVersion = [&result](const char* major, const char* minor) { + cmQtAutoGen::IntegerVersion ver(CharPtrToUInt(major), + CharPtrToUInt(minor)); + if (ver.Major != 0) { + result.emplace_back(ver); } + }; + // Qt version variable prefixes + std::array<std::string, 3> const prefixes{ { "Qt6Core", "Qt5Core", "QT" } }; + + // Read versions from variables + for (const std::string& prefix : prefixes) { + addVersion(makefile->GetDefinition(prefix + "_VERSION_MAJOR"), + makefile->GetDefinition(prefix + "_VERSION_MINOR")); + } + + // Read versions from directory properties + for (const std::string& prefix : prefixes) { + addVersion(makefile->GetProperty(prefix + "_VERSION_MAJOR"), + makefile->GetProperty(prefix + "_VERSION_MINOR")); } return result; } -std::pair<cmQtAutoGenInitializer::IntegerVersion, unsigned int> +std::pair<cmQtAutoGen::IntegerVersion, unsigned int> cmQtAutoGenInitializer::GetQtVersion(cmGeneratorTarget const* target) { std::pair<IntegerVersion, unsigned int> res( IntegerVersion(), - CharPtrToInt(target->GetLinkInterfaceDependentStringProperty( + CharPtrToUInt(target->GetLinkInterfaceDependentStringProperty( "QT_MAJOR_VERSION", ""))); auto knownQtVersions = GetKnownQtVersions(target); diff --git a/Source/cmQtAutoGenerator.h b/Source/cmQtAutoGenerator.h index 2b9cbc6..9956a99 100644 --- a/Source/cmQtAutoGenerator.h +++ b/Source/cmQtAutoGenerator.h @@ -24,7 +24,6 @@ class cmMakefile; /// @brief Base class for QtAutoGen gernerators class cmQtAutoGenerator : public cmQtAutoGen { - CM_DISABLE_COPY(cmQtAutoGenerator) public: // -- Types @@ -245,6 +244,9 @@ public: cmQtAutoGenerator(); virtual ~cmQtAutoGenerator(); + cmQtAutoGenerator(cmQtAutoGenerator const&) = delete; + cmQtAutoGenerator& operator=(cmQtAutoGenerator const&) = delete; + // -- Run bool Run(std::string const& infoFile, std::string const& config); diff --git a/Source/cmQtAutoGeneratorMocUic.cxx b/Source/cmQtAutoGeneratorMocUic.cxx index bc496ac..0ba5224 100644 --- a/Source/cmQtAutoGeneratorMocUic.cxx +++ b/Source/cmQtAutoGeneratorMocUic.cxx @@ -1111,8 +1111,7 @@ void cmQtAutoGeneratorMocUic::WorkerT::UVProcessStart(uv_async_t* handle) { std::lock_guard<std::mutex> lock(wrk.ProcessMutex_); if (wrk.Process_ && !wrk.Process_->IsStarted()) { - wrk.Process_->start(handle->loop, - std::bind(&WorkerT::UVProcessFinished, &wrk)); + wrk.Process_->start(handle->loop, [&wrk] { wrk.UVProcessFinished(); }); } } } diff --git a/Source/cmQtAutoGeneratorMocUic.h b/Source/cmQtAutoGeneratorMocUic.h index 0df2cff..32a6006 100644 --- a/Source/cmQtAutoGeneratorMocUic.h +++ b/Source/cmQtAutoGeneratorMocUic.h @@ -28,11 +28,13 @@ class cmMakefile; // @brief AUTOMOC and AUTOUIC generator class cmQtAutoGeneratorMocUic : public cmQtAutoGenerator { - CM_DISABLE_COPY(cmQtAutoGeneratorMocUic) public: cmQtAutoGeneratorMocUic(); ~cmQtAutoGeneratorMocUic() override; + cmQtAutoGeneratorMocUic(cmQtAutoGeneratorMocUic const&) = delete; + cmQtAutoGeneratorMocUic& operator=(cmQtAutoGeneratorMocUic const&) = delete; + public: // -- Types class WorkerT; @@ -63,7 +65,6 @@ public: /// class BaseSettingsT { - CM_DISABLE_COPY(BaseSettingsT) public: // -- Volatile methods BaseSettingsT(FileSystem* fileSystem) @@ -75,6 +76,9 @@ public: { } + BaseSettingsT(BaseSettingsT const&) = delete; + BaseSettingsT& operator=(BaseSettingsT const&) = delete; + // -- Const methods std::string AbsoluteBuildPath(std::string const& relativePath) const; bool FindHeader(std::string& header, @@ -103,13 +107,15 @@ public: /// class MocSettingsT { - CM_DISABLE_COPY(MocSettingsT) public: MocSettingsT(FileSystem* fileSys) : FileSys(fileSys) { } + MocSettingsT(MocSettingsT const&) = delete; + MocSettingsT& operator=(MocSettingsT const&) = delete; + // -- Const methods bool skipped(std::string const& fileName) const; std::string FindMacro(std::string const& content) const; @@ -145,9 +151,12 @@ public: /// class UicSettingsT { - CM_DISABLE_COPY(UicSettingsT) public: UicSettingsT() = default; + + UicSettingsT(UicSettingsT const&) = delete; + UicSettingsT& operator=(UicSettingsT const&) = delete; + // -- Const methods bool skipped(std::string const& fileName) const; @@ -166,10 +175,13 @@ public: /// class JobT { - CM_DISABLE_COPY(JobT) public: JobT() = default; virtual ~JobT() = default; + + JobT(JobT const&) = delete; + JobT& operator=(JobT const&) = delete; + // -- Abstract processing interface virtual void Process(WorkerT& wrk) = 0; }; @@ -293,11 +305,13 @@ public: /// class WorkerT { - CM_DISABLE_COPY(WorkerT) public: WorkerT(cmQtAutoGeneratorMocUic* gen, uv_loop_t* uvLoop); ~WorkerT(); + WorkerT(WorkerT const&) = delete; + WorkerT& operator=(WorkerT const&) = delete; + // -- Const accessors cmQtAutoGeneratorMocUic& Gen() const { return *Gen_; } Logger& Log() const { return Gen_->Log(); } diff --git a/Source/cmQtAutoGeneratorRcc.cxx b/Source/cmQtAutoGeneratorRcc.cxx index 43ff172..021a15f 100644 --- a/Source/cmQtAutoGeneratorRcc.cxx +++ b/Source/cmQtAutoGeneratorRcc.cxx @@ -10,8 +10,6 @@ #include "cmSystemTools.h" #include "cmUVHandlePtr.h" -#include <functional> - // -- Class methods cmQtAutoGeneratorRcc::cmQtAutoGeneratorRcc() @@ -662,8 +660,7 @@ bool cmQtAutoGeneratorRcc::StartProcess( Process_ = cm::make_unique<ReadOnlyProcessT>(); Process_->setup(&ProcessResult_, mergedOutput, command, workingDirectory); // Start process - if (!Process_->start(UVLoop(), - std::bind(&cm::uv_async_ptr::send, &UVRequest()))) { + if (!Process_->start(UVLoop(), [this] { UVRequest().send(); })) { Log().ErrorFile(GeneratorT::RCC, QrcFile_, ProcessResult_.ErrorMessage); Error_ = true; // Clean up diff --git a/Source/cmQtAutoGeneratorRcc.h b/Source/cmQtAutoGeneratorRcc.h index 1148071..1ec1c4a 100644 --- a/Source/cmQtAutoGeneratorRcc.h +++ b/Source/cmQtAutoGeneratorRcc.h @@ -17,11 +17,13 @@ class cmMakefile; // @brief AUTORCC generator class cmQtAutoGeneratorRcc : public cmQtAutoGenerator { - CM_DISABLE_COPY(cmQtAutoGeneratorRcc) public: cmQtAutoGeneratorRcc(); ~cmQtAutoGeneratorRcc() override; + cmQtAutoGeneratorRcc(cmQtAutoGeneratorRcc const&) = delete; + cmQtAutoGeneratorRcc& operator=(cmQtAutoGeneratorRcc const&) = delete; + private: // -- Types diff --git a/Source/cmScriptGenerator.h b/Source/cmScriptGenerator.h index 5792ba8..e334d5b 100644 --- a/Source/cmScriptGenerator.h +++ b/Source/cmScriptGenerator.h @@ -44,13 +44,14 @@ inline std::ostream& operator<<(std::ostream& os, */ class cmScriptGenerator { - CM_DISABLE_COPY(cmScriptGenerator) - public: cmScriptGenerator(std::string config_var, std::vector<std::string> configurations); virtual ~cmScriptGenerator(); + cmScriptGenerator(cmScriptGenerator const&) = delete; + cmScriptGenerator& operator=(cmScriptGenerator const&) = delete; + void Generate(std::ostream& os, const std::string& config, std::vector<std::string> const& configurationTypes); diff --git a/Source/cmServer.cxx b/Source/cmServer.cxx index f7d3879..e740c05 100644 --- a/Source/cmServer.cxx +++ b/Source/cmServer.cxx @@ -96,11 +96,16 @@ void cmServer::ProcessRequest(cmConnection* connection, return; } - cmSystemTools::SetMessageCallback(reportMessage, - const_cast<cmServerRequest*>(&request)); + cmSystemTools::SetMessageCallback( + [&request](const char* msg, const char* title) { + reportMessage(msg, title, request); + }); + if (this->Protocol) { this->Protocol->CMakeInstance()->SetProgressCallback( - reportProgress, const_cast<cmServerRequest*>(&request)); + [&request](const char* msg, float prog) { + reportProgress(msg, prog, request); + }); this->WriteResponse(connection, this->Protocol->Process(request), debug.get()); } else { @@ -150,28 +155,25 @@ void cmServer::PrintHello(cmConnection* connection) const this->WriteJsonObject(connection, hello, nullptr); } -void cmServer::reportProgress(const char* msg, float progress, void* data) +void cmServer::reportProgress(const char* msg, float progress, + const cmServerRequest& request) { - const cmServerRequest* request = static_cast<const cmServerRequest*>(data); - assert(request); if (progress < 0.0f || progress > 1.0f) { - request->ReportMessage(msg, ""); + request.ReportMessage(msg, ""); } else { - request->ReportProgress(0, static_cast<int>(progress * 1000), 1000, msg); + request.ReportProgress(0, static_cast<int>(progress * 1000), 1000, msg); } } void cmServer::reportMessage(const char* msg, const char* title, - bool& /* cancel */, void* data) + const cmServerRequest& request) { - const cmServerRequest* request = static_cast<const cmServerRequest*>(data); - assert(request); assert(msg); std::string titleString; if (title) { titleString = title; } - request->ReportMessage(std::string(msg), titleString); + request.ReportMessage(std::string(msg), titleString); } cmServerResponse cmServer::SetProtocolVersion(const cmServerRequest& request) diff --git a/Source/cmServer.h b/Source/cmServer.h index ca37ce2..e1ed27a 100644 --- a/Source/cmServer.h +++ b/Source/cmServer.h @@ -88,14 +88,15 @@ protected: class cmServer : public cmServerBase { - CM_DISABLE_COPY(cmServer) - public: class DebugInfo; cmServer(cmConnection* conn, bool supportExperimental); ~cmServer() override; + cmServer(cmServer const&) = delete; + cmServer& operator=(cmServer const&) = delete; + bool Serve(std::string* errorMessage) override; cmFileMonitor* FileMonitor() const; @@ -118,9 +119,10 @@ public: void OnConnected(cmConnection* connection) override; private: - static void reportProgress(const char* msg, float progress, void* data); - static void reportMessage(const char* msg, const char* title, bool& cancel, - void* data); + static void reportProgress(const char* msg, float progress, + const cmServerRequest& request); + static void reportMessage(const char* msg, const char* title, + const cmServerRequest& request); // Handle requests: cmServerResponse SetProtocolVersion(const cmServerRequest& request); diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx index c3c8156..203ee93 100644 --- a/Source/cmServerProtocol.cxx +++ b/Source/cmServerProtocol.cxx @@ -222,13 +222,22 @@ bool cmServerProtocol1::DoActivate(const cmServerRequest& request, std::string* errorMessage) { std::string sourceDirectory = request.Data[kSOURCE_DIRECTORY_KEY].asString(); - const std::string buildDirectory = - request.Data[kBUILD_DIRECTORY_KEY].asString(); + std::string buildDirectory = request.Data[kBUILD_DIRECTORY_KEY].asString(); std::string generator = request.Data[kGENERATOR_KEY].asString(); std::string extraGenerator = request.Data[kEXTRA_GENERATOR_KEY].asString(); std::string toolset = request.Data[kTOOLSET_KEY].asString(); std::string platform = request.Data[kPLATFORM_KEY].asString(); + // normalize source and build directory + if (!sourceDirectory.empty()) { + sourceDirectory = cmSystemTools::CollapseFullPath(sourceDirectory); + cmSystemTools::ConvertToUnixSlashes(sourceDirectory); + } + if (!buildDirectory.empty()) { + buildDirectory = cmSystemTools::CollapseFullPath(buildDirectory); + cmSystemTools::ConvertToUnixSlashes(buildDirectory); + } + if (buildDirectory.empty()) { setErrorMessage(errorMessage, std::string("\"") + kBUILD_DIRECTORY_KEY + diff --git a/Source/cmServerProtocol.h b/Source/cmServerProtocol.h index 2d1507b..2f55a20 100644 --- a/Source/cmServerProtocol.h +++ b/Source/cmServerProtocol.h @@ -71,12 +71,13 @@ private: class cmServerProtocol { - CM_DISABLE_COPY(cmServerProtocol) - public: cmServerProtocol() = default; virtual ~cmServerProtocol() = default; + cmServerProtocol(cmServerProtocol const&) = delete; + cmServerProtocol& operator=(cmServerProtocol const&) = delete; + virtual std::pair<int, int> ProtocolVersion() const = 0; virtual bool IsExperimental() const = 0; virtual const cmServerResponse Process(const cmServerRequest& request) = 0; diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx index 1a2d1c6..6bd071c 100644 --- a/Source/cmSetCommand.cxx +++ b/Source/cmSetCommand.cxx @@ -4,6 +4,7 @@ #include "cmAlgorithms.h" #include "cmMakefile.h" +#include "cmMessageType.h" #include "cmState.h" #include "cmStateTypes.h" #include "cmSystemTools.h" @@ -37,6 +38,14 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args, putEnvArg += args[1]; cmSystemTools::PutEnv(putEnvArg); } + // if there's extra arguments, warn user + // that they are ignored by this command. + if (args.size() > 2) { + std::string m = "Only the first value argument is used when setting " + "an environment variable. Argument '" + + args[2] + "' and later are unused."; + this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, m); + } return true; } @@ -112,7 +121,15 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args, if (cache) { std::string::size_type cacheStart = args.size() - 3 - (force ? 1 : 0); - type = cmState::StringToCacheEntryType(args[cacheStart + 1].c_str()); + if (!cmState::StringToCacheEntryType(args[cacheStart + 1].c_str(), type)) { + std::string m = "implicitly converting '" + args[cacheStart + 1] + + "' to 'STRING' type."; + this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, m); + // Setting this may not be required, since it's + // initialized as a string. Keeping this here to + // ensure that the type is actually converting to a string. + type = cmStateEnums::STRING; + } docstring = args[cacheStart + 2].c_str(); } diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx index efc6bb5..d05fb68 100644 --- a/Source/cmSourceFile.cxx +++ b/Source/cmSourceFile.cxx @@ -2,7 +2,8 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmSourceFile.h" -#include <sstream> +#include <array> +#include <utility> #include "cmCustomCommand.h" #include "cmGlobalGenerator.h" @@ -17,8 +18,6 @@ cmSourceFile::cmSourceFile(cmMakefile* mf, const std::string& name, cmSourceFileLocationKind kind) : Location(mf, name, kind) { - this->CustomCommand = nullptr; - this->FindFullPathFailed = false; } cmSourceFile::~cmSourceFile() @@ -32,6 +31,8 @@ std::string const& cmSourceFile::GetExtension() const } const std::string cmSourceFile::propLANGUAGE = "LANGUAGE"; +const std::string cmSourceFile::propLOCATION = "LOCATION"; +const std::string cmSourceFile::propGENERATED = "GENERATED"; void cmSourceFile::SetObjectLibrary(std::string const& objlib) { @@ -112,92 +113,88 @@ std::string const& cmSourceFile::GetFullPath() const bool cmSourceFile::FindFullPath(std::string* error) { - // If this method has already failed once do not try again. - if (this->FindFullPathFailed) { - return false; - } - - // If the file is generated compute the location without checking on - // disk. - if (this->GetPropertyAsBool("GENERATED")) { + // If the file is generated compute the location without checking on disk. + if (this->GetIsGenerated()) { // The file is either already a full path or is relative to the // build directory for the target. this->Location.DirectoryUseBinary(); - this->FullPath = this->Location.GetDirectory(); - this->FullPath += "/"; - this->FullPath += this->Location.GetName(); + this->FullPath = this->Location.GetFullPath(); return true; } - // The file is not generated. It must exist on disk. - cmMakefile const* mf = this->Location.GetMakefile(); - const char* tryDirs[3] = { nullptr, nullptr, nullptr }; - if (this->Location.DirectoryIsAmbiguous()) { - tryDirs[0] = mf->GetCurrentSourceDirectory().c_str(); - tryDirs[1] = mf->GetCurrentBinaryDirectory().c_str(); - } else { - tryDirs[0] = ""; + // If this method has already failed once do not try again. + if (this->FindFullPathFailed) { + return false; } - cmake const* const cmakeInst = mf->GetCMakeInstance(); - std::vector<std::string> const& srcExts = cmakeInst->GetSourceExtensions(); - std::vector<std::string> const& hdrExts = cmakeInst->GetHeaderExtensions(); - for (const char* const* di = tryDirs; *di; ++di) { - std::string tryPath = this->Location.GetDirectory(); - if (!tryPath.empty()) { - tryPath += "/"; - } - tryPath += this->Location.GetName(); - tryPath = cmSystemTools::CollapseFullPath(tryPath, *di); - if (this->TryFullPath(tryPath, "")) { + // The file is not generated. It must exist on disk. + cmMakefile const* makefile = this->Location.GetMakefile(); + // Location path + std::string const lPath = this->Location.GetFullPath(); + // List of extension lists + std::array<std::vector<std::string> const*, 2> const extsLists = { + { &makefile->GetCMakeInstance()->GetSourceExtensions(), + &makefile->GetCMakeInstance()->GetHeaderExtensions() } + }; + + // Tries to find the file in a given directory + auto findInDir = [this, &extsLists, &lPath](std::string const& dir) -> bool { + // Compute full path + std::string const fullPath = cmSystemTools::CollapseFullPath(lPath, dir); + // Try full path + if (cmSystemTools::FileExists(fullPath)) { + this->FullPath = fullPath; return true; } - for (std::string const& ext : srcExts) { - if (this->TryFullPath(tryPath, ext)) { - return true; + // Try full path with extension + for (auto exts : extsLists) { + for (std::string const& ext : *exts) { + if (!ext.empty()) { + std::string extPath = fullPath; + extPath += '.'; + extPath += ext; + if (cmSystemTools::FileExists(extPath)) { + this->FullPath = extPath; + return true; + } + } } } - for (std::string const& ext : hdrExts) { - if (this->TryFullPath(tryPath, ext)) { - return true; - } + // File not found + return false; + }; + + // Try to find the file in various directories + if (this->Location.DirectoryIsAmbiguous()) { + if (findInDir(makefile->GetCurrentSourceDirectory()) || + findInDir(makefile->GetCurrentBinaryDirectory())) { + return true; + } + } else { + if (findInDir({})) { + return true; } } - std::ostringstream e; - std::string missing = this->Location.GetDirectory(); - if (!missing.empty()) { - missing += "/"; - } - missing += this->Location.GetName(); - e << "Cannot find source file:\n " << missing << "\nTried extensions"; - for (std::string const& srcExt : srcExts) { - e << " ." << srcExt; - } - for (std::string const& ext : hdrExts) { - e << " ." << ext; + // Compose error + std::string err; + err += "Cannot find source file:\n "; + err += lPath; + err += "\nTried extensions"; + for (auto exts : extsLists) { + for (std::string const& ext : *exts) { + err += " ."; + err += ext; + } } - if (error) { - *error = e.str(); + if (error != nullptr) { + *error = std::move(err); } else { - this->Location.GetMakefile()->IssueMessage(MessageType::FATAL_ERROR, - e.str()); + makefile->IssueMessage(MessageType::FATAL_ERROR, err); } this->FindFullPathFailed = true; - return false; -} -bool cmSourceFile::TryFullPath(const std::string& path, const std::string& ext) -{ - std::string tryPath = path; - if (!ext.empty()) { - tryPath += "."; - tryPath += ext; - } - if (cmSystemTools::FileExists(tryPath)) { - this->FullPath = tryPath; - return true; - } + // File not found return false; } @@ -242,12 +239,22 @@ bool cmSourceFile::Matches(cmSourceFileLocation const& loc) void cmSourceFile::SetProperty(const std::string& prop, const char* value) { this->Properties.SetProperty(prop, value); + + // Update IsGenerated flag + if (prop == propGENERATED) { + this->IsGenerated = cmSystemTools::IsOn(value); + } } void cmSourceFile::AppendProperty(const std::string& prop, const char* value, bool asString) { this->Properties.AppendProperty(prop, value, asString); + + // Update IsGenerated flag + if (prop == propGENERATED) { + this->IsGenerated = this->GetPropertyAsBool(propGENERATED); + } } const char* cmSourceFile::GetPropertyForUser(const std::string& prop) @@ -266,7 +273,7 @@ const char* cmSourceFile::GetPropertyForUser(const std::string& prop) // cmSourceFileLocation class to commit to a particular full path to // the source file as late as possible. If the users requests the // LOCATION property we must commit now. - if (prop == "LOCATION") { + if (prop == propLOCATION) { // Commit to a location. this->GetFullPath(); } @@ -278,7 +285,7 @@ const char* cmSourceFile::GetPropertyForUser(const std::string& prop) const char* cmSourceFile::GetProperty(const std::string& prop) const { // Check for computed properties. - if (prop == "LOCATION") { + if (prop == propLOCATION) { if (this->FullPath.empty()) { return nullptr; } diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h index ab0f229..a82a58a 100644 --- a/Source/cmSourceFile.h +++ b/Source/cmSourceFile.h @@ -55,6 +55,10 @@ public: command like get_property or get_source_file_property. */ const char* GetPropertyForUser(const std::string& prop); + ///! Checks is the GENERATED property is set and true + /// @return Equivalent to GetPropertyAsBool("GENERATED") + bool GetIsGenerated() const { return this->IsGenerated; } + /** * The full path to the file. The non-const version of this method * may attempt to locate the file on disk and finalize its location. @@ -106,20 +110,22 @@ public: private: cmSourceFileLocation Location; cmPropertyMap Properties; - cmCustomCommand* CustomCommand; + cmCustomCommand* CustomCommand = nullptr; std::string Extension; std::string Language; std::string FullPath; std::string ObjectLibrary; std::vector<std::string> Depends; - bool FindFullPathFailed; + bool FindFullPathFailed = false; + bool IsGenerated = false; bool FindFullPath(std::string* error); - bool TryFullPath(const std::string& path, const std::string& ext); void CheckExtension(); void CheckLanguage(std::string const& ext); static const std::string propLANGUAGE; + static const std::string propLOCATION; + static const std::string propGENERATED; }; // TODO: Factor out into platform information modules. diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx index 13d2d7e..acacba2 100644 --- a/Source/cmSourceFileLocation.cxx +++ b/Source/cmSourceFileLocation.cxx @@ -42,6 +42,16 @@ cmSourceFileLocation::cmSourceFileLocation(cmMakefile const* mf, } } +std::string cmSourceFileLocation::GetFullPath() const +{ + std::string path = this->GetDirectory(); + if (!path.empty()) { + path += '/'; + } + path += this->GetName(); + return path; +} + void cmSourceFileLocation::Update(cmSourceFileLocation const& loc) { if (this->AmbiguousDirectory && !loc.AmbiguousDirectory) { diff --git a/Source/cmSourceFileLocation.h b/Source/cmSourceFileLocation.h index 82747ba..87040b8 100644 --- a/Source/cmSourceFileLocation.h +++ b/Source/cmSourceFileLocation.h @@ -34,6 +34,8 @@ public: cmSourceFileLocation(); cmSourceFileLocation(const cmSourceFileLocation& loc); + cmSourceFileLocation& operator=(cmSourceFileLocation const&) = delete; + /** * Return whether the given source file location could refers to the * same source file as this location given the level of ambiguity in @@ -78,6 +80,11 @@ public: const std::string& GetName() const { return this->Name; } /** + * Get the full file path composed of GetDirectory() and GetName(). + */ + std::string GetFullPath() const; + + /** * Get the cmMakefile instance for which the source file was created. */ cmMakefile const* GetMakefile() const { return this->Makefile; } @@ -94,8 +101,6 @@ private: // Update the location with additional knowledge. void Update(cmSourceFileLocation const& loc); void UpdateExtension(const std::string& name); - - cmSourceFileLocation& operator=(const cmSourceFileLocation& loc) = delete; }; #endif diff --git a/Source/cmState.cxx b/Source/cmState.cxx index fdd7b3d..a08e9b8 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -75,14 +75,23 @@ const char* cmState::CacheEntryTypeToString(cmStateEnums::CacheEntryType type) cmStateEnums::CacheEntryType cmState::StringToCacheEntryType(const char* s) { + cmStateEnums::CacheEntryType type = cmStateEnums::STRING; + StringToCacheEntryType(s, type); + return type; +} + +bool cmState::StringToCacheEntryType(const char* s, + cmStateEnums::CacheEntryType& type) +{ int i = 0; while (cmCacheEntryTypes[i]) { if (strcmp(s, cmCacheEntryTypes[i]) == 0) { - return static_cast<cmStateEnums::CacheEntryType>(i); + type = static_cast<cmStateEnums::CacheEntryType>(i); + return true; } ++i; } - return cmStateEnums::STRING; + return false; } bool cmState::IsCacheEntryType(std::string const& key) diff --git a/Source/cmState.h b/Source/cmState.h index e447485..f755f83 100644 --- a/Source/cmState.h +++ b/Source/cmState.h @@ -65,6 +65,8 @@ public: cmStateSnapshot Pop(cmStateSnapshot const& originSnapshot); static cmStateEnums::CacheEntryType StringToCacheEntryType(const char*); + static bool StringToCacheEntryType(const char*, + cmStateEnums::CacheEntryType& type); static const char* CacheEntryTypeToString(cmStateEnums::CacheEntryType); static bool IsCacheEntryType(std::string const& key); diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index f7de3aa..5d8c079 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -76,6 +76,15 @@ # include <malloc.h> /* for malloc/free on QNX */ #endif +namespace { + +cmSystemTools::InterruptCallback s_InterruptCallback; +cmSystemTools::MessageCallback s_MessageCallback; +cmSystemTools::OutputCallback s_StderrCallback; +cmSystemTools::OutputCallback s_StdoutCallback; + +} // namespace + static bool cm_isspace(char c) { return ((c & 0x80) == 0) && isspace(c); @@ -161,15 +170,6 @@ bool cmSystemTools::s_FatalErrorOccured = false; bool cmSystemTools::s_DisableMessages = false; bool cmSystemTools::s_ForceUnixPaths = false; -cmSystemTools::MessageCallback cmSystemTools::s_MessageCallback; -cmSystemTools::OutputCallback cmSystemTools::s_StdoutCallback; -cmSystemTools::OutputCallback cmSystemTools::s_StderrCallback; -cmSystemTools::InterruptCallback cmSystemTools::s_InterruptCallback; -void* cmSystemTools::s_MessageCallbackClientData; -void* cmSystemTools::s_StdoutCallbackClientData; -void* cmSystemTools::s_StderrCallbackClientData; -void* cmSystemTools::s_InterruptCallbackClientData; - // replace replace with with as many times as it shows up in source. // write the result into source. #if defined(_WIN32) && !defined(__CYGWIN__) @@ -277,42 +277,38 @@ void cmSystemTools::Error(const std::string& m) cmSystemTools::Message(message, "Error"); } -void cmSystemTools::SetInterruptCallback(InterruptCallback f, void* clientData) +void cmSystemTools::SetInterruptCallback(InterruptCallback f) { - s_InterruptCallback = f; - s_InterruptCallbackClientData = clientData; + s_InterruptCallback = std::move(f); } bool cmSystemTools::GetInterruptFlag() { if (s_InterruptCallback) { - return (*s_InterruptCallback)(s_InterruptCallbackClientData); + return s_InterruptCallback(); } return false; } -void cmSystemTools::SetMessageCallback(MessageCallback f, void* clientData) +void cmSystemTools::SetMessageCallback(MessageCallback f) { - s_MessageCallback = f; - s_MessageCallbackClientData = clientData; + s_MessageCallback = std::move(f); } -void cmSystemTools::SetStdoutCallback(OutputCallback f, void* clientData) +void cmSystemTools::SetStdoutCallback(OutputCallback f) { - s_StdoutCallback = f; - s_StdoutCallbackClientData = clientData; + s_StdoutCallback = std::move(f); } -void cmSystemTools::SetStderrCallback(OutputCallback f, void* clientData) +void cmSystemTools::SetStderrCallback(OutputCallback f) { - s_StderrCallback = f; - s_StderrCallbackClientData = clientData; + s_StderrCallback = std::move(f); } void cmSystemTools::Stderr(const std::string& s) { if (s_StderrCallback) { - (*s_StderrCallback)(s.c_str(), s.length(), s_StderrCallbackClientData); + s_StderrCallback(s); } else { std::cerr << s << std::flush; } @@ -321,7 +317,7 @@ void cmSystemTools::Stderr(const std::string& s) void cmSystemTools::Stdout(const std::string& s) { if (s_StdoutCallback) { - (*s_StdoutCallback)(s.c_str(), s.length(), s_StdoutCallbackClientData); + s_StdoutCallback(s); } else { std::cout << s << std::flush; } @@ -333,8 +329,7 @@ void cmSystemTools::Message(const char* m1, const char* title) return; } if (s_MessageCallback) { - (*s_MessageCallback)(m1, title, s_DisableMessages, - s_MessageCallbackClientData); + s_MessageCallback(m1, title); return; } std::cerr << m1 << std::endl << std::flush; @@ -940,17 +935,12 @@ std::string cmSystemTools::FileExistsInParentDirectories(const char* fname, return ""; } -bool cmSystemTools::cmCopyFile(const char* source, const char* destination) +bool cmSystemTools::cmCopyFile(const std::string& source, + const std::string& destination) { return Superclass::CopyFileAlways(source, destination); } -bool cmSystemTools::CopyFileIfDifferent(const char* source, - const char* destination) -{ - return Superclass::CopyFileIfDifferent(source, destination); -} - #ifdef _WIN32 cmSystemTools::WindowsFileRetry cmSystemTools::GetWindowsFileRetry() { diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h index b1d5751..fcb2cce 100644 --- a/Source/cmSystemTools.h +++ b/Source/cmSystemTools.h @@ -10,6 +10,7 @@ #include "cmProcessOutput.h" #include "cmsys/Process.h" #include "cmsys/SystemTools.hxx" // IWYU pragma: export +#include <functional> #include <stddef.h> #include <string> #include <vector> @@ -55,15 +56,13 @@ public: */ static std::string TrimWhitespace(const std::string& s); - typedef void (*MessageCallback)(const char*, const char*, bool&, void*); + using MessageCallback = std::function<void(const char*, const char*)>; /** * Set the function used by GUIs to display error messages * Function gets passed: message as a const char*, - * title as a const char*, and a reference to bool that when - * set to false, will disable further messages (cancel). + * title as a const char*. */ - static void SetMessageCallback(MessageCallback f, - void* clientData = nullptr); + static void SetMessageCallback(MessageCallback f); /** * Display an error message. @@ -81,19 +80,18 @@ public: Message(m.c_str(), title); } - typedef void (*OutputCallback)(const char*, size_t length, void*); + using OutputCallback = std::function<void(std::string const&)>; ///! Send a string to stdout static void Stdout(const std::string& s); - static void SetStdoutCallback(OutputCallback, void* clientData = nullptr); + static void SetStdoutCallback(OutputCallback f); ///! Send a string to stderr static void Stderr(const std::string& s); - static void SetStderrCallback(OutputCallback, void* clientData = nullptr); + static void SetStderrCallback(OutputCallback f); - typedef bool (*InterruptCallback)(void*); - static void SetInterruptCallback(InterruptCallback f, - void* clientData = nullptr); + using InterruptCallback = std::function<bool()>; + static void SetInterruptCallback(InterruptCallback f); static bool GetInterruptFlag(); ///! Return true if there was an error at any point. @@ -179,8 +177,8 @@ public: std::vector<std::string>& files, int type = 0); ///! Copy a file. - static bool cmCopyFile(const char* source, const char* destination); - static bool CopyFileIfDifferent(const char* source, const char* destination); + static bool cmCopyFile(const std::string& source, + const std::string& destination); /** Rename a file or directory within a single disk volume (atomic if possible). */ @@ -410,11 +408,13 @@ public: original environment. */ class SaveRestoreEnvironment { - CM_DISABLE_COPY(SaveRestoreEnvironment) public: SaveRestoreEnvironment(); ~SaveRestoreEnvironment(); + SaveRestoreEnvironment(SaveRestoreEnvironment const&) = delete; + SaveRestoreEnvironment& operator=(SaveRestoreEnvironment const&) = delete; + private: std::vector<std::string> Env; }; @@ -548,14 +548,6 @@ private: static bool s_FatalErrorOccured; static bool s_DisableMessages; static bool s_DisableRunCommandOutput; - static MessageCallback s_MessageCallback; - static OutputCallback s_StdoutCallback; - static OutputCallback s_StderrCallback; - static InterruptCallback s_InterruptCallback; - static void* s_MessageCallbackClientData; - static void* s_StdoutCallbackClientData; - static void* s_StderrCallbackClientData; - static void* s_InterruptCallbackClientData; }; #endif diff --git a/Source/cmTestGenerator.h b/Source/cmTestGenerator.h index f26d2ff..8b9cf78 100644 --- a/Source/cmTestGenerator.h +++ b/Source/cmTestGenerator.h @@ -20,14 +20,15 @@ class cmTest; */ class cmTestGenerator : public cmScriptGenerator { - CM_DISABLE_COPY(cmTestGenerator) - public: cmTestGenerator(cmTest* test, std::vector<std::string> const& configurations = std::vector<std::string>()); ~cmTestGenerator() override; + cmTestGenerator(cmTestGenerator const&) = delete; + cmTestGenerator& operator=(cmTestGenerator const&) = delete; + void Compute(cmLocalGenerator* lg); /** Test if this generator installs the test for a given configuration. */ diff --git a/Source/cmUVHandlePtr.h b/Source/cmUVHandlePtr.h index d42969e..992c429 100644 --- a/Source/cmUVHandlePtr.h +++ b/Source/cmUVHandlePtr.h @@ -61,7 +61,8 @@ protected: void allocate(void* data = nullptr); public: - CM_DISABLE_COPY(uv_handle_ptr_base_) + uv_handle_ptr_base_(uv_handle_ptr_base_ const&) = delete; + uv_handle_ptr_base_& operator=(uv_handle_ptr_base_ const&) = delete; uv_handle_ptr_base_(uv_handle_ptr_base_&&) noexcept; uv_handle_ptr_base_& operator=(uv_handle_ptr_base_&&) noexcept; diff --git a/Source/cmUseMangledMesaCommand.cxx b/Source/cmUseMangledMesaCommand.cxx index 01ef5cb..9648b21 100644 --- a/Source/cmUseMangledMesaCommand.cxx +++ b/Source/cmUseMangledMesaCommand.cxx @@ -100,6 +100,6 @@ void cmUseMangledMesaCommand::CopyAndFullPathMesaHeader(const char* source, // close the files before attempting to copy fin.close(); fout.close(); - cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(), outFile.c_str()); + cmSystemTools::CopyFileIfDifferent(tempOutputFile, outFile); cmSystemTools::RemoveFile(tempOutputFile); } diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx index 9d7dd07..178e717 100644 --- a/Source/cmVisualStudio10TargetGenerator.cxx +++ b/Source/cmVisualStudio10TargetGenerator.cxx @@ -376,7 +376,13 @@ void cmVisualStudio10TargetGenerator::Generate() { Elem e0(BuildFileStream, "Project"); e0.Attribute("DefaultTargets", "Build"); - e0.Attribute("ToolsVersion", this->GlobalGenerator->GetToolsVersion()); + const char* toolsVersion = this->GlobalGenerator->GetToolsVersion(); + if (this->GlobalGenerator->GetVersion() == + cmGlobalVisualStudioGenerator::VS12 && + this->GlobalGenerator->TargetsWindowsCE()) { + toolsVersion = "4.0"; + } + e0.Attribute("ToolsVersion", toolsVersion); e0.Attribute("xmlns", "http://schemas.microsoft.com/developer/msbuild/2003"); @@ -3884,8 +3890,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences(Elem& e0) this->WriteDotNetReferenceCustomTags(e2, name); // If the dependency target is not managed (compiled with /clr or - // C# target) we cannot reference it and have to set - // 'ReferenceOutputAssembly' to false. + // C# target) and not a WinRT component we cannot reference it and + // have to set 'ReferenceOutputAssembly' to false. auto referenceNotManaged = dt->GetManagedType("") < cmGeneratorTarget::ManagedType::Mixed; // Workaround to check for manually set /clr flags. @@ -3902,6 +3908,12 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences(Elem& e0) if (referenceNotManaged && dt->GetType() == cmStateEnums::STATIC_LIBRARY) { referenceNotManaged = !dt->IsCSharpOnly(); } + + // Referencing WinRT components is okay. + if (referenceNotManaged) { + referenceNotManaged = !dt->GetPropertyAsBool("VS_WINRT_COMPONENT"); + } + if (referenceNotManaged) { e2.Element("ReferenceOutputAssembly", "false"); e2.Element("CopyToOutputDirectory", "Never"); diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h index 7d24e88..5901004 100644 --- a/Source/cmVisualStudio10TargetGenerator.h +++ b/Source/cmVisualStudio10TargetGenerator.h @@ -25,12 +25,16 @@ class cmVS10GeneratorOptions; class cmVisualStudio10TargetGenerator { - CM_DISABLE_COPY(cmVisualStudio10TargetGenerator) - public: cmVisualStudio10TargetGenerator(cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg); ~cmVisualStudio10TargetGenerator(); + + cmVisualStudio10TargetGenerator(cmVisualStudio10TargetGenerator const&) = + delete; + cmVisualStudio10TargetGenerator& operator=( + cmVisualStudio10TargetGenerator const&) = delete; + void Generate(); private: diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h index b080654..1df8a09 100644 --- a/Source/cmXMLWriter.h +++ b/Source/cmXMLWriter.h @@ -16,12 +16,13 @@ class cmXMLWriter { - CM_DISABLE_COPY(cmXMLWriter) - public: cmXMLWriter(std::ostream& output, std::size_t level = 0); ~cmXMLWriter(); + cmXMLWriter(cmXMLWriter const&) = delete; + cmXMLWriter& operator=(cmXMLWriter const&) = delete; + void StartDocument(const char* encoding = "UTF-8"); void EndDocument(); diff --git a/Source/cm_thread.hxx b/Source/cm_thread.hxx index 84e6a5c..b1f0645 100644 --- a/Source/cm_thread.hxx +++ b/Source/cm_thread.hxx @@ -11,18 +11,18 @@ namespace cm { class shared_mutex { uv_rwlock_t _M_; - CM_DISABLE_COPY(shared_mutex) public: shared_mutex() { uv_rwlock_init(&_M_); } ~shared_mutex() { uv_rwlock_destroy(&_M_); } - void lock() { uv_rwlock_wrlock(&_M_); } + shared_mutex(shared_mutex const&) = delete; + shared_mutex& operator=(shared_mutex const&) = delete; + void lock() { uv_rwlock_wrlock(&_M_); } void unlock() { uv_rwlock_wrunlock(&_M_); } void lock_shared() { uv_rwlock_rdlock(&_M_); } - void unlock_shared() { uv_rwlock_rdunlock(&_M_); } }; @@ -30,7 +30,6 @@ template <typename T> class shared_lock { T& _mutex; - CM_DISABLE_COPY(shared_lock) public: shared_lock(T& m) @@ -38,7 +37,12 @@ public: { _mutex.lock_shared(); } + ~shared_lock() { _mutex.unlock_shared(); } + + shared_lock(shared_lock const&) = delete; + shared_lock& operator=(shared_lock const&) = delete; }; } + #endif diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 70316f1..8023298 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -157,8 +157,6 @@ cmake::cmake(Role role, cmState::Mode mode) #endif this->GlobalGenerator = nullptr; - this->ProgressCallback = nullptr; - this->ProgressCallbackClientData = nullptr; this->CurrentWorkingMode = NORMAL_MODE; #ifdef CMAKE_BUILD_WITH_CMAKE @@ -439,7 +437,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } } std::cout << "loading initial cache file " << path << "\n"; - this->ReadListFile(args, path.c_str()); + this->ReadListFile(args, path); } else if (arg.find("-P", 0) == 0) { i++; if (i >= args.size()) { @@ -453,7 +451,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } // Register fake project commands that hint misuse in script mode. GetProjectCommandsInScriptMode(this->State); - this->ReadListFile(args, path.c_str()); + this->ReadListFile(args, path); } else if (arg.find("--find-package", 0) == 0) { findPackageMode = true; } @@ -467,7 +465,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } void cmake::ReadListFile(const std::vector<std::string>& args, - const char* path) + const std::string& path) { // if a generator was not yet created, temporarily create one cmGlobalGenerator* gg = this->GetGlobalGenerator(); @@ -480,7 +478,7 @@ void cmake::ReadListFile(const std::vector<std::string>& args, } // read in the list file to fill the cache - if (path) { + if (!path.empty()) { this->CurrentSnapshot = this->State->Reset(); std::string homeDir = this->GetHomeDirectory(); std::string homeOutputDir = this->GetHomeOutputDirectory(); @@ -501,7 +499,7 @@ void cmake::ReadListFile(const std::vector<std::string>& args, mf.SetArgcArgv(args); } if (!mf.ReadListFile(path)) { - cmSystemTools::Error("Error processing file: ", path); + cmSystemTools::Error("Error processing file: " + path); } this->SetHomeDirectory(homeDir); this->SetHomeOutputDirectory(homeOutputDir); @@ -1608,14 +1606,14 @@ void cmake::PreLoadCMakeFiles() if (!pre_load.empty()) { pre_load += "/PreLoad.cmake"; if (cmSystemTools::FileExists(pre_load)) { - this->ReadListFile(args, pre_load.c_str()); + this->ReadListFile(args, pre_load); } } pre_load = this->GetHomeOutputDirectory(); if (!pre_load.empty()) { pre_load += "/PreLoad.cmake"; if (cmSystemTools::FileExists(pre_load)) { - this->ReadListFile(args, pre_load.c_str()); + this->ReadListFile(args, pre_load); } } } @@ -1922,17 +1920,15 @@ bool cmake::DeleteCache(const std::string& path) return this->State->DeleteCache(path); } -void cmake::SetProgressCallback(ProgressCallbackType f, void* cd) +void cmake::SetProgressCallback(ProgressCallbackType f) { - this->ProgressCallback = f; - this->ProgressCallbackClientData = cd; + this->ProgressCallback = std::move(f); } void cmake::UpdateProgress(const char* msg, float prog) { if (this->ProgressCallback && !this->State->GetIsInTryCompile()) { - (*this->ProgressCallback)(msg, prog, this->ProgressCallbackClientData); - return; + this->ProgressCallback(msg, prog); } } @@ -2358,7 +2354,7 @@ int cmake::GetSystemInformation(std::vector<std::string>& args) outFile += "/CMakeLists.txt"; // Copy file - if (!cmSystemTools::cmCopyFile(inFile.c_str(), outFile.c_str())) { + if (!cmSystemTools::cmCopyFile(inFile, outFile)) { std::cerr << "Error copying file \"" << inFile << "\" to \"" << outFile << "\".\n"; return 1; @@ -2617,7 +2613,7 @@ int cmake::Build(int jobs, const std::string& dir, const std::string& target, cachePath + "/" + "CMakeFiles/" + "VerifyGlobs.cmake"; if (cmSystemTools::FileExists(globVerifyScript)) { std::vector<std::string> args; - this->ReadListFile(args, globVerifyScript.c_str()); + this->ReadListFile(args, globVerifyScript); } } diff --git a/Source/cmake.h b/Source/cmake.h index c60fc33..53d44f1 100644 --- a/Source/cmake.h +++ b/Source/cmake.h @@ -5,6 +5,7 @@ #include "cmConfigure.h" // IWYU pragma: keep +#include <functional> #include <map> #include <memory> // IWYU pragma: keep #include <set> @@ -59,8 +60,6 @@ struct cmDocumentationEntry; class cmake { - CM_DISABLE_COPY(cmake) - public: enum Role { @@ -119,6 +118,9 @@ public: /// Destructor ~cmake(); + cmake(cmake const&) = delete; + cmake& operator=(cmake const&) = delete; + #if defined(CMAKE_BUILD_WITH_CMAKE) Json::Value ReportVersionJson() const; Json::Value ReportCapabilitiesJson(bool haveServerMode) const; @@ -271,7 +273,7 @@ public: ///! Parse command line arguments that might set cache values bool SetCacheArgs(const std::vector<std::string>&); - typedef void (*ProgressCallbackType)(const char* msg, float progress, void*); + using ProgressCallbackType = std::function<void(const char*, float)>; /** * Set the function used by GUIs to receive progress updates * Function gets passed: message as a const char*, a progress @@ -279,7 +281,7 @@ public: * number provided may be negative in cases where a message is * to be displayed without any progress percentage. */ - void SetProgressCallback(ProgressCallbackType f, void* clientData = nullptr); + void SetProgressCallback(ProgressCallbackType f); ///! this is called by generators to update the progress void UpdateProgress(const char* msg, float prog); @@ -442,7 +444,6 @@ public: protected: void RunCheckForUnusedVariables(); - void InitializeProperties(); int HandleDeleteCacheVariables(const std::string& var); typedef std::vector<cmGlobalGeneratorFactory*> RegisteredGeneratorsVector; @@ -462,7 +463,8 @@ protected: std::string GeneratorToolset; ///! read in a cmake list file to initialize the cache - void ReadListFile(const std::vector<std::string>& args, const char* path); + void ReadListFile(const std::vector<std::string>& args, + const std::string& path); bool FindPackage(const std::vector<std::string>& args); ///! Check if CMAKE_CACHEFILE_DIR is set. If it is not, delete the log file. @@ -485,8 +487,6 @@ protected: private: ProgressCallbackType ProgressCallback; - void* ProgressCallbackClientData; - bool InTryCompile; WorkingMode CurrentWorkingMode; bool DebugOutput; bool Trace; @@ -534,18 +534,6 @@ private: void AppendGlobalGeneratorsDocumentation(std::vector<cmDocumentationEntry>&); void AppendExtraGeneratorsDocumentation(std::vector<cmDocumentationEntry>&); - - /** - * Convert a message type between a warning and an error, based on the state - * of the error output CMake variables, in the cache. - */ - MessageType ConvertMessageType(MessageType t) const; - - /* - * Check if messages of this type should be output, based on the state of the - * warning and error output CMake variables, in the cache. - */ - bool IsMessageTypeVisible(MessageType t) const; }; #define CMAKE_STANDARD_OPTIONS_TABLE \ diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx index 0ec2552..890b74e 100644 --- a/Source/cmakemain.cxx +++ b/Source/cmakemain.cxx @@ -117,9 +117,8 @@ int do_cmake(int ac, char const* const* av); static int do_build(int ac, char const* const* av); static int do_open(int ac, char const* const* av); -static cmMakefile* cmakemainGetMakefile(void* clientdata) +static cmMakefile* cmakemainGetMakefile(cmake* cm) { - cmake* cm = static_cast<cmake*>(clientdata); if (cm && cm->GetDebugOutput()) { cmGlobalGenerator* gg = cm->GetGlobalGenerator(); if (gg) { @@ -129,10 +128,10 @@ static cmMakefile* cmakemainGetMakefile(void* clientdata) return nullptr; } -static std::string cmakemainGetStack(void* clientdata) +static std::string cmakemainGetStack(cmake* cm) { std::string msg; - cmMakefile* mf = cmakemainGetMakefile(clientdata); + cmMakefile* mf = cmakemainGetMakefile(cm); if (mf) { msg = mf->FormatListFileStack(); if (!msg.empty()) { @@ -144,15 +143,14 @@ static std::string cmakemainGetStack(void* clientdata) } static void cmakemainMessageCallback(const char* m, const char* /*unused*/, - bool& /*unused*/, void* clientdata) + cmake* cm) { - std::cerr << m << cmakemainGetStack(clientdata) << std::endl << std::flush; + std::cerr << m << cmakemainGetStack(cm) << std::endl << std::flush; } -static void cmakemainProgressCallback(const char* m, float prog, - void* clientdata) +static void cmakemainProgressCallback(const char* m, float prog, cmake* cm) { - cmMakefile* mf = cmakemainGetMakefile(clientdata); + cmMakefile* mf = cmakemainGetMakefile(cm); std::string dir; if ((mf) && (strstr(m, "Configuring") == m) && (prog < 0)) { dir = " "; @@ -163,8 +161,7 @@ static void cmakemainProgressCallback(const char* m, float prog, } if ((prog < 0) || (!dir.empty())) { - std::cout << "-- " << m << dir << cmakemainGetStack(clientdata) - << std::endl; + std::cout << "-- " << m << dir << cmakemainGetStack(cm) << std::endl; } std::cout.flush(); @@ -322,8 +319,12 @@ int do_cmake(int ac, char const* const* av) cmake cm(role, mode); cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); - cmSystemTools::SetMessageCallback(cmakemainMessageCallback, &cm); - cm.SetProgressCallback(cmakemainProgressCallback, &cm); + cmSystemTools::SetMessageCallback([&cm](const char* msg, const char* title) { + cmakemainMessageCallback(msg, title, &cm); + }); + cm.SetProgressCallback([&cm](const char* msg, float prog) { + cmakemainProgressCallback(msg, prog, &cm); + }); cm.SetWorkingMode(workingMode); int res = cm.Run(args, view_only); @@ -498,8 +499,12 @@ static int do_build(int ac, char const* const* av) } cmake cm(cmake::RoleInternal, cmState::Unknown); - cmSystemTools::SetMessageCallback(cmakemainMessageCallback, &cm); - cm.SetProgressCallback(cmakemainProgressCallback, &cm); + cmSystemTools::SetMessageCallback([&cm](const char* msg, const char* title) { + cmakemainMessageCallback(msg, title, &cm); + }); + cm.SetProgressCallback([&cm](const char* msg, float prog) { + cmakemainProgressCallback(msg, prog, &cm); + }); return cm.Build(jobs, dir, target, config, nativeOptions, clean, verbose); #endif } @@ -536,8 +541,12 @@ static int do_open(int ac, char const* const* av) } cmake cm(cmake::RoleInternal, cmState::Unknown); - cmSystemTools::SetMessageCallback(cmakemainMessageCallback, &cm); - cm.SetProgressCallback(cmakemainProgressCallback, &cm); + cmSystemTools::SetMessageCallback([&cm](const char* msg, const char* title) { + cmakemainMessageCallback(msg, title, &cm); + }); + cm.SetProgressCallback([&cm](const char* msg, float prog) { + cmakemainProgressCallback(msg, prog, &cm); + }); return cm.Open(dir, false) ? 0 : 1; #endif } diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index 2a3aedd..d20c5d2 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -482,8 +482,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // If error occurs we want to continue copying next files. bool return_value = false; for (std::string::size_type cc = 2; cc < args.size() - 1; cc++) { - if (!cmSystemTools::cmCopyFile(args[cc].c_str(), - args.back().c_str())) { + if (!cmSystemTools::cmCopyFile(args[cc], args.back())) { std::cerr << "Error copying file \"" << args[cc] << "\" to \"" << args.back() << "\".\n"; return_value = true; @@ -505,8 +504,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // If error occurs we want to continue copying next files. bool return_value = false; for (std::string::size_type cc = 2; cc < args.size() - 1; cc++) { - if (!cmSystemTools::CopyFileIfDifferent(args[cc].c_str(), - args.back().c_str())) { + if (!cmSystemTools::CopyFileIfDifferent(args[cc], args.back())) { std::cerr << "Error copying file (if different) from \"" << args[cc] << "\" to \"" << args.back() << "\".\n"; return_value = true; @@ -1304,7 +1302,7 @@ bool cmcmd::SymlinkInternal(std::string const& file, std::string const& link) cmSystemTools::RemoveFile(link); } #if defined(_WIN32) && !defined(__CYGWIN__) - return cmSystemTools::CopyFileAlways(file.c_str(), link.c_str()); + return cmSystemTools::CopyFileAlways(file, link); #else std::string linktext = cmSystemTools::GetFilenameName(file); return cmSystemTools::CreateSymlink(linktext, link); diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt index b33aa80..e7da994 100644 --- a/Source/kwsys/CMakeLists.txt +++ b/Source/kwsys/CMakeLists.txt @@ -42,6 +42,10 @@ # SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR}) # INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR}) # +# KWSYS_CXX_STANDARD = A value for CMAKE_CXX_STANDARD within KWSys. +# Set to empty string to use no default value. +# KWSYS_CXX_COMPILE_FEATURES = target_compile_features arguments for KWSys. +# # Optional settings to setup install rules are as follows: # # KWSYS_INSTALL_BIN_DIR = The installation target directories into @@ -82,25 +86,17 @@ # any outside mailing list and no documentation of the change will be # written. -CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3 FATAL_ERROR) +CMAKE_MINIMUM_REQUIRED(VERSION 3.1 FATAL_ERROR) FOREACH(p - CMP0022 # CMake 2.8, Define link interface - required by android_mk export - CMP0025 # CMake 3.0, Compiler id for Apple Clang is now AppleClang. - CMP0042 # CMake 3.0, MACOSX_RPATH is enabled by default. - CMP0048 # CMake 3.0, Let the project command manage version variables. CMP0056 # CMake 3.2, Honor link flags in try_compile() source-file signature. CMP0063 # CMake 3.3, Honor visibility properties for all target types. + CMP0067 # CMake 3.8, Honor language standard in try_compile source-file signature. CMP0069 # CMake 3.9, INTERPROCEDURAL_OPTIMIZATION is enforced when enabled. ) IF(POLICY ${p}) CMAKE_POLICY(SET ${p} NEW) ENDIF() ENDFOREACH() -SET(CMAKE_LEGACY_CYGWIN_WIN32 0) - -IF(CMAKE_VERSION VERSION_LESS 3.0) - SET(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE 0) -ENDIF() #----------------------------------------------------------------------------- # If a namespace is not specified, use "kwsys" and enable testing. @@ -121,6 +117,12 @@ SET_PROPERTY(DIRECTORY "KWSYS_HEADER(%)=<${KWSYS_NAMESPACE}/%>" ) +if(KWSYS_CXX_STANDARD) + set(CMAKE_CXX_STANDARD "${KWSYS_CXX_STANDARD}") +elseif(NOT DEFINED CMAKE_CXX_STANDARD AND NOT DEFINED KWSYS_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) +endif() + # Select library components. IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR) SET(KWSYS_ENABLE_C 1) @@ -884,6 +886,8 @@ IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS) ${KWSYS_TARGET_INTERFACE}) TARGET_SOURCES(${KWSYS_TARGET_LINK} INTERFACE $<TARGET_OBJECTS:${KWSYS_TARGET_OBJECT}>) + target_compile_features(${KWSYS_TARGET_OBJECT} PRIVATE ${KWSYS_CXX_COMPILE_FEATURES}) + target_compile_features(${KWSYS_TARGET_INTERFACE} INTERFACE ${KWSYS_CXX_COMPILE_FEATURES}) ELSE() SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE}) SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE}) @@ -892,6 +896,7 @@ IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS) SET(KWSYS_LINK_DEPENDENCY PUBLIC) ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE} ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS}) + target_compile_features(${KWSYS_TARGET_INTERFACE} PUBLIC ${KWSYS_CXX_COMPILE_FEATURES}) ENDIF() if (KWSYS_ALIAS_TARGET) add_library(${KWSYS_ALIAS_TARGET} ALIAS ${KWSYS_TARGET_INTERFACE}) diff --git a/Source/kwsys/kwsysPlatformTests.cmake b/Source/kwsys/kwsysPlatformTests.cmake index 5386a49..28d3f68 100644 --- a/Source/kwsys/kwsysPlatformTests.cmake +++ b/Source/kwsys/kwsysPlatformTests.cmake @@ -7,11 +7,16 @@ SET(KWSYS_PLATFORM_TEST_FILE_CXX kwsysPlatformTestsCXX.cxx) MACRO(KWSYS_PLATFORM_TEST lang var description invert) IF(NOT DEFINED ${var}_COMPILED) MESSAGE(STATUS "${description}") + set(maybe_cxx_standard "") + if(CMAKE_VERSION VERSION_LESS 3.8 AND CMAKE_CXX_STANDARD) + set(maybe_cxx_standard "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}") + endif() TRY_COMPILE(${var}_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/${KWSYS_PLATFORM_TEST_FILE_${lang}} COMPILE_DEFINITIONS -DTEST_${var} ${KWSYS_PLATFORM_TEST_DEFINES} ${KWSYS_PLATFORM_TEST_EXTRA_FLAGS} CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=${KWSYS_PLATFORM_TEST_LINK_LIBRARIES}" + ${maybe_cxx_standard} OUTPUT_VARIABLE OUTPUT) IF(${var}_COMPILED) FILE(APPEND diff --git a/Tests/RunCMake/Autogen/QtInFunction.cmake b/Tests/RunCMake/Autogen/QtInFunction.cmake new file mode 100644 index 0000000..a44bc5a --- /dev/null +++ b/Tests/RunCMake/Autogen/QtInFunction.cmake @@ -0,0 +1,13 @@ +enable_language(CXX) + +function (use_autogen target) + find_package(Qt5 REQUIRED COMPONENTS Core Widgets) + set(Qt5Core_VERSION_MAJOR "${Qt5Core_VERSION_MAJOR}" PARENT_SCOPE) + set(Qt5Core_VERSION_MINOR "${Qt5Core_VERSION_MINOR}" PARENT_SCOPE) + set_property(TARGET "${target}" PROPERTY AUTOMOC 1) + set_property(TARGET "${target}" PROPERTY AUTORCC 1) + set_property(TARGET "${target}" PROPERTY AUTOUIC 1) +endfunction () + +add_executable(main empty.cpp) +use_autogen(main) diff --git a/Tests/RunCMake/Autogen/QtInFunctionNested-stderr.txt b/Tests/RunCMake/Autogen/QtInFunctionNested-stderr.txt new file mode 100644 index 0000000..1c6660a --- /dev/null +++ b/Tests/RunCMake/Autogen/QtInFunctionNested-stderr.txt @@ -0,0 +1,8 @@ +^CMake Warning \(dev\) in CMakeLists.txt: + AUTOGEN: No valid Qt version found for target main. AUTOMOC, AUTOUIC and + AUTORCC disabled. Consider adding: + + find_package\(Qt<QTVERSION> COMPONENTS Widgets\) + + to your CMakeLists.txt file. +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/Autogen/QtInFunctionNested.cmake b/Tests/RunCMake/Autogen/QtInFunctionNested.cmake new file mode 100644 index 0000000..5421ba0 --- /dev/null +++ b/Tests/RunCMake/Autogen/QtInFunctionNested.cmake @@ -0,0 +1,17 @@ +enable_language(CXX) + +function (use_autogen target) + find_package(Qt5 REQUIRED COMPONENTS Core Widgets) + set(Qt5Core_VERSION_MAJOR "${Qt5Core_VERSION_MAJOR}" PARENT_SCOPE) + set(Qt5Core_VERSION_MINOR "${Qt5Core_VERSION_MINOR}" PARENT_SCOPE) + set_property(TARGET "${target}" PROPERTY AUTOMOC 1) + set_property(TARGET "${target}" PROPERTY AUTORCC 1) + set_property(TARGET "${target}" PROPERTY AUTOUIC 1) +endfunction () + +function (wrap_autogen target) + use_autogen("${target}") +endfunction () + +add_executable(main empty.cpp) +wrap_autogen(main) diff --git a/Tests/RunCMake/Autogen/QtInFunctionProperty.cmake b/Tests/RunCMake/Autogen/QtInFunctionProperty.cmake new file mode 100644 index 0000000..35f1cd1 --- /dev/null +++ b/Tests/RunCMake/Autogen/QtInFunctionProperty.cmake @@ -0,0 +1,21 @@ +enable_language(CXX) + +function (use_autogen target) + find_package(Qt5 REQUIRED COMPONENTS Core Widgets) + set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + PROPERTY + Qt5Core_VERSION_MAJOR "${Qt5Core_VERSION_MAJOR}") + set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + PROPERTY + Qt5Core_VERSION_MINOR "${Qt5Core_VERSION_MINOR}") + set_property(TARGET "${target}" PROPERTY AUTOMOC 1) + set_property(TARGET "${target}" PROPERTY AUTORCC 1) + set_property(TARGET "${target}" PROPERTY AUTOUIC 1) +endfunction () + +function (wrap_autogen target) + use_autogen("${target}") +endfunction () + +add_executable(main empty.cpp) +wrap_autogen(main) diff --git a/Tests/RunCMake/Autogen/RunCMakeTest.cmake b/Tests/RunCMake/Autogen/RunCMakeTest.cmake index e52f28d..a31b67c 100644 --- a/Tests/RunCMake/Autogen/RunCMakeTest.cmake +++ b/Tests/RunCMake/Autogen/RunCMakeTest.cmake @@ -1,3 +1,8 @@ include(RunCMake) run_cmake(NoQt) +if (with_qt5) + run_cmake(QtInFunction) + run_cmake(QtInFunctionNested) + run_cmake(QtInFunctionProperty) +endif () diff --git a/Tests/RunCMake/CMakeLists.txt b/Tests/RunCMake/CMakeLists.txt index 2de90e7..1f3e5c3 100644 --- a/Tests/RunCMake/CMakeLists.txt +++ b/Tests/RunCMake/CMakeLists.txt @@ -150,7 +150,14 @@ if(NOT CMake_TEST_EXTERNAL_CMAKE) endif() add_RunCMake_test(AndroidTestUtilities) -add_RunCMake_test(Autogen) +set(autogen_with_qt5 FALSE) +if(CMake_TEST_Qt5) + find_package(Qt5Widgets QUIET NO_MODULE) +endif() +if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND) + set(autogen_with_qt5 TRUE) +endif () +add_RunCMake_test(Autogen -Dwith_qt5=${autogen_with_qt5}) add_RunCMake_test(BuildDepends) if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja") add_RunCMake_test(Byproducts) diff --git a/Tests/RunCMake/FetchContent/MakeAvailable-stdout.txt b/Tests/RunCMake/FetchContent/MakeAvailable-stdout.txt new file mode 100644 index 0000000..6e6c730 --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailable-stdout.txt @@ -0,0 +1,2 @@ +Confirmation project has been added +.*Confirmation script has been called diff --git a/Tests/RunCMake/FetchContent/MakeAvailable.cmake b/Tests/RunCMake/FetchContent/MakeAvailable.cmake new file mode 100644 index 0000000..a93f1f7 --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailable.cmake @@ -0,0 +1,20 @@ +include(FetchContent) + +FetchContent_Declare( + WithProject + SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/WithProject +) +FetchContent_Declare( + WithoutProject + SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/WithoutProject +) + +# Order is important and will be verified by test output +FetchContent_MakeAvailable(WithProject WithoutProject) + +get_property(addedWith GLOBAL PROPERTY FetchWithProject SET) +if(NOT addedWith) + message(SEND_ERROR "Subdir with CMakeLists.txt not added") +endif() + +include(${withoutproject_SOURCE_DIR}/confirmMessage.cmake) diff --git a/Tests/RunCMake/FetchContent/MakeAvailableTwice-stdout.txt b/Tests/RunCMake/FetchContent/MakeAvailableTwice-stdout.txt new file mode 100644 index 0000000..8d3b7c0 --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailableTwice-stdout.txt @@ -0,0 +1,4 @@ +-- Before first[ + ]+-- Confirmation project has been added[ + ]+-- Between both[ + ]+-- After last diff --git a/Tests/RunCMake/FetchContent/MakeAvailableTwice.cmake b/Tests/RunCMake/FetchContent/MakeAvailableTwice.cmake new file mode 100644 index 0000000..a9af020 --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailableTwice.cmake @@ -0,0 +1,12 @@ +include(FetchContent) + +FetchContent_Declare( + WithProject + SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/WithProject +) + +message(STATUS "Before first") +FetchContent_MakeAvailable(WithProject) +message(STATUS "Between both") +FetchContent_MakeAvailable(WithProject) +message(STATUS "After last") diff --git a/Tests/RunCMake/FetchContent/MakeAvailableUndeclared-result.txt b/Tests/RunCMake/FetchContent/MakeAvailableUndeclared-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailableUndeclared-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/FetchContent/MakeAvailableUndeclared-stderr.txt b/Tests/RunCMake/FetchContent/MakeAvailableUndeclared-stderr.txt new file mode 100644 index 0000000..9715b78 --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailableUndeclared-stderr.txt @@ -0,0 +1 @@ +No content details recorded for NoDetails diff --git a/Tests/RunCMake/FetchContent/MakeAvailableUndeclared.cmake b/Tests/RunCMake/FetchContent/MakeAvailableUndeclared.cmake new file mode 100644 index 0000000..bd57cbe --- /dev/null +++ b/Tests/RunCMake/FetchContent/MakeAvailableUndeclared.cmake @@ -0,0 +1,3 @@ +include(FetchContent) + +FetchContent_MakeAvailable(NoDetails) diff --git a/Tests/RunCMake/FetchContent/RunCMakeTest.cmake b/Tests/RunCMake/FetchContent/RunCMakeTest.cmake index 9c1ab66..e28ae96 100644 --- a/Tests/RunCMake/FetchContent/RunCMakeTest.cmake +++ b/Tests/RunCMake/FetchContent/RunCMakeTest.cmake @@ -11,6 +11,9 @@ run_cmake(VarDefinitions) run_cmake(GetProperties) run_cmake(DirOverrides) run_cmake(UsesTerminalOverride) +run_cmake(MakeAvailable) +run_cmake(MakeAvailableTwice) +run_cmake(MakeAvailableUndeclared) # We need to pass through CMAKE_GENERATOR and CMAKE_MAKE_PROGRAM # to ensure the test can run on machines where the build tool diff --git a/Tests/RunCMake/FetchContent/WithProject/CMakeLists.txt b/Tests/RunCMake/FetchContent/WithProject/CMakeLists.txt new file mode 100644 index 0000000..b6a3750 --- /dev/null +++ b/Tests/RunCMake/FetchContent/WithProject/CMakeLists.txt @@ -0,0 +1,5 @@ +cmake_minimum_required(VERSION 3.13) +project(WithProject LANGUAGES NONE) + +set_property(GLOBAL PROPERTY FetchWithProject YES) +message(STATUS "Confirmation project has been added") diff --git a/Tests/RunCMake/FetchContent/WithoutProject/confirmMessage.cmake b/Tests/RunCMake/FetchContent/WithoutProject/confirmMessage.cmake new file mode 100644 index 0000000..a2f5c61 --- /dev/null +++ b/Tests/RunCMake/FetchContent/WithoutProject/confirmMessage.cmake @@ -0,0 +1 @@ +message(STATUS "Confirmation script has been called") diff --git a/Tests/RunCMake/Framework/InstallBeforeFramework-stderr.txt b/Tests/RunCMake/Framework/InstallBeforeFramework-stderr.txt new file mode 100644 index 0000000..a3a7c6c --- /dev/null +++ b/Tests/RunCMake/Framework/InstallBeforeFramework-stderr.txt @@ -0,0 +1,7 @@ +^CMake Warning \(dev\) at InstallBeforeFramework.cmake:4 \(install\): + Target 'foo' was changed to a FRAMEWORK sometime after install\(\). This may + result in the wrong install DESTINATION. Set the FRAMEWORK property + earlier. +Call Stack \(most recent call first\): + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/Framework/InstallBeforeFramework.cmake b/Tests/RunCMake/Framework/InstallBeforeFramework.cmake new file mode 100644 index 0000000..3791dac --- /dev/null +++ b/Tests/RunCMake/Framework/InstallBeforeFramework.cmake @@ -0,0 +1,5 @@ +enable_language(C) + +add_library(foo SHARED foo.c) +install(TARGETS foo LIBRARY DESTINATION lib) +set_property(TARGET foo PROPERTY FRAMEWORK TRUE) diff --git a/Tests/RunCMake/Framework/RunCMakeTest.cmake b/Tests/RunCMake/Framework/RunCMakeTest.cmake index 4fc83f8..e705a31 100644 --- a/Tests/RunCMake/Framework/RunCMakeTest.cmake +++ b/Tests/RunCMake/Framework/RunCMakeTest.cmake @@ -1,5 +1,7 @@ include(RunCMake) +run_cmake(InstallBeforeFramework) + function(framework_layout_test Name Toolchain Type) set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${Toolchain}${Type}FrameworkLayout-build) set(RunCMake_TEST_NO_CLEAN 1) diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/ParseImplicitIncludeInfo.cmake b/Tests/RunCMake/ParseImplicitIncludeInfo/ParseImplicitIncludeInfo.cmake index a9029dc..ce8d45b 100644 --- a/Tests/RunCMake/ParseImplicitIncludeInfo/ParseImplicitIncludeInfo.cmake +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/ParseImplicitIncludeInfo.cmake @@ -21,6 +21,10 @@ set(targets freebsd-C-Clang-3.3.0 freebsd-CXX-Clang-3.3.0 freebsd-Fortran-GNU-4.6.4 linux-C-GNU-7.3.0 linux-CXX-GNU-7.3.0 linux-Fortran-GNU-7.3.0 linux-C-Intel-18.0.0.20170811 linux-CXX-Intel-18.0.0.20170811 + linux-C-PGI-18.10.1 linux-CXX-PGI-18.10.1 + linux-Fortran-PGI-18.10.1 linux_pgf77-Fortran-PGI-18.10.1 + linux_nostdinc-C-PGI-18.10.1 linux_nostdinc-CXX-PGI-18.10.1 + linux_nostdinc-Fortran-PGI-18.10.1 linux-C-XL-12.1.0 linux-CXX-XL-12.1.0 linux-Fortran-XL-14.1.0 linux_nostdinc-C-XL-12.1.0 linux_nostdinc-CXX-XL-12.1.0 linux_nostdinc_i-C-XL-12.1.0 linux_nostdinc-CXX-XL-12.1.0 @@ -30,7 +34,7 @@ set(targets netbsd-C-GNU-4.8.5 netbsd-CXX-GNU-4.8.5 netbsd_nostdinc-C-GNU-4.8.5 netbsd_nostdinc-CXX-GNU-4.8.5 openbsd-C-Clang-5.0.1 openbsd-CXX-Clang-5.0.1 - sunos-C-SunPro-5.13.0 sunos-CXX-SunPro-5.13.0 + sunos-C-SunPro-5.13.0 sunos-CXX-SunPro-5.13.0 sunos-Fortran-SunPro-8.8.0 ) include(${CMAKE_ROOT}/Modules/CMakeParseImplicitIncludeInfo.cmake) diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-C-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-C-PGI-18.10.1.input new file mode 100644 index 0000000..cfc3e7b --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-C-PGI-18.10.1.input @@ -0,0 +1,36 @@ +CMAKE_LANG=C +CMAKE_C_COMPILER_ABI= +CMAKE_C_COMPILER_AR= +CMAKE_C_COMPILER_ARCHITECTURE_ID= +CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_C_COMPILER_ID=PGI +CMAKE_C_COMPILER_LAUNCHER= +CMAKE_C_COMPILER_LOADED=1 +CMAKE_C_COMPILER_RANLIB= +CMAKE_C_COMPILER_TARGET= +CMAKE_C_COMPILER_VERSION=18.10.1 +CMAKE_C_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_81a12/fast" +/usr/bin/make -f CMakeFiles/cmTC_81a12.dir/build.make CMakeFiles/cmTC_81a12.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o +/mnt/pgi/linux86-64/2018/bin/pgcc -v -o CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o -c /usr/share/cmake-3.10/Modules/CMakeCCompilerABI.c +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pgc /usr/share/cmake-3.10/Modules/CMakeCCompilerABI.c -opt 1 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -astype 0 -stdinc /mnt/pgi/linux86-64/18.10/include-gcc70:/mnt/pgi/linux86-64/18.10/include:/usr/lib/gcc/x86_64-linux-gnu/7/include:/usr/local/include:/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed:/usr/include/x86_64-linux-gnu:/usr/include -def unix -def __unix -def __unix__ -def linux -def __linux -def __linux__ -def __NO_MATH_INLINES -def __LP64__ -def __x86_64 -def __x86_64__ -def __LONG_MAX__=9223372036854775807L -def '__SIZE_TYPE__=unsigned long int' -def '__PTRDIFF_TYPE__=long int' -def __extension__= -def __amd_64__amd64__ -def __k8 -def __k8__ -def __SSE__ -def __MMX__ -def __SSE2__ -def __SSE3__ -predicate '#machine(x86_64) #lint(off) #system(posix) #cpu(x86_64)' -cmdline '+pgcc /usr/share/cmake-3.10/Modules/CMakeCCompilerABI.c -v -o CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o -c' -outfile CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o -x 123 0x80000000 -x 123 4 -x 2 0x400 -preinclude _c_macros.h -x 119 0x20 -def __pgnu_vsn=70300 -x 120 0x200000 -x 70 0x40000000 -x 164 0x800000 -y 163 0xc0000000 -x 189 0x10 -y 189 0x4000000 -asm /tmp/pgccl1BeHkOmG3zk.s +PGC/x86-64 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgccl1BeHkOmG3zk.s -o CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o +Unlinking /tmp/pgccl1BeHkOmG3zk.s +Unlinking /tmp/pgccJ1BePEjJHZ9x.ll +Linking C executable cmTC_81a12 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_81a12.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgcc -v CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o -o cmTC_81a12 +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_81a12.dir/CMakeCCompilerABI.c.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_81a12 -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-C-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-C-PGI-18.10.1.output new file mode 100644 index 0000000..289c530 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-C-PGI-18.10.1.output @@ -0,0 +1 @@ +/mnt/pgi/linux86-64/18.10/include-gcc70;/mnt/pgi/linux86-64/18.10/include;/usr/lib/gcc/x86_64-linux-gnu/7/include;/usr/local/include;/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed;/usr/include/x86_64-linux-gnu;/usr/include diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-CXX-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-CXX-PGI-18.10.1.input new file mode 100644 index 0000000..f95627e --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-CXX-PGI-18.10.1.input @@ -0,0 +1,40 @@ +CMAKE_LANG=CXX +CMAKE_CXX_COMPILER_ABI= +CMAKE_CXX_COMPILER_AR= +CMAKE_CXX_COMPILER_ARCHITECTURE_ID= +CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_CXX_COMPILER_ID=PGI +CMAKE_CXX_COMPILER_LAUNCHER= +CMAKE_CXX_COMPILER_LOADED=1 +CMAKE_CXX_COMPILER_RANLIB= +CMAKE_CXX_COMPILER_TARGET= +CMAKE_CXX_COMPILER_VERSION=18.10.1 +CMAKE_CXX_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_9932f/fast" +/usr/bin/make -f CMakeFiles/cmTC_9932f.dir/build.make CMakeFiles/cmTC_9932f.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_9932f.dir/CMakeCXXCompilerABI.cpp.o +/mnt/pgi/linux86-64/2018/bin/pgc++ -v -o CMakeFiles/cmTC_9932f.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pggpp1 --llalign -Dunix -D__unix -D__unix__ -Dlinux -D__linux -D__linux__ -D__NO_MATH_INLINES -D__LP64__ -D__x86_64 -D__x86_64__ -D__LONG_MAX__=9223372036854775807L '-D__SIZE_TYPE__=unsigned long int' '-D__PTRDIFF_TYPE__=long int' -D__extension__= -D__amd_64__amd64__ -D__k8 -D__k8__ -D__SSE__ -D__MMX__ -D__SSE2__ -D__SSE3__ -D__PGI -D_GNU_SOURCE -D_PGCG_SOURCE -I- -I/mnt/pgi/linux86-64/18.10/include-gcc70 -I/mnt/pgi/linux86-64/18.10/include -I/usr/include/c++/7 -I/usr/include/x86_64-linux-gnu/c++/7 -I/usr/include/c++/7/backward -I/usr/lib/gcc/x86_64-linux-gnu/7/include -I/usr/local/include -I/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed -I/usr/include/x86_64-linux-gnu -I/usr/include --preinclude _cplus_preinclude.h --preinclude_macros _cplus_macros.h --gnu_version=70300 -D__pgnu_vsn=70300 -q -o /tmp/pgc++9bCe3jXUexoO.il /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp + +/mnt/pgi/linux86-64/18.10/bin/pggpp2 /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp -opt 1 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -astype 0 -fn /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp -il /tmp/pgc++9bCe3jXUexoO.il -x 117 0x600 -x 123 0x80000000 -x 123 4 -x 119 0x20 -def __pgnu_vsn=70300 -x 120 0x200000 -x 70 0x40000000 -x 164 0x800000 -y 163 0xc0000000 -x 189 0x10 -y 189 0x4000000 -gnuvsn 70300 -x 69 0x200 -cmdline '+pgc++ /tmp/pgc++9bCe3jXUexoO.il -v -o CMakeFiles/cmTC_9932f.dir/CMakeCXXCompilerABI.cpp.o -c' -asm /tmp/pgc++LbCeVyAxx_Yt.s +PGCC/x86 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgc++LbCeVyAxx_Yt.s -o CMakeFiles/cmTC_9932f.dir/CMakeCXXCompilerABI.cpp.o +Action(ReadTIFile(./CMakeCXXCompilerABI.ti)) +Unlinking /tmp/pgc++9bCe3jXUexoO.il +Unlinking /tmp/pgc++LbCeVyAxx_Yt.s +Unlinking /tmp/pgc++nbCeNEnzNVv3.ll +Linking CXX executable cmTC_9932f +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_9932f.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgc++ -v CMakeFiles/cmTC_9932f.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_9932f +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_9932f.dir/CMakeCXXCompilerABI.cpp.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_9932f -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -latomic -lpgatm -lstdc++ -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-CXX-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-CXX-PGI-18.10.1.output new file mode 100644 index 0000000..8c9d24a --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-CXX-PGI-18.10.1.output @@ -0,0 +1 @@ +/mnt/pgi/linux86-64/18.10/include-gcc70;/mnt/pgi/linux86-64/18.10/include;/usr/include/c++/7;/usr/include/x86_64-linux-gnu/c++/7;/usr/include/c++/7/backward;/usr/lib/gcc/x86_64-linux-gnu/7/include;/usr/local/include;/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed;/usr/include/x86_64-linux-gnu;/usr/include diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-Fortran-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-Fortran-PGI-18.10.1.input new file mode 100644 index 0000000..fe49bcd --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-Fortran-PGI-18.10.1.input @@ -0,0 +1,47 @@ +CMAKE_LANG=Fortran +CMAKE_Fortran_COMPILER_ABI= +CMAKE_Fortran_COMPILER_AR= +CMAKE_Fortran_COMPILER_ARCHITECTURE_ID= +CMAKE_Fortran_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_Fortran_COMPILER_ID=PGI +CMAKE_Fortran_COMPILER_LAUNCHER= +CMAKE_Fortran_COMPILER_LOADED=1 +CMAKE_Fortran_COMPILER_RANLIB= +CMAKE_Fortran_COMPILER_TARGET= +CMAKE_Fortran_COMPILER_VERSION=18.10.1 +CMAKE_Fortran_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_1e8d2/fast" +/usr/bin/make -f CMakeFiles/cmTC_1e8d2.dir/build.make CMakeFiles/cmTC_1e8d2.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building Fortran object CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o +/mnt/pgi/linux86-64/2018/bin/pgfortran -v -c /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -o CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pgf901 /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -opt 1 -nohpf -nostatic -x 19 0x400000 -quad -x 59 4 -x 15 2 -x 49 0x400004 -x 51 0x20 -x 57 0x4c -x 58 0x10000 -x 124 0x1000 -tp k8 -x 57 0xfb0000 -x 58 0x78031040 -x 47 0x08 -x 48 4608 -x 49 0x100 -x 120 0x200 -stdinc /mnt/pgi/linux86-64/18.10/include-gcc70:/mnt/pgi/linux86-64/18.10/include:/usr/lib/gcc/x86_64-linux-gnu/7/include:/usr/local/include:/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed:/usr/include/x86_64-linux-gnu:/usr/include -cmdline '+pgfortran /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -v -c -o CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o' -def unix -def __unix -def __unix__ -def linux -def __linux -def __linux__ -def __NO_MATH_INLINES -def __LP64__ -def __x86_64 -def __x86_64__ -def __LONG_MAX__=9223372036854775807L -def '__SIZE_TYPE__=unsigned long int' -def '__PTRDIFF_TYPE__=long int' -def __extension__= -def __amd_64__amd64__ -def __k8 -def __k8__ -def __SSE__ -def __MMX__ -def __SSE2__ -def __SSE3__ -preprocess -nofreeform -vect 48 -x 54 1 -x 70 0x40000000 -y 163 0xc0000000 -x 189 0x10 -modexport /tmp/pgfortranSoCeegQjDEd5.cmod -modindex /tmp/pgfortranmoCeK26CaVn7.cmdx -output /tmp/pgfortranSoCeeXSv8E7w.ilm + 0 inform, 0 warnings, 0 severes, 0 fatal for cmakefortrancompilerabi +PGF90/x86-64 Linux 18.10-1: compilation successful + +/mnt/pgi/linux86-64/18.10/bin/pgf902 /tmp/pgfortranSoCeeXSv8E7w.ilm -fn /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -opt 1 -x 51 0x20 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -x 124 0x1400 -y 15 2 -x 57 0x3b0000 -x 58 0x48000000 -x 49 0x100 -x 120 0x200 -astype 0 -x 68 0x20 -x 70 0x40000000 -x 164 0x800000 -x 124 1 -y 163 0xc0000000 -x 189 0x10 -y 189 0x4000000 -cmdline '+pgfortran /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -v -c -o CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o' -asm /tmp/pgfortranSoCeeRr681iB.s + 0 inform, 0 warnings, 0 severes, 0 fatal for cmakefortrancompilerabi +PGF90/x86-64 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgfortranSoCeeRr681iB.s -o CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o + +/mnt/pgi/linux86-64/18.10/bin/pgappend -noerror CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o -name .IPDINFO /tmp/pgfortranSoCeegQjDEd5.cmod -name .IPEINFO /tmp/pgfortranmoCeK26CaVn7.cmdx +Unlinking /tmp/pgfortranSoCeeXSv8E7w.ilm +Unlinking /tmp/pgfortranmoCeK5sPGGfq.stb +Unlinking /tmp/pgfortranSoCeegQjDEd5.cmod +Unlinking /tmp/pgfortranmoCeK26CaVn7.cmdx +Unlinking /tmp/pgfortranSoCeeRr681iB.s +Unlinking /tmp/pgfortranmoCeKdFYP9Gu.ll +Linking Fortran executable cmTC_1e8d2 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_1e8d2.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgfortran -v CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o -o cmTC_1e8d2 +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o /mnt/pgi/linux86-64/18.10/lib/f90main.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_1e8d2.dir/CMakeFortranCompilerABI.F.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_1e8d2 -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -lpgf90rtl -lpgf90 -lpgf90_rpm1 -lpgf902 -lpgf90rtl -lpgftnrtl -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lrt -lpthread -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-Fortran-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-Fortran-PGI-18.10.1.output new file mode 100644 index 0000000..289c530 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux-Fortran-PGI-18.10.1.output @@ -0,0 +1 @@ +/mnt/pgi/linux86-64/18.10/include-gcc70;/mnt/pgi/linux86-64/18.10/include;/usr/lib/gcc/x86_64-linux-gnu/7/include;/usr/local/include;/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed;/usr/include/x86_64-linux-gnu;/usr/include diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-C-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-C-PGI-18.10.1.input new file mode 100644 index 0000000..5e2e49a --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-C-PGI-18.10.1.input @@ -0,0 +1,36 @@ +CMAKE_LANG=C +CMAKE_C_COMPILER_ABI= +CMAKE_C_COMPILER_AR= +CMAKE_C_COMPILER_ARCHITECTURE_ID= +CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_C_COMPILER_ID=PGI +CMAKE_C_COMPILER_LAUNCHER= +CMAKE_C_COMPILER_LOADED=1 +CMAKE_C_COMPILER_RANLIB= +CMAKE_C_COMPILER_TARGET= +CMAKE_C_COMPILER_VERSION=18.10.1 +CMAKE_C_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_a7f0d/fast" +/usr/bin/make -f CMakeFiles/cmTC_a7f0d.dir/build.make CMakeFiles/cmTC_a7f0d.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o +/mnt/pgi/linux86-64/2018/bin/pgcc -Mnostdinc -v -o CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o -c /usr/share/cmake-3.10/Modules/CMakeCCompilerABI.c +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pgc /usr/share/cmake-3.10/Modules/CMakeCCompilerABI.c -opt 1 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -astype 0 -nostdinc -def unix -def __unix -def __unix__ -def linux -def __linux -def __linux__ -def __NO_MATH_INLINES -def __LP64__ -def __x86_64 -def __x86_64__ -def __LONG_MAX__=9223372036854775807L -def '__SIZE_TYPE__=unsigned long int' -def '__PTRDIFF_TYPE__=long int' -def __extension__= -def __amd_64__amd64__ -def __k8 -def __k8__ -def __SSE__ -def __MMX__ -def __SSE2__ -def __SSE3__ -predicate '#machine(x86_64) #lint(off) #system(posix) #cpu(x86_64)' -cmdline '+pgcc /usr/share/cmake-3.10/Modules/CMakeCCompilerABI.c -Mnostdinc -v -o CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o -c' -outfile CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o -x 123 0x80000000 -x 123 4 -x 2 0x400 -x 119 0x20 -def __pgnu_vsn=70300 -x 120 0x200000 -x 70 0x40000000 -x 164 0x800000 -y 163 0xc0000000 -x 189 0x10 -y 189 0x4000000 -asm /tmp/pgccjRkfBrHQsITu.s +PGC/x86-64 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgccjRkfBrHQsITu.s -o CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o +Unlinking /tmp/pgccjRkfBrHQsITu.s +Unlinking /tmp/pgccrRkfZClhdaSG.ll +Linking C executable cmTC_a7f0d +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_a7f0d.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgcc -Mnostdinc -v CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o -o cmTC_a7f0d +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_a7f0d.dir/CMakeCCompilerABI.c.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_a7f0d -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-C-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-C-PGI-18.10.1.output new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-C-PGI-18.10.1.output diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-CXX-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-CXX-PGI-18.10.1.input new file mode 100644 index 0000000..dd2b55d --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-CXX-PGI-18.10.1.input @@ -0,0 +1,40 @@ +CMAKE_LANG=CXX +CMAKE_CXX_COMPILER_ABI= +CMAKE_CXX_COMPILER_AR= +CMAKE_CXX_COMPILER_ARCHITECTURE_ID= +CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_CXX_COMPILER_ID=PGI +CMAKE_CXX_COMPILER_LAUNCHER= +CMAKE_CXX_COMPILER_LOADED=1 +CMAKE_CXX_COMPILER_RANLIB= +CMAKE_CXX_COMPILER_TARGET= +CMAKE_CXX_COMPILER_VERSION=18.10.1 +CMAKE_CXX_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_90855/fast" +/usr/bin/make -f CMakeFiles/cmTC_90855.dir/build.make CMakeFiles/cmTC_90855.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_90855.dir/CMakeCXXCompilerABI.cpp.o +/mnt/pgi/linux86-64/2018/bin/pgc++ -Mnostdinc -v -o CMakeFiles/cmTC_90855.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pggpp1 --llalign -Dunix -D__unix -D__unix__ -Dlinux -D__linux -D__linux__ -D__NO_MATH_INLINES -D__LP64__ -D__x86_64 -D__x86_64__ -D__LONG_MAX__=9223372036854775807L '-D__SIZE_TYPE__=unsigned long int' '-D__PTRDIFF_TYPE__=long int' -D__extension__= -D__amd_64__amd64__ -D__k8 -D__k8__ -D__SSE__ -D__MMX__ -D__SSE2__ -D__SSE3__ -D__PGI -D_GNU_SOURCE -D_PGCG_SOURCE -I- -I/mnt/pgi/linux86-64/18.10/include-gcc70 -I/mnt/pgi/linux86-64/18.10/include -I/usr/include/c++/7 -I/usr/include/x86_64-linux-gnu/c++/7 -I/usr/include/c++/7/backward -I/usr/lib/gcc/x86_64-linux-gnu/7/include -I/usr/local/include -I/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed -I/usr/include/x86_64-linux-gnu -I/usr/include --preinclude _cplus_preinclude.h --preinclude_macros _cplus_macros.h --gnu_version=70300 -D__pgnu_vsn=70300 -q -o /tmp/pgc++X3kftwl3x0Hl.il /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp + +/mnt/pgi/linux86-64/18.10/bin/pggpp2 /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp -opt 1 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -astype 0 -fn /usr/share/cmake-3.10/Modules/CMakeCXXCompilerABI.cpp -il /tmp/pgc++X3kftwl3x0Hl.il -x 117 0x600 -x 123 0x80000000 -x 123 4 -x 119 0x20 -def __pgnu_vsn=70300 -x 120 0x200000 -x 70 0x40000000 -x 164 0x800000 -y 163 0xc0000000 -x 189 0x10 -y 189 0x4000000 -gnuvsn 70300 -x 69 0x200 -cmdline '+pgc++ /tmp/pgc++X3kftwl3x0Hl.il -Mnostdinc -v -o CMakeFiles/cmTC_90855.dir/CMakeCXXCompilerABI.cpp.o -c' -asm /tmp/pgc++53kfRignAQXZ.s +PGCC/x86 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgc++53kfRignAQXZ.s -o CMakeFiles/cmTC_90855.dir/CMakeCXXCompilerABI.cpp.o +Action(ReadTIFile(./CMakeCXXCompilerABI.ti)) +Unlinking /tmp/pgc++X3kftwl3x0Hl.il +Unlinking /tmp/pgc++53kfRignAQXZ.s +Unlinking /tmp/pgc++b3kfdox2AAgc.ll +Linking CXX executable cmTC_90855 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_90855.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgc++ -Mnostdinc -v CMakeFiles/cmTC_90855.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_90855 +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_90855.dir/CMakeCXXCompilerABI.cpp.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_90855 -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -latomic -lpgatm -lstdc++ -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-CXX-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-CXX-PGI-18.10.1.output new file mode 100644 index 0000000..8c9d24a --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-CXX-PGI-18.10.1.output @@ -0,0 +1 @@ +/mnt/pgi/linux86-64/18.10/include-gcc70;/mnt/pgi/linux86-64/18.10/include;/usr/include/c++/7;/usr/include/x86_64-linux-gnu/c++/7;/usr/include/c++/7/backward;/usr/lib/gcc/x86_64-linux-gnu/7/include;/usr/local/include;/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed;/usr/include/x86_64-linux-gnu;/usr/include diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-Fortran-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-Fortran-PGI-18.10.1.input new file mode 100644 index 0000000..12727f0 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-Fortran-PGI-18.10.1.input @@ -0,0 +1,47 @@ +CMAKE_LANG=Fortran +CMAKE_Fortran_COMPILER_ABI= +CMAKE_Fortran_COMPILER_AR= +CMAKE_Fortran_COMPILER_ARCHITECTURE_ID= +CMAKE_Fortran_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_Fortran_COMPILER_ID=PGI +CMAKE_Fortran_COMPILER_LAUNCHER= +CMAKE_Fortran_COMPILER_LOADED=1 +CMAKE_Fortran_COMPILER_RANLIB= +CMAKE_Fortran_COMPILER_TARGET= +CMAKE_Fortran_COMPILER_VERSION=18.10.1 +CMAKE_Fortran_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_b7462/fast" +/usr/bin/make -f CMakeFiles/cmTC_b7462.dir/build.make CMakeFiles/cmTC_b7462.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building Fortran object CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o +/mnt/pgi/linux86-64/2018/bin/pgfortran -Mnostdinc -v -c /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -o CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pgf901 /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -opt 1 -nohpf -nostatic -x 19 0x400000 -quad -x 59 4 -x 15 2 -x 49 0x400004 -x 51 0x20 -x 57 0x4c -x 58 0x10000 -x 124 0x1000 -tp k8 -x 57 0xfb0000 -x 58 0x78031040 -x 47 0x08 -x 48 4608 -x 49 0x100 -x 120 0x200 -nostdinc -cmdline '+pgfortran /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -Mnostdinc -v -c -o CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o' -def unix -def __unix -def __unix__ -def linux -def __linux -def __linux__ -def __NO_MATH_INLINES -def __LP64__ -def __x86_64 -def __x86_64__ -def __LONG_MAX__=9223372036854775807L -def '__SIZE_TYPE__=unsigned long int' -def '__PTRDIFF_TYPE__=long int' -def __extension__= -def __amd_64__amd64__ -def __k8 -def __k8__ -def __SSE__ -def __MMX__ -def __SSE2__ -def __SSE3__ -preprocess -nofreeform -vect 48 -x 54 1 -x 70 0x40000000 -y 163 0xc0000000 -x 189 0x10 -modexport /tmp/pgfortranoelfQQWHVV3l.cmod -modindex /tmp/pgfortran_elf6-1UcVhp.cmdx -output /tmp/pgfortranUelfk_cqURUw.ilm + 0 inform, 0 warnings, 0 severes, 0 fatal for cmakefortrancompilerabi +PGF90/x86-64 Linux 18.10-1: compilation successful + +/mnt/pgi/linux86-64/18.10/bin/pgf902 /tmp/pgfortranUelfk_cqURUw.ilm -fn /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -opt 1 -x 51 0x20 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -x 124 0x1400 -y 15 2 -x 57 0x3b0000 -x 58 0x48000000 -x 49 0x100 -x 120 0x200 -astype 0 -x 68 0x20 -x 70 0x40000000 -x 164 0x800000 -x 124 1 -y 163 0xc0000000 -x 189 0x10 -y 189 0x4000000 -cmdline '+pgfortran /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -Mnostdinc -v -c -o CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o' -asm /tmp/pgfortranUelfk-LC2Ixm.s + 0 inform, 0 warnings, 0 severes, 0 fatal for cmakefortrancompilerabi +PGF90/x86-64 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgfortranUelfk-LC2Ixm.s -o CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o + +/mnt/pgi/linux86-64/18.10/bin/pgappend -noerror CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o -name .IPDINFO /tmp/pgfortranoelfQQWHVV3l.cmod -name .IPEINFO /tmp/pgfortran_elf6-1UcVhp.cmdx +Unlinking /tmp/pgfortranUelfk_cqURUw.ilm +Unlinking /tmp/pgfortranEelfAVAFcE2q.stb +Unlinking /tmp/pgfortranoelfQQWHVV3l.cmod +Unlinking /tmp/pgfortran_elf6-1UcVhp.cmdx +Unlinking /tmp/pgfortranUelfk-LC2Ixm.s +Unlinking /tmp/pgfortranEelfA4vWZ2Nt.ll +Linking Fortran executable cmTC_b7462 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_b7462.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgfortran -v -Mnostdinc CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o -o cmTC_b7462 +Export PGI_CURR_CUDA_HOME=/mnt/pgi/linux86-64/2018/cuda/9.1 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o /mnt/pgi/linux86-64/18.10/lib/f90main.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_b7462.dir/CMakeFortranCompilerABI.F.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_b7462 -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -lpgf90rtl -lpgf90 -lpgf90_rpm1 -lpgf902 -lpgf90rtl -lpgftnrtl -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lrt -lpthread -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-Fortran-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-Fortran-PGI-18.10.1.output new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_nostdinc-Fortran-PGI-18.10.1.output diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_pgf77-Fortran-PGI-18.10.1.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_pgf77-Fortran-PGI-18.10.1.input new file mode 100644 index 0000000..01abe8d --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_pgf77-Fortran-PGI-18.10.1.input @@ -0,0 +1,35 @@ +CMAKE_LANG=Fortran +CMAKE_Fortran_COMPILER_ABI= +CMAKE_Fortran_COMPILER_AR= +CMAKE_Fortran_COMPILER_ARCHITECTURE_ID= +CMAKE_Fortran_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_Fortran_COMPILER_ID=PGI +CMAKE_Fortran_COMPILER_LAUNCHER= +CMAKE_Fortran_COMPILER_LOADED=1 +CMAKE_Fortran_COMPILER_RANLIB= +CMAKE_Fortran_COMPILER_TARGET= +CMAKE_Fortran_COMPILER_VERSION=18.10.1 +CMAKE_Fortran_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_ea063/fast" +/usr/bin/make -f CMakeFiles/cmTC_ea063.dir/build.make CMakeFiles/cmTC_ea063.dir/build +make[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building Fortran object CMakeFiles/cmTC_ea063.dir/CMakeFortranCompilerABI.F.o +/mnt/pgi/linux86-64/2018/bin/pgf77 -v -c /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -o CMakeFiles/cmTC_ea063.dir/CMakeFortranCompilerABI.F.o +Export PGI=/mnt/pgi + +/mnt/pgi/linux86-64/18.10/bin/pgftnc /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -opt 1 -x 119 0xa10000 -x 122 0x40 -x 123 0x1000 -x 127 4 -x 127 17 -x 19 0x400000 -x 28 0x40000 -x 120 0x10000000 -x 70 0x8000 -x 122 1 -x 125 0x20000 -quad -x 59 4 -tp k8 -x 120 0x1000 -x 51 0x20 -x 124 0x1401 -astype 0 -stdinc /mnt/pgi/linux86-64/18.10/include-gcc70:/mnt/pgi/linux86-64/18.10/include:/usr/lib/gcc/x86_64-linux-gnu/7/include:/usr/local/include:/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed:/usr/include/x86_64-linux-gnu:/usr/include -def unix -def __unix -def __unix__ -def linux -def __linux -def __linux__ -def __NO_MATH_INLINES -def __LP64__ -def __x86_64 -def __x86_64__ -def __LONG_MAX__=9223372036854775807L -def '__SIZE_TYPE__=unsigned long int' -def '__PTRDIFF_TYPE__=long int' -def __extension__= -def __amd_64__amd64__ -def __k8 -def __k8__ -def __SSE__ -def __MMX__ -def __SSE2__ -def __SSE3__ -preprocess -cmdline '+pgf77 /usr/share/cmake-3.10/Modules/CMakeFortranCompilerABI.F -v -c -o CMakeFiles/cmTC_ea063.dir/CMakeFortranCompilerABI.F.o' -x 70 0x40000000 -x 164 0x800000 -x 124 1 -asm /tmp/pgf77RxHebkuzkjES.s + 0 inform, 0 warnings, 0 severes, 0 fatal for cmakefortrancompilerabi +PGFTN/x86-64 Linux 18.10-1: compilation successful + +/usr/bin/as /tmp/pgf77RxHebkuzkjES.s -o CMakeFiles/cmTC_ea063.dir/CMakeFortranCompilerABI.F.o +Unlinking /tmp/pgf77RxHebkuzkjES.s +Unlinking /tmp/pgf77dxHejAvLAzcs.ll +Linking Fortran executable cmTC_ea063 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_ea063.dir/link.txt --verbose=1 +/mnt/pgi/linux86-64/2018/bin/pgf77 -v CMakeFiles/cmTC_ea063.dir/CMakeFortranCompilerABI.F.o -o cmTC_ea063 +Export PGI=/mnt/pgi + +/usr/bin/ld /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /mnt/pgi/linux86-64/18.10/lib/trace_init.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbegin.o /mnt/pgi/linux86-64/18.10/lib/initmp.o /mnt/pgi/linux86-64/18.10/lib/pgfmain.o --eh-frame-hdr -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /mnt/pgi/linux86-64/18.10/lib/pgi.ld -L/mnt/pgi/linux86-64/18.10/lib -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/7 CMakeFiles/cmTC_ea063.dir/CMakeFortranCompilerABI.F.o -rpath /mnt/pgi/linux86-64/18.10/lib -rpath /usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -o cmTC_ea063 -L/usr/lib/gcc/x86_64-linux-gnu/7/../../../../lib64 -lpgftnrtl -lpgmp -lnuma -lpthread --start-group -lpgmath -lnspgc -lpgc --end-group -lrt -lpthread -lm -lgcc -lc -lgcc -lgcc_s /usr/lib/gcc/x86_64-linux-gnu/7/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_pgf77-Fortran-PGI-18.10.1.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_pgf77-Fortran-PGI-18.10.1.output new file mode 100644 index 0000000..289c530 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/linux_pgf77-Fortran-PGI-18.10.1.output @@ -0,0 +1 @@ +/mnt/pgi/linux86-64/18.10/include-gcc70;/mnt/pgi/linux86-64/18.10/include;/usr/lib/gcc/x86_64-linux-gnu/7/include;/usr/local/include;/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed;/usr/include/x86_64-linux-gnu;/usr/include diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/sunos-Fortran-SunPro-8.8.0.input b/Tests/RunCMake/ParseImplicitIncludeInfo/data/sunos-Fortran-SunPro-8.8.0.input new file mode 100644 index 0000000..4a2bedd --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/sunos-Fortran-SunPro-8.8.0.input @@ -0,0 +1,40 @@ +CMAKE_LANG=Fortran +CMAKE_Fortran_COMPILER_ABI= +CMAKE_Fortran_COMPILER_AR= +CMAKE_Fortran_COMPILER_ARCHITECTURE_ID= +CMAKE_Fortran_COMPILER_EXTERNAL_TOOLCHAIN= +CMAKE_Fortran_COMPILER_ID=SunPro +CMAKE_Fortran_COMPILER_LAUNCHER= +CMAKE_Fortran_COMPILER_LOADED=1 +CMAKE_Fortran_COMPILER_RANLIB= +CMAKE_Fortran_COMPILER_TARGET= +CMAKE_Fortran_COMPILER_VERSION=8.8.0 +CMAKE_Fortran_COMPILER_VERSION_INTERAL= +Change Dir: /tmp/ii/CMakeFiles/CMakeTmp + +Run Build Command:"/opt/csw/bin/gmake" "cmTC_adcec/fast" +/opt/csw/bin/gmake -f CMakeFiles/cmTC_adcec.dir/build.make CMakeFiles/cmTC_adcec.dir/build +gmake[1]: Entering directory '/tmp/ii/CMakeFiles/CMakeTmp' +Building Fortran object CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o +/opt/developerstudio12.6/bin/sunf95 -v -c /tmp/CMake/Modules/CMakeFortranCompilerABI.F -o CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o +### f90: Note: NLSPATH = /opt/developerstudio12.6/bin/../lib/locale/%L/LC_MESSAGES/%N.cat:/opt/developerstudio12.6/bin/../../lib/locale/%L/LC_MESSAGES/%N.cat +### command line files and options (expanded): +### -v -c /tmp/CMake/Modules/CMakeFortranCompilerABI.F -o CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o +/opt/developerstudio12.6/bin/fpp -undef -vax=bslash -Y/opt/developerstudio12.6/lib/compilers/include/f95 -D__SunOS_5_10 -D__SunOS_RELEASE=0x051000 -D__SUNPRO_F90=0x880 -D__SUNPRO_F95=0x880 -D__unix -D__SVR4__ -D__svr4__ -D__SVR4 -D__sun -D__sun__ -D__SunOS -D__sparcv8 -D__sparcv8plus -D__sparc -D__sparc__ -Dsun -Dunix -Dsparc -D__SUN_PREFETCH -I/opt/developerstudio12.6/lib/compilers/include/f95 /tmp/CMake/Modules/CMakeFortranCompilerABI.F /tmp/fpp.1548681160.26580.01.f +/opt/developerstudio12.6/lib/compilers/bin/f90comp -E/tmp/CMake/Modules/CMakeFortranCompilerABI.F -m3 -ev -xall -xivdep=loop -H "/opt/developerstudio12.6/bin/f90 -v -c " -I/opt/developerstudio12.6/lib/compilers/include/f95 -p/opt/developerstudio12.6/lib/compilers/modules -m32 -y-m32 -xmemalign=8i -iorounding=processor-defined -xhasc=yes -xdebuginfo=%none -y-xdebuginfo=%none -y-xglobalize=no -xcache=generic -y-xcache=generic -y-xassume_control=optimize -xassume_control=optimize -y-xdbggen=dwarf+incl -keepmod=yes -y-ir -y/tmp/f90comp.1548681160.26580.02.ir /tmp/fpp.1548681160.26580.01.f +/opt/developerstudio12.6/lib/compilers/bin/cg -Qy -fsimple=0 -xarch=sparcvis2 -m32 -xchip=generic -xcache=generic -comdat -ftrap=division,invalid,overflow -xdebuginfo=%none -xbuiltin=%none -xcode=abs32 -xannotate=yes -xmemalign=8i -xprefetch=auto,explicit -xprefetch_auto_type=no%indirect_array_access -xcheck=stkovf -xcheck=noreturn -xvector=no -oo CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o -ir /tmp/f90comp.1548681160.26580.02.ir +rm /tmp/f90comp.1548681160.26580.02.ir +rm /tmp/fpp.1548681160.26580.01.f +Linking Fortran executable cmTC_adcec +/tmp/CMake/bin/cmake -E cmake_link_script CMakeFiles/cmTC_adcec.dir/link.txt --verbose=1 +/opt/developerstudio12.6/bin/sunf95 -v CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o -o cmTC_adcec +### f90: Note: NLSPATH = /opt/developerstudio12.6/bin/../lib/locale/%L/LC_MESSAGES/%N.cat:/opt/developerstudio12.6/bin/../../lib/locale/%L/LC_MESSAGES/%N.cat +### command line files and options (expanded): +### -v CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o -o cmTC_adcec +### f90: Note: LD_LIBRARY_PATH = (null) +### f90: Note: LD_RUN_PATH = (null) +### f90: Note: LD_OPTIONS = (null) +ln -s /opt/developerstudio12.6/lib/compilers /tmp/lib_link.1548681161.26655.01 +/usr/ccs/bin/ld -zld32=-S/tmp/lib_link.1548681161.26655.01/libldstab_ws.so -zld64=-S/tmp/lib_link.1548681161.26655.01/sparcv9/libldstab_ws.so -zld32=-S/tmp/lib_link.1548681161.26655.01/libld_annotate.so -zld64=-S/tmp/lib_link.1548681161.26655.01/sparcv9/libld_annotate.so /opt/developerstudio12.6/lib/compilers/crti.o /opt/developerstudio12.6/lib/compilers/crt1.o /opt/developerstudio12.6/lib/compilers/misalign.o /opt/developerstudio12.6/lib/compilers/values-xi.o CMakeFiles/cmTC_adcec.dir/CMakeFortranCompilerABI.F.o -o cmTC_adcec -Y "P,/opt/developerstudio12.6/lib/compilers/sparcvis2:/opt/developerstudio12.6/lib/compilers:/opt/developerstudio12.6/lib:/usr/ccs/lib:/lib:/usr/lib" -Qy -R/opt/developerstudio12.6/lib -t -lfsu -lsunmath -lmtsk -lm -lc /opt/developerstudio12.6/lib/compilers/crtn.o +rm /tmp/lib_link.1548681161.26655.01 +gmake[1]: Leaving directory '/tmp/ii/CMakeFiles/CMakeTmp' diff --git a/Tests/RunCMake/ParseImplicitIncludeInfo/data/sunos-Fortran-SunPro-8.8.0.output b/Tests/RunCMake/ParseImplicitIncludeInfo/data/sunos-Fortran-SunPro-8.8.0.output new file mode 100644 index 0000000..3c31e16 --- /dev/null +++ b/Tests/RunCMake/ParseImplicitIncludeInfo/data/sunos-Fortran-SunPro-8.8.0.output @@ -0,0 +1 @@ +/opt/developerstudio12.6/lib/compilers/include/f95 diff --git a/Tests/RunCMake/VS10ProjectWinCE/VsCEDebuggerDeploy-check.cmake b/Tests/RunCMake/VS10ProjectWinCE/VsCEDebuggerDeploy-check.cmake index c66676f..6ab3833 100644 --- a/Tests/RunCMake/VS10ProjectWinCE/VsCEDebuggerDeploy-check.cmake +++ b/Tests/RunCMake/VS10ProjectWinCE/VsCEDebuggerDeploy-check.cmake @@ -13,6 +13,7 @@ endif() set(FoundCEAdditionalFiles FALSE) set(FoundRemoteDirectory FALSE) +set(FoundToolsVersion4 FALSE) file(STRINGS "${vcProjectFile}" lines) foreach(line IN LISTS lines) @@ -20,6 +21,8 @@ foreach(line IN LISTS lines) set(FoundCEAdditionalFiles TRUE) elseif(line MATCHES " *<RemoteDirectory>[A-Za-z0-9\\]+</RemoteDirectory> *$") set(FoundRemoteDirectory TRUE) + elseif(line MATCHES " *<Project +.*ToolsVersion=\"4.0\".*> *$") + set(FoundToolsVersion4 TRUE) endif() endforeach() @@ -32,3 +35,8 @@ if(NOT FoundRemoteDirectory) set(RunCMake_TEST_FAILED "RemoteDirectory not found or not set correctly.") return() endif() + +if(NOT FoundToolsVersion4) + set(RunCMake_TEST_FAILED "Failed to find correct ToolsVersion=\"4.0\" .") + return() +endif() diff --git a/Tests/RunCMake/set/ExtraEnvValue-stderr.txt b/Tests/RunCMake/set/ExtraEnvValue-stderr.txt new file mode 100644 index 0000000..f61f9d2 --- /dev/null +++ b/Tests/RunCMake/set/ExtraEnvValue-stderr.txt @@ -0,0 +1,6 @@ +CMake Warning \(dev\) at ExtraEnvValue.cmake:1 \(set\): + Only the first value argument is used when setting an environment variable. + Argument 'value_2' and later are unused. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/set/ExtraEnvValue.cmake b/Tests/RunCMake/set/ExtraEnvValue.cmake new file mode 100644 index 0000000..768a6ea --- /dev/null +++ b/Tests/RunCMake/set/ExtraEnvValue.cmake @@ -0,0 +1 @@ +set (ENV{sample_key} value_1 value_2) diff --git a/Tests/RunCMake/set/RunCMakeTest.cmake b/Tests/RunCMake/set/RunCMakeTest.cmake index b8e8cf1..b3bd0a4 100644 --- a/Tests/RunCMake/set/RunCMakeTest.cmake +++ b/Tests/RunCMake/set/RunCMakeTest.cmake @@ -3,3 +3,5 @@ include(RunCMake) run_cmake(ParentScope) run_cmake(ParentPulling) run_cmake(ParentPullingRecursive) +run_cmake(UnknownCacheType) +run_cmake(ExtraEnvValue) diff --git a/Tests/RunCMake/set/UnknownCacheType-stderr.txt b/Tests/RunCMake/set/UnknownCacheType-stderr.txt new file mode 100644 index 0000000..6e1c811 --- /dev/null +++ b/Tests/RunCMake/set/UnknownCacheType-stderr.txt @@ -0,0 +1,5 @@ +CMake Warning \(dev\) at UnknownCacheType.cmake:1 \(set\): + implicitly converting 'unknown_type_sample' to 'STRING' type. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/set/UnknownCacheType.cmake b/Tests/RunCMake/set/UnknownCacheType.cmake new file mode 100644 index 0000000..f2b5d05 --- /dev/null +++ b/Tests/RunCMake/set/UnknownCacheType.cmake @@ -0,0 +1 @@ +set (sample_key sample_value CACHE unknown_type_sample "sample doc") diff --git a/Tests/SwiftOnly/CMakeLists.txt b/Tests/SwiftOnly/CMakeLists.txt index cf4463c..e5f8588 100644 --- a/Tests/SwiftOnly/CMakeLists.txt +++ b/Tests/SwiftOnly/CMakeLists.txt @@ -1,7 +1,9 @@ cmake_minimum_required(VERSION 3.3) project(SwiftOnly Swift) -if(NOT XCODE_VERSION VERSION_LESS 8.0) +if(NOT XCODE_VERSION VERSION_LESS 10.2) + set(CMAKE_Swift_LANGUAGE_VERSION 5.0) +elseif(NOT XCODE_VERSION VERSION_LESS 8.0) set(CMAKE_Swift_LANGUAGE_VERSION 3.0) endif() diff --git a/Tests/VSWinStorePhone/CMakeLists.txt b/Tests/VSWinStorePhone/CMakeLists.txt index acda117..efc7760 100644 --- a/Tests/VSWinStorePhone/CMakeLists.txt +++ b/Tests/VSWinStorePhone/CMakeLists.txt @@ -8,6 +8,8 @@ elseif(MSVC_VERSION GREATER 1600) set(COMPILER_VERSION "11") endif() +add_subdirectory(WinRT) + set (APP_MANIFEST_NAME Package.appxmanifest) if("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsPhone") set(PLATFORM WP) @@ -139,11 +141,14 @@ if("${SHORT_VERSION}" STREQUAL "10.0") message(STATUS "Targeting Windows 10. Setting Extensions to version ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") set_property(TARGET ${EXE_NAME} PROPERTY VS_DESKTOP_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") set_property(TARGET ${EXE_NAME} PROPERTY VS_MOBILE_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") - set_property(TARGET ${EXE_NAME} PROPERTY VS_IOT_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") + + # The last IOT reference is on 10.0.17134.0, so only add it if supported + if("${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}" VERSION_LESS "10.0.17135.0") + set_property(TARGET ${EXE_NAME} PROPERTY VS_IOT_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") + endif() # Add a reference to an SDK set_property(TARGET ${EXE_NAME} PROPERTY VS_SDK_REFERENCES "Microsoft.UniversalCRT.Debug, Version=${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") endif() - -target_link_libraries(${EXE_NAME} d3d11) +target_link_libraries(${EXE_NAME} d3d11 JusticeLeagueWinRT) diff --git a/Tests/VSWinStorePhone/Direct3DApp1/CubeRenderer.cpp b/Tests/VSWinStorePhone/Direct3DApp1/CubeRenderer.cpp index 1c969cd..3ba35fa 100644 --- a/Tests/VSWinStorePhone/Direct3DApp1/CubeRenderer.cpp +++ b/Tests/VSWinStorePhone/Direct3DApp1/CubeRenderer.cpp @@ -6,11 +6,15 @@ using namespace DirectX; using namespace Microsoft::WRL; using namespace Windows::Foundation; using namespace Windows::UI::Core; +using namespace JusticeLeagueWinRT; CubeRenderer::CubeRenderer() : m_loadingComplete(false) , m_indexCount(0) { + // Create a new WinRT object to validate that we can link properly + Batman ^ hero = ref new Batman(); + hero->savePeople(); } void CubeRenderer::CreateDeviceResources() diff --git a/Tests/VSWinStorePhone/WinRT/Batman.cpp b/Tests/VSWinStorePhone/WinRT/Batman.cpp new file mode 100644 index 0000000..e092258 --- /dev/null +++ b/Tests/VSWinStorePhone/WinRT/Batman.cpp @@ -0,0 +1,14 @@ +#include "Batman.h" + +using namespace JusticeLeagueWinRT; +using namespace Platform; + +Batman::Batman() +{ +} + +void Batman::savePeople() +{ + int i = 0; + i++; +} diff --git a/Tests/VSWinStorePhone/WinRT/Batman.h b/Tests/VSWinStorePhone/WinRT/Batman.h new file mode 100644 index 0000000..e2dcabc --- /dev/null +++ b/Tests/VSWinStorePhone/WinRT/Batman.h @@ -0,0 +1,12 @@ +#pragma once + +namespace JusticeLeagueWinRT { +public +ref class Batman sealed +{ +public: + Batman(); + + void savePeople(); +}; +} diff --git a/Tests/VSWinStorePhone/WinRT/CMakeLists.txt b/Tests/VSWinStorePhone/WinRT/CMakeLists.txt new file mode 100644 index 0000000..bb93333 --- /dev/null +++ b/Tests/VSWinStorePhone/WinRT/CMakeLists.txt @@ -0,0 +1,13 @@ +project(JusticeLeagueWinRT CXX) + +# create project +add_library(JusticeLeagueWinRT SHARED + "${CMAKE_CURRENT_SOURCE_DIR}/Batman.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/Batman.h" +) + +set_target_properties(JusticeLeagueWinRT PROPERTIES + VS_WINRT_COMPONENT TRUE + VS_GLOBAL_ROOTNAMESPACE "JusticeLeagueWinRT" + OUTPUT_NAME "JusticeLeagueWinRT" +) diff --git a/Utilities/Sphinx/cmake.py b/Utilities/Sphinx/cmake.py index 882cdc1..d903dbe 100644 --- a/Utilities/Sphinx/cmake.py +++ b/Utilities/Sphinx/cmake.py @@ -21,6 +21,8 @@ from pygments.lexer import bygroups # - Unix paths are recognized by '/'; support for Windows paths may be added if needed # - (\\.) allows for \-escapes (used in manual/cmake-language.7) # - $<..$<..$>..> nested occurence in cmake-buildsystem +# - Nested variable evaluations are only supported in a limited capacity. Only +# one level of nesting is supported and at most one nested variable can be present. CMakeLexer.tokens["root"] = [ (r'\b(\w+)([ \t]*)(\()', bygroups(Name.Function, Text, Name.Function), '#push'), # fctn( @@ -34,7 +36,8 @@ CMakeLexer.tokens["root"] = [ (r'[<>]=', Punctuation), # used in FindPkgConfig.cmake (r'\$<', Operator, '#push'), # $<...> (r'<[^<|]+?>(\w*\.\.\.)?', Name.Variable), # <expr> - (r'(\$\w*\{)(.+?)(\})', bygroups(Operator, Name.Tag, Operator)), # ${..} $ENV{..} + (r'(\$\w*\{)([^\}\$]*)?(?:(\$\w*\{)([^\}]+?)(\}))?([^\}]*?)(\})', # ${..} $ENV{..}, possibly nested + bygroups(Operator, Name.Tag, Operator, Name.Tag, Operator, Name.Tag, Operator)), (r'([A-Z]+\{)(.+?)(\})', bygroups(Operator, Name.Tag, Operator)), # DATA{ ...} (r'[a-z]+(@|(://))((\\.)|[\w.+-:/\\])+', Name.Attribute), # URL, git@, ... (r'/\w[\w\.\+-/\\]*', Name.Attribute), # absolute path @@ -1317,7 +1317,6 @@ cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insall cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP" cmake_report cmConfigure.h${_tmp} "#define CM_FALLTHROUGH" -cmake_report cmConfigure.h${_tmp} "#define CM_DISABLE_COPY(Class)" # Regenerate configured headers for h in Configure VersionConfig; do |