Merge topic 'configure-log'

f6ed2585e5 Modules: Record system inspection steps in the configure log
0f688386ea Modules: Drop redundant check logging to CMakeOutput.log and CMakeError.log
ecc26f98eb UsewxWidgets: Remove leftover debugging code
874c2e1198 FindQt4: Drop outdated advice to look at CMakeError.log on failure
a80465bcad GHS: Drop debugging message from log
9199449687 CompileFeatures: Warn explicitly when feature detection binary is not found
24ccc8c3c9 CompilerId: Restore logging of failed identifications
95976514f6 Tests: Avoid using CMake{Output,Error}.log files

Acked-by: Kitware Robot <[email protected]>
Merge-request: !8089

Modules/CMakeDetermineCUDACompiler.cmake

@@ -520,10 +520,10 @@ elseif(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
     set(_SET_CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT
       "set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT \"${CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT}\")")
 
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Parsed CUDA nvcc implicit link information from above output:\n${_nvcc_log}\n${log}\n\n")
+    message(CONFIGURE_LOG
+      "Parsed CUDA nvcc implicit link information:\n${_nvcc_log}\n${log}\n\n")
   else()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+    message(CONFIGURE_LOG
       "Failed to parse CUDA nvcc implicit link information:\n${_nvcc_log}\n\n")
     message(FATAL_ERROR "Failed to extract nvcc implicit link line.")
   endif()
@@ -576,10 +576,10 @@ if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
       list(APPEND CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "${line}")
     endforeach()
 
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Parsed CUDA nvcc include information from above output:\n${_nvcc_log}\n${log}\n\n")
+    message(CONFIGURE_LOG
+      "Parsed CUDA nvcc include information:\n${_nvcc_log}\n${log}\n\n")
   else()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    message(CONFIGURE_LOG
       "Failed to detect CUDA nvcc include information:\n${_nvcc_log}\n\n")
   endif()
 

Modules/CMakeDetermineCompilerABI.cmake

@@ -82,8 +82,6 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
     # Load the resulting information strings.
     if(CMAKE_${lang}_ABI_COMPILED)
       message(CHECK_PASS "done")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Detecting ${lang} compiler ABI info compiled with the following output:\n${OUTPUT}\n\n")
       file(STRINGS "${BIN}" ABI_STRINGS LIMIT_COUNT 32 REGEX "INFO:[A-Za-z0-9_]+\\[[^]]*\\]")
       set(ABI_SIZEOF_DPTR "NOTFOUND")
       set(ABI_BYTE_ORDER "NOTFOUND")
@@ -126,8 +124,8 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
         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")
+        message(CONFIGURE_LOG
+          "Parsed ${lang} implicit include dir info: rv=${rv}\n${log}\n\n")
         if("${rv}" STREQUAL "done")
           # Entries that we have been told to explicitly pass as standard include
           # directories will not be implicitly added by the compiler.
@@ -151,8 +149,8 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
           "${CMAKE_${lang}_IMPLICIT_OBJECT_REGEX}"
           COMPUTE_IMPLICIT_OBJECTS implicit_objs
           LANGUAGE ${lang})
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-          "Parsed ${lang} implicit link information from above output:\n${log}\n\n")
+        message(CONFIGURE_LOG
+          "Parsed ${lang} implicit link information:\n${log}\n\n")
       endif()
       # for VS IDE Intel Fortran we have to figure out the
       # implicit link path for the fortran run time using
@@ -195,8 +193,6 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
 
     else()
       message(CHECK_FAIL "failed")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Detecting ${lang} compiler ABI info failed to compile with the following output:\n${OUTPUT}\n${_copy_error}\n\n")
     endif()
   endif()
 endfunction()

Modules/CMakeDetermineCompilerId.cmake

@@ -2,6 +2,8 @@
 # file Copyright.txt or https://cmake.org/licensing for details.
 
 macro(__determine_compiler_id_test testflags_var userflags_var)
+  set(_CMAKE_${lang}_COMPILER_ID_LOG "")
+
   separate_arguments(testflags UNIX_COMMAND "${${testflags_var}}")
   CMAKE_DETERMINE_COMPILER_ID_BUILD("${lang}" "${testflags}" "${${userflags_var}}" "${src}")
   CMAKE_DETERMINE_COMPILER_ID_MATCH_VENDOR("${lang}" "${COMPILER_${lang}_PRODUCED_OUTPUT}")
@@ -11,6 +13,9 @@ macro(__determine_compiler_id_test testflags_var userflags_var)
       CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}")
     endforeach()
   endif()
+
+  message(CONFIGURE_LOG "${_CMAKE_${lang}_COMPILER_ID_LOG}")
+  unset(_CMAKE_${lang}_COMPILER_ID_LOG)
 endmacro()
 
 # Function to compile a source file to identify the compiler.  This is
@@ -85,8 +90,6 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
   # If the compiler is still unknown, fallback to GHS
   if(NOT CMAKE_${lang}_COMPILER_ID  AND "${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI")
     set(CMAKE_${lang}_COMPILER_ID GHS)
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "The ${lang} compiler identification is falling back to GHS.\n\n")
   endif()
 
   # CUDA < 7.5 is missing version macros
@@ -116,7 +119,7 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
       RESULT_VARIABLE result
       TIMEOUT 10
     )
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    message(CONFIGURE_LOG
       "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" -version\n"
       "${output}\n"
       )
@@ -140,7 +143,7 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
       RESULT_VARIABLE result
       TIMEOUT 10
     )
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    message(CONFIGURE_LOG
       "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" -version\n"
       "${output}\n"
       )
@@ -160,7 +163,7 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
       RESULT_VARIABLE result
       TIMEOUT 10
     )
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    message(CONFIGURE_LOG
       "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" --version\n"
       "${output}\n"
       )
@@ -724,7 +727,7 @@ Id flags: ${testflags} ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS}
      OR CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "warning #5117: Bad # preprocessor line"
      )
     # Compilation failed.
-    string(APPEND _CMAKE_DETERMINE_COMPILER_ID_BUILD_MSG
+    set(MSG
       "Compiling the ${lang} compiler identification source file \"${src}\" failed.
 ${COMPILER_DESCRIPTION}
 The output was:
@@ -734,14 +737,16 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
 ")
     # Log the output unless we recognize it as a known-bad case.
     if(NOT CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "warning #5117: Bad # preprocessor line")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}")
+      string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG "${MSG}")
     endif()
 
+    string(APPEND _CMAKE_DETERMINE_COMPILER_ID_BUILD_MSG "${MSG}")
+
     # Some languages may know the correct/desired set of flags and want to fail right away if they don't work.
     # This is currently only used by CUDA.
     if(__compiler_id_require_success)
       message(FATAL_ERROR "${_CMAKE_DETERMINE_COMPILER_ID_BUILD_MSG}")
-    else()
+    elseif(CMAKE_${lang}_COMPILER_ID_REQUIRE_SUCCESS)
       # Build up the outputs for compiler detection attempts so that users
       # can see all set of flags tried, instead of just last
       set(_CMAKE_DETERMINE_COMPILER_ID_BUILD_MSG "${_CMAKE_DETERMINE_COMPILER_ID_BUILD_MSG}" PARENT_SCOPE)
@@ -752,7 +757,7 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
     set(COMPILER_${lang}_PRODUCED_OUTPUT)
   else()
     # Compilation succeeded.
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
       "Compiling the ${lang} compiler identification source file \"${src}\" succeeded.
 ${COMPILER_DESCRIPTION}
 The output was:
@@ -781,7 +786,7 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
     foreach(file ${files})
       if(NOT IS_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}/${file})
         list(APPEND COMPILER_${lang}_PRODUCED_FILES ${file})
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
           "Compilation of the ${lang} compiler identification source \""
           "${src}\" produced \"${file}\"\n\n")
       endif()
@@ -789,7 +794,7 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
 
     if(NOT COMPILER_${lang}_PRODUCED_FILES)
       # No executable was found.
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+      string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
         "Compilation of the ${lang} compiler identification source \""
         "${src}\" did not produce an executable in \""
         "${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n")
@@ -801,6 +806,7 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
   # Return the files produced by the compilation.
   set(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
   set(COMPILER_${lang}_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE)
+  set(_CMAKE_${lang}_COMPILER_ID_LOG "${_CMAKE_${lang}_COMPILER_ID_LOG}" PARENT_SCOPE)
 
 endfunction()
 
@@ -994,15 +1000,16 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
     # Check the compiler identification string.
     if(CMAKE_${lang}_COMPILER_ID)
       # The compiler identification was found.
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \""
-        "${file}\"\n\n")
+      string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
+        "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in:\n"
+        "  ${file}\n\n")
     else()
       # The compiler identification could not be found.
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "The ${lang} compiler identification could not be found in \""
-        "${file}\"\n\n")
+      string(APPEND _CMAKE_${lang}_COMPILER_ID_LOG
+        "The ${lang} compiler identification could not be found in:\n"
+        "  ${file}\n\n")
     endif()
+    set(_CMAKE_${lang}_COMPILER_ID_LOG "${_CMAKE_${lang}_COMPILER_ID_LOG}" PARENT_SCOPE)
   endif()
 
   # try to figure out the executable format: ELF, COFF, Mach-O
@@ -1089,7 +1096,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang userflags)
       )
 
     if("${output}" MATCHES "${regex}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+      message(CONFIGURE_LOG
         "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
         "matched \"${regex}\":\n${output}")
       set(CMAKE_${lang}_COMPILER_ID "${vendor}" PARENT_SCOPE)
@@ -1098,11 +1105,11 @@ function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang userflags)
       break()
     else()
       if("${result}" MATCHES  "timeout")
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        message(CONFIGURE_LOG
           "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
           "terminated after 10 s due to timeout.")
       else()
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        message(CONFIGURE_LOG
           "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
           "did not match \"${regex}\":\n${output}")
        endif()

Modules/CMakeDetermineFortranCompiler.cmake

@@ -187,11 +187,11 @@ if(NOT CMAKE_Fortran_COMPILER_ID_RUN)
     if(NOT CMAKE_COMPILER_RETURN)
       if(CMAKE_COMPILER_OUTPUT MATCHES "THIS_IS_GNU")
         set(CMAKE_Fortran_COMPILER_ID "GNU")
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        message(CONFIGURE_LOG
           "Determining if the Fortran compiler is GNU succeeded with "
           "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
       else()
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        message(CONFIGURE_LOG
           "Determining if the Fortran compiler is GNU failed with "
           "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
       endif()

Modules/CMakeDetermineSystem.cmake

@@ -196,13 +196,14 @@ endif()
 if(CMAKE_BINARY_DIR)
   # write entry to the log file
   if(PRESET_CMAKE_SYSTEM_NAME)
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-                "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-                "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n")
+    message(CONFIGURE_LOG
+      "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n"
+      "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n"
+      )
   else()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-                "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
+    message(CONFIGURE_LOG
+      "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n"
+      )
   endif()
 
   # if a toolchain file is used, it needs to be included in the configured file,

Modules/CMakeTestCCompiler.cmake

@@ -63,9 +63,6 @@ if(NOT CMAKE_C_COMPILER_WORKS)
   __TestCompiler_restoreTryCompileTargetType()
   if(NOT CMAKE_C_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the C compiler works failed with "
-      "the following output:\n${__CMAKE_C_COMPILER_OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${__CMAKE_C_COMPILER_OUTPUT}")
     message(FATAL_ERROR "The C compiler\n  \"${CMAKE_C_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -73,9 +70,6 @@ if(NOT CMAKE_C_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the C compiler works passed with "
-    "the following output:\n${__CMAKE_C_COMPILER_OUTPUT}\n\n")
 endif()
 
 # Try to identify the compiler features

Modules/CMakeTestCSharpCompiler.cmake

@@ -44,9 +44,6 @@ endif()
 
 if(NOT CMAKE_CSharp_COMPILER_WORKS)
   PrintTestCompilerResult(CHECK_FAIL "broken")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-    "Determining if the C# compiler works failed with "
-    "the following output:\n${__CMAKE_CSharp_COMPILER_OUTPUT}\n\n")
   string(REPLACE "\n" "\n  " _output "${__CMAKE_CSharp_COMPILER_OUTPUT}")
   message(FATAL_ERROR "The C# compiler\n  \"${CMAKE_CSharp_COMPILER}\"\n"
     "is not able to compile a simple test program.\nIt fails "
@@ -55,9 +52,6 @@ if(NOT CMAKE_CSharp_COMPILER_WORKS)
 else()
   if(CSharp_TEST_WAS_RUN)
     PrintTestCompilerResult(CHECK_PASS "works")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining if the C# compiler works passed with "
-      "the following output:\n${__CMAKE_CSharp_COMPILER_OUTPUT}\n\n")
   endif()
 
   # Re-configure to save learned information.

Modules/CMakeTestCUDACompiler.cmake

@@ -60,7 +60,7 @@ if(CMAKE_CUDA_ABI_COMPILED)
       set(_CUDA_ARCHS_STATUS "")
     endif()
     string(REPLACE "\n" "\n  " _CUDA_ARCHS_OUTPUT "  ${_CUDA_ARCHS_OUTPUT}")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+    message(CONFIGURE_LOG
       "Detecting the CUDA native architecture(s) failed with "
       "the following output:\n${_CUDA_ARCHS_OUTPUT}\n\n")
   endif()
@@ -96,9 +96,6 @@ if(NOT CMAKE_CUDA_COMPILER_WORKS)
   unset(CMAKE_CUDA_COMPILER_WORKS CACHE)
   if(NOT CMAKE_CUDA_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the CUDA compiler works failed with "
-      "the following output:\n${__CMAKE_CUDA_COMPILER_OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${__CMAKE_CUDA_COMPILER_OUTPUT}")
     message(FATAL_ERROR "The CUDA compiler\n  \"${CMAKE_CUDA_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -106,9 +103,6 @@ if(NOT CMAKE_CUDA_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the CUDA compiler works passed with "
-    "the following output:\n${__CMAKE_CUDA_COMPILER_OUTPUT}\n\n")
 endif()
 
 # Try to identify the compiler features

Modules/CMakeTestCXXCompiler.cmake

@@ -56,9 +56,6 @@ if(NOT CMAKE_CXX_COMPILER_WORKS)
   __TestCompiler_restoreTryCompileTargetType()
   if(NOT CMAKE_CXX_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the C++ compiler works failed with "
-      "the following output:\n${__CMAKE_CXX_COMPILER_OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${__CMAKE_CXX_COMPILER_OUTPUT}")
     message(FATAL_ERROR "The C++ compiler\n  \"${CMAKE_CXX_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -66,9 +63,6 @@ if(NOT CMAKE_CXX_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the C++ compiler works passed with "
-    "the following output:\n${__CMAKE_CXX_COMPILER_OUTPUT}\n\n")
 endif()
 
 # Try to identify the compiler features

Modules/CMakeTestFortranCompiler.cmake

@@ -55,9 +55,6 @@ if(NOT CMAKE_Fortran_COMPILER_WORKS)
   unset(CMAKE_Fortran_COMPILER_WORKS CACHE)
   if(NOT CMAKE_Fortran_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the Fortran compiler works failed with "
-      "the following output:\n${OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${OUTPUT}")
     message(FATAL_ERROR "The Fortran compiler\n  \"${CMAKE_Fortran_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -65,9 +62,6 @@ if(NOT CMAKE_Fortran_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the Fortran compiler works passed with "
-    "the following output:\n${OUTPUT}\n\n")
 endif()
 
 # Test for Fortran 90 support by using an f90-specific construct.
@@ -84,15 +78,9 @@ if(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F90)
   unset(__TestCompiler_testFortranCompilerF90Source)
   if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
     message(CHECK_PASS "yes")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining if the Fortran compiler supports Fortran 90 passed with "
-      "the following output:\n${OUTPUT}\n\n")
     set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1)
   else()
     message(CHECK_FAIL "no")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the Fortran compiler supports Fortran 90 failed with "
-      "the following output:\n${OUTPUT}\n\n")
     set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 0)
   endif()
   unset(CMAKE_Fortran_COMPILER_SUPPORTS_F90 CACHE)

Modules/CMakeTestHIPCompiler.cmake

@@ -59,9 +59,6 @@ if(NOT CMAKE_HIP_COMPILER_WORKS)
   __TestCompiler_restoreTryCompileTargetType()
   if(NOT CMAKE_HIP_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the HIP compiler works failed with "
-      "the following output:\n${__CMAKE_HIP_COMPILER_OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${__CMAKE_HIP_COMPILER_OUTPUT}")
     message(FATAL_ERROR "The HIP compiler\n  \"${CMAKE_HIP_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -69,9 +66,6 @@ if(NOT CMAKE_HIP_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the HIP compiler works passed with "
-    "the following output:\n${__CMAKE_HIP_COMPILER_OUTPUT}\n\n")
 endif()
 
 set(CMAKE_HIP_FLAGS "${__CMAKE_HIP_FLAGS}")

Modules/CMakeTestOBJCCompiler.cmake

@@ -60,9 +60,6 @@ if(NOT CMAKE_OBJC_COMPILER_WORKS)
   __TestCompiler_restoreTryCompileTargetType()
   if(NOT CMAKE_OBJC_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the Objective-C compiler works failed with "
-      "the following output:\n${__CMAKE_OBJC_COMPILER_OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${__CMAKE_OBJC_COMPILER_OUTPUT}")
     message(FATAL_ERROR "The Objective-C compiler\n  \"${CMAKE_OBJC_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -70,9 +67,6 @@ if(NOT CMAKE_OBJC_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the Objective-C compiler works passed with "
-    "the following output:\n${__CMAKE_OBJC_COMPILER_OUTPUT}\n\n")
 endif()
 
 # Try to identify the compiler features

Modules/CMakeTestOBJCXXCompiler.cmake

@@ -59,9 +59,6 @@ if(NOT CMAKE_OBJCXX_COMPILER_WORKS)
   __TestCompiler_restoreTryCompileTargetType()
   if(NOT CMAKE_OBJCXX_COMPILER_WORKS)
     PrintTestCompilerResult(CHECK_FAIL "broken")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the Objective-C++ compiler works failed with "
-      "the following output:\n${__CMAKE_OBJCXX_COMPILER_OUTPUT}\n\n")
     string(REPLACE "\n" "\n  " _output "${__CMAKE_OBJCXX_COMPILER_OUTPUT}")
     message(FATAL_ERROR "The Objective-C++ compiler\n  \"${CMAKE_OBJCXX_COMPILER}\"\n"
       "is not able to compile a simple test program.\nIt fails "
@@ -69,9 +66,6 @@ if(NOT CMAKE_OBJCXX_COMPILER_WORKS)
       "CMake will not be able to correctly generate this project.")
   endif()
   PrintTestCompilerResult(CHECK_PASS "works")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-    "Determining if the Objective-C++ compiler works passed with "
-    "the following output:\n${__CMAKE_OBJCXX_COMPILER_OUTPUT}\n\n")
 endif()
 
 # Try to identify the compiler features

Modules/CMakeTestSwiftCompiler.cmake

@@ -36,9 +36,6 @@ endif()
 
 if(NOT CMAKE_Swift_COMPILER_WORKS)
   PrintTestCompilerResult(CHECK_FAIL "broken")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-    "Determining if the Swift compiler works failed with "
-    "the following output:\n${__CMAKE_Swift_COMPILER_OUTPUT}\n\n")
   string(REPLACE "\n" "\n  " _output "${__CMAKE_Swift_COMPILER_OUTPUT}")
   message(FATAL_ERROR "The Swift compiler\n  \"${CMAKE_Swift_COMPILER}\"\n"
     "is not able to compile a simple test program.\nIt fails "
@@ -47,9 +44,6 @@ if(NOT CMAKE_Swift_COMPILER_WORKS)
 else()
   if(Swift_TEST_WAS_RUN)
     PrintTestCompilerResult(CHECK_PASS "works")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining if the Swift compiler works passed with "
-      "the following output:\n${__CMAKE_Swift_COMPILER_OUTPUT}\n\n")
   endif()
 
   # Unlike C and CXX we do not yet detect any information about the Swift ABI.

Modules/CheckFortranFunctionExists.cmake

@@ -70,21 +70,14 @@ macro(CHECK_FORTRAN_FUNCTION_EXISTS FUNCTION VARIABLE)
       SOURCE_FROM_VAR testFortranCompiler.f __CheckFunction_testFortranCompilerSource
       ${CHECK_FUNCTION_EXISTS_ADD_LINK_OPTIONS}
       ${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES}
-      OUTPUT_VARIABLE OUTPUT
     )
     unset(__CheckFunction_testFortranCompilerSource)
     if(${VARIABLE})
       set(${VARIABLE} 1 CACHE INTERNAL "Have Fortran function ${FUNCTION}")
       message(CHECK_PASS "found")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the Fortran ${FUNCTION} exists passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       message(CHECK_FAIL "not found")
       set(${VARIABLE} "" CACHE INTERNAL "Have Fortran function ${FUNCTION}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the Fortran ${FUNCTION} exists failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/CheckFunctionExists.cmake

@@ -95,7 +95,7 @@ macro(CHECK_FUNCTION_EXISTS FUNCTION VARIABLE)
       ${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES}
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
       "${CHECK_FUNCTION_EXISTS_ADD_INCLUDES}"
-      OUTPUT_VARIABLE OUTPUT)
+      )
     unset(_cfe_source)
 
     if(${VARIABLE})
@@ -103,17 +103,11 @@ macro(CHECK_FUNCTION_EXISTS FUNCTION VARIABLE)
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_PASS "found")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the function ${FUNCTION} exists passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
       set(${VARIABLE} "" CACHE INTERNAL "Have function ${FUNCTION}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the function ${FUNCTION} exists failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/CheckIPOSupported.cmake

@@ -150,9 +150,6 @@ macro(_ipo_run_language_check language)
   unset(_IPO_LANGUAGE_CHECK_RESULT CACHE)
 
   if(NOT _IPO_LANGUAGE_CHECK_RESULT)
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "${language} compiler IPO check failed with the following output:\n"
-      "${output}\n")
     _ipo_not_supported("check failed to compile")
     if(X_OUTPUT)
       set("${X_OUTPUT}" "${output}" PARENT_SCOPE)

Modules/CheckIncludeFile.cmake

@@ -100,7 +100,7 @@ macro(CHECK_INCLUDE_FILE INCLUDE VARIABLE)
       CMAKE_FLAGS
       -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_INCLUDE_FILE_FLAGS}
       "${CHECK_INCLUDE_FILE_C_INCLUDE_DIRS}"
-      OUTPUT_VARIABLE OUTPUT)
+      )
     unset(_CIF_LINK_OPTIONS)
     unset(_CIF_LINK_LIBRARIES)
 
@@ -113,19 +113,11 @@ macro(CHECK_INCLUDE_FILE INCLUDE VARIABLE)
         message(CHECK_PASS "found")
       endif()
       set(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the include file ${INCLUDE} "
-        "exists passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
       set(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the include file ${INCLUDE} "
-        "exists failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/CheckIncludeFileCXX.cmake

@@ -99,7 +99,7 @@ macro(CHECK_INCLUDE_FILE_CXX INCLUDE VARIABLE)
       CMAKE_FLAGS
       -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_INCLUDE_FILE_FLAGS}
       "${CHECK_INCLUDE_FILE_CXX_INCLUDE_DIRS}"
-      OUTPUT_VARIABLE OUTPUT)
+      )
     unset(_CIF_LINK_OPTIONS)
     unset(_CIF_LINK_LIBRARIES)
 
@@ -112,19 +112,11 @@ macro(CHECK_INCLUDE_FILE_CXX INCLUDE VARIABLE)
         message(CHECK_PASS "found")
       endif()
       set(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the include file ${INCLUDE} "
-        "exists passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
       set(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the include file ${INCLUDE} "
-        "exists failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/CheckIncludeFiles.cmake

@@ -142,7 +142,7 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
       CMAKE_FLAGS
       -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_INCLUDE_FILES_FLAGS}
       "${CHECK_INCLUDE_FILES_INCLUDE_DIRS}"
-      OUTPUT_VARIABLE OUTPUT)
+      )
     unset(_CIF_LINK_OPTIONS)
     unset(_CIF_LINK_LIBRARIES)
     if(${VARIABLE})
@@ -150,19 +150,11 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
         message(CHECK_PASS "found")
       endif()
       set(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if files ${INCLUDE} "
-        "exist passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
       set(${VARIABLE} "" CACHE INTERNAL "Have includes ${INCLUDE}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if files ${INCLUDE} "
-        "exist failed with the following output:\n"
-        "${OUTPUT}\nSource:\n${_src_content}\n")
     endif()
   endif()
 endmacro()

Modules/CheckLanguage.cmake

@@ -90,14 +90,14 @@ file(WRITE \"\${CMAKE_CURRENT_BINARY_DIR}/result.cmake\"
       )
     include(${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/Check${lang}/result.cmake OPTIONAL)
     if(CMAKE_${lang}_COMPILER AND "${_cl_result}" STREQUAL "0")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+      message(CONFIGURE_LOG
         "${_desc} passed with the following output:\n"
         "${_cl_output}\n")
       set(_CHECK_COMPILER_STATUS CHECK_PASS)
     else()
       set(CMAKE_${lang}_COMPILER NOTFOUND)
       set(_CHECK_COMPILER_STATUS CHECK_FAIL)
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+      message(CONFIGURE_LOG
         "${_desc} failed with the following output:\n"
         "${_cl_output}\n")
     endif()

Modules/CheckLibraryExists.cmake

@@ -76,7 +76,7 @@ macro(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE)
       CMAKE_FLAGS
       -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_LIBRARY_EXISTS_DEFINITION}
       -DLINK_DIRECTORIES:STRING=${LOCATION}
-      OUTPUT_VARIABLE OUTPUT)
+      )
     unset(_cle_source)
 
     if(${VARIABLE})
@@ -84,19 +84,11 @@ macro(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE)
         message(CHECK_PASS "found")
       endif()
       set(${VARIABLE} 1 CACHE INTERNAL "Have library ${LIBRARY}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the function ${FUNCTION} exists in the ${LIBRARY} "
-        "passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
       set(${VARIABLE} "" CACHE INTERNAL "Have library ${LIBRARY}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the function ${FUNCTION} exists in the ${LIBRARY} "
-        "failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/CheckPrototypeDefinition.cmake

@@ -104,24 +104,18 @@ function(check_prototype_definition _FUNCTION _PROTOTYPE _RETURN _HEADER _VARIAB
       ${CHECK_PROTOTYPE_DEFINITION_LIBS}
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${CHECK_PROTOTYPE_DEFINITION_FLAGS}
       "${CMAKE_SYMBOL_EXISTS_INCLUDES}"
-      OUTPUT_VARIABLE OUTPUT)
+      )
 
     if (${_VARIABLE})
       set(${_VARIABLE} 1 CACHE INTERNAL "Have correct prototype for ${_FUNCTION}")
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_PASS "True")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the prototype ${_FUNCTION} exists for ${_VARIABLE} passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else ()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "False")
       endif()
       set(${_VARIABLE} 0 CACHE INTERNAL "Have correct prototype for ${_FUNCTION}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the prototype ${_FUNCTION} exists for ${_VARIABLE} failed with the following output:\n"
-        "${OUTPUT}\n\n${_SOURCE}\n\n")
     endif ()
   endif()
 

Modules/CheckSymbolExists.cmake

@@ -150,27 +150,17 @@ int main(int argc, char** argv)
       CMAKE_FLAGS
       -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_SYMBOL_EXISTS_FLAGS}
       "${CMAKE_SYMBOL_EXISTS_INCLUDES}"
-      OUTPUT_VARIABLE OUTPUT)
+      )
     if(${VARIABLE})
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_PASS "found")
       endif()
       set(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the ${SYMBOL} "
-        "exist passed with the following output:\n"
-        "${OUTPUT}\nFile ${SOURCEFILE}:\n"
-        "${_CSE_SOURCE}\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
       set(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the ${SYMBOL} "
-        "exist failed with the following output:\n"
-        "${OUTPUT}\nFile ${SOURCEFILE}:\n"
-        "${_CSE_SOURCE}\n")
     endif()
     unset(_CSE_SOURCE)
   endif()

Modules/CheckTypeSize.cmake

@@ -152,7 +152,6 @@ function(__check_type_size_impl type var map builtin language)
     CMAKE_FLAGS
       "-DCOMPILE_DEFINITIONS:STRING=${CMAKE_REQUIRED_FLAGS}"
       "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}"
-    OUTPUT_VARIABLE output
     COPY_FILE ${bin}
     )
 
@@ -203,16 +202,12 @@ function(__check_type_size_impl type var map builtin language)
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_PASS "done")
     endif()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining size of ${type} passed with the following output:\n${output}\n\n")
     set(${var} "${${var}}" CACHE INTERNAL "CHECK_TYPE_SIZE: sizeof(${type})")
   else()
     # The check failed to compile.
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_FAIL "failed")
     endif()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining size of ${type} failed with the following output:\n${output}\n${src}:\n${src_content}\n\n")
     set(${var} "" CACHE INTERNAL "CHECK_TYPE_SIZE: ${type} unknown")
     file(REMOVE ${map})
   endif()

Modules/CheckVariableExists.cmake

@@ -67,23 +67,17 @@ macro(CHECK_VARIABLE_EXISTS VAR VARIABLE)
       ${CHECK_VARIABLE_EXISTS_ADD_LINK_OPTIONS}
       ${CHECK_VARIABLE_EXISTS_ADD_LIBRARIES}
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_VARIABLE_DEFINITIONS}
-      OUTPUT_VARIABLE OUTPUT)
+      )
     if(${VARIABLE})
       set(${VARIABLE} 1 CACHE INTERNAL "Have variable ${VAR}")
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_PASS "found")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the variable ${VAR} exists passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       set(${VARIABLE} "" CACHE INTERNAL "Have variable ${VAR}")
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the variable ${VAR} exists failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/Compiler/NAG-Fortran.cmake

@@ -14,7 +14,7 @@ if(NOT CMAKE_Fortran_COMPILER_WORKS AND NOT CMAKE_Fortran_COMPILER_FORCED)
     string(REGEX REPLACE "/[^/]*$" "" _nag_dir "${_nag_obj}")
     string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" _nag_regex "${_nag_dir}")
     set(CMAKE_Fortran_IMPLICIT_OBJECT_REGEX "^${_nag_regex}/")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+    message(CONFIGURE_LOG
       "Detecting NAG Fortran directory with -dryrun found\n"
       "  object: ${_nag_obj}\n"
       "  directory: ${_nag_dir}\n"
@@ -22,7 +22,7 @@ if(NOT CMAKE_Fortran_COMPILER_WORKS AND NOT CMAKE_Fortran_COMPILER_FORCED)
       "from output:\n${_dryrun}\n\n")
     message(CHECK_PASS "${_nag_dir}")
   else()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+    message(CONFIGURE_LOG
       "Detecting NAG Fortran directory with -dryrun failed:\n${_dryrun}\n\n")
     message(CHECK_FAIL "failed")
   endif()

Modules/FindMFC.cmake

@@ -49,15 +49,9 @@ if(MFC_ATTEMPT_TRY_COMPILE)
     if(MFC_HAVE_MFC)
       message(CHECK_PASS "found")
       set(MFC_HAVE_MFC 1 CACHE INTERNAL "Have MFC?")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if MFC exists passed with the following output:\n"
-        "${OUTPUT}\n\n")
     else()
       message(CHECK_FAIL "not found")
       set(MFC_HAVE_MFC 0 CACHE INTERNAL "Have MFC?")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if MFC exists failed with the following output:\n"
-        "${OUTPUT}\n\n")
     endif()
   endif()
 

Modules/FindMPI.cmake

@@ -1259,9 +1259,16 @@ function(_MPI_try_staged_settings LANG MPI_TEST_FILE_NAME MODE RUN_BINARY SUPPRE
     file(READ "${SRC_DIR}/${MPI_TEST_FILE_NAME}.c" MPI_TEST_SOURCE_CONTENT)
     set(MPI_TEST_SOURCE_FILE "${MPI_TEST_FILE_NAME}.c")
   endif()
+  if(SUPPRESS_ERRORS)
+    set(maybe_no_log NO_LOG)
+  else()
+    set(maybe_no_log "")
+  endif()
   if(RUN_BINARY)
     try_run(MPI_RUN_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE} MPI_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}
       SOURCE_FROM_VAR "${MPI_TEST_SOURCE_FILE}" MPI_TEST_SOURCE_CONTENT
+      ${maybe_no_log}
+      LOG_DESCRIPTION "The MPI test ${MPI_TEST_FILE_NAME} for ${LANG} in mode ${MODE}"
       COMPILE_DEFINITIONS ${MPI_TEST_COMPILE_DEFINITIONS}
       LINK_LIBRARIES MPI::MPI_${LANG}
       RUN_OUTPUT_VARIABLE MPI_RUN_OUTPUT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}
@@ -1270,20 +1277,13 @@ function(_MPI_try_staged_settings LANG MPI_TEST_FILE_NAME MODE RUN_BINARY SUPPRE
   else()
     try_compile(MPI_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}
       SOURCE_FROM_VAR "${MPI_TEST_SOURCE_FILE}" MPI_TEST_SOURCE_CONTENT
+      ${maybe_no_log}
+      LOG_DESCRIPTION "The MPI test ${MPI_TEST_FILE_NAME} for ${LANG} in mode ${MODE}"
       COMPILE_DEFINITIONS ${MPI_TEST_COMPILE_DEFINITIONS}
       LINK_LIBRARIES MPI::MPI_${LANG}
       COPY_FILE "${BIN_FILE}"
       OUTPUT_VARIABLE _MPI_TRY_${MPI_TEST_FILE_NAME}_${MODE}_OUTPUT)
   endif()
-  if(NOT SUPPRESS_ERRORS)
-    if(NOT MPI_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE})
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-          "The MPI test ${MPI_TEST_FILE_NAME} for ${LANG} in mode ${MODE} failed to compile with the following output:\n${_MPI_TRY_${MPI_TEST_FILE_NAME}_${MODE}_OUTPUT}\n\n")
-    elseif(DEFINED MPI_RUN_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE} AND MPI_RUN_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE})
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-          "The MPI test ${MPI_TEST_FILE_NAME} for ${LANG} in mode ${MODE} failed to run with the following output:\n${MPI_RUN_OUTPUT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}}\n\n")
-    endif()
-  endif()
 endfunction()
 
 macro(_MPI_check_lang_works LANG SUPPRESS_ERRORS)

Modules/FindOpenMP.cmake

@@ -214,6 +214,7 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
     string(REGEX REPLACE "[-/=+]" "" OPENMP_PLAIN_FLAG "${OPENMP_FLAG}")
     try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
       SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
+      LOG_DESCRIPTION "Detecting ${LANG} OpenMP compiler info"
       CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
       LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG}
       OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
@@ -228,9 +229,6 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
         unset(OpenMP_${LANG}_IMPLICIT_FWK_DIRS)
         unset(OpenMP_${LANG}_LOG_VAR)
 
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Detecting ${LANG} OpenMP compiler ABI info compiled with the following output:\n${OpenMP_TRY_COMPILE_OUTPUT}\n\n")
-
         cmake_parse_implicit_link_info("${OpenMP_TRY_COMPILE_OUTPUT}"
           OpenMP_${LANG}_IMPLICIT_LIBRARIES
           OpenMP_${LANG}_IMPLICIT_LINK_DIRS
@@ -240,9 +238,6 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
           LANGUAGE ${LANG}
         )
 
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Parsed ${LANG} OpenMP implicit link information from above output:\n${OpenMP_${LANG}_LOG_VAR}\n\n")
-
         # For LCC we should additionally alanyze -print-search-dirs output
         # to check for additional implicit_dirs.
         # Note: This won't work if CMP0129 policy is set to OLD!
@@ -255,11 +250,14 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
           if("${output_lines}" MATCHES ".*\nlibraries:[ \t]+(.*:)\n.*")
             string(REPLACE ":" ";" implicit_dirs_addon "${CMAKE_MATCH_1}")
             list(PREPEND OpenMP_${LANG}_IMPLICIT_LINK_DIRS ${implicit_dirs_addon})
-            file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+            string(APPEND OpenMP_${LANG}_LOG_VAR
               "  Extended OpenMP library search paths: [${implicit_dirs}]\n")
           endif()
         endif()
 
+        message(CONFIGURE_LOG
+          "Parsed ${LANG} OpenMP implicit link information from above output:\n${OpenMP_${LANG}_LOG_VAR}\n\n")
+
         unset(_OPENMP_LIB_NAMES)
         foreach(_OPENMP_IMPLICIT_LIB IN LISTS OpenMP_${LANG}_IMPLICIT_LIBRARIES)
           get_filename_component(_OPENMP_IMPLICIT_LIB_DIR "${_OPENMP_IMPLICIT_LIB}" DIRECTORY)
@@ -312,9 +310,9 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
         # default header search path already.
         try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
           SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
+          LOG_DESCRIPTION "Trying ${LANG} OpenMP compiler with '${OpenMP_libomp_LIBRARY}'"
           CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
           LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} ${OpenMP_libomp_LIBRARY}
-          OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
         )
         if(NOT OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG})
           find_path(OpenMP_${LANG}_INCLUDE_DIR omp.h)
@@ -323,10 +321,10 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
           if(OpenMP_${LANG}_INCLUDE_DIR)
             try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
               SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
+              LOG_DESCRIPTION "Trying ${LANG} OpenMP compiler with '${OpenMP_libomp_LIBRARY}' and '${OpenMP_${LANG}_INCLUDE_DIR}'"
               CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
                           "-DINCLUDE_DIRECTORIES:STRING=${OpenMP_${LANG}_INCLUDE_DIR}"
               LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} ${OpenMP_libomp_LIBRARY}
-              OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
             )
           endif()
         endif()
@@ -346,9 +344,9 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
       if(OpenMP_libomp_LIBRARY)
         try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
           SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
+          LOG_DESCRIPTION "Trying ${LANG} OpenMP compiler with '${OpenMP_libomp_LIBRARY}'"
           CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
           LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} ${OpenMP_libomp_LIBRARY}
-          OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
         )
         if(OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG})
           set("${OPENMP_FLAG_VAR}" "${OPENMP_FLAG}" PARENT_SCOPE)
@@ -356,9 +354,6 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
           break()
         endif()
       endif()
-    else()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Detecting ${LANG} OpenMP failed with the following output:\n${OpenMP_TRY_COMPILE_OUTPUT}\n\n")
     endif()
     set("${OPENMP_LIB_NAMES_VAR}" "NOTFOUND" PARENT_SCOPE)
     set("${OPENMP_FLAG_VAR}" "NOTFOUND" PARENT_SCOPE)
@@ -419,9 +414,10 @@ function(_OPENMP_GET_SPEC_DATE LANG SPEC_DATE)
   string(REGEX REPLACE "[-/=+]" "" OPENMP_PLAIN_FLAG "${OPENMP_FLAG}")
   try_compile(OpenMP_SPECTEST_${LANG}_${OPENMP_PLAIN_FLAG}
     SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
+    LOG_DESCRIPTION "Detecting ${LANG} OpenMP version"
     CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OpenMP_${LANG}_FLAGS}" ${_includeDirFlags}
     COPY_FILE "${BIN_FILE}"
-    OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT)
+    )
 
   if(${OpenMP_SPECTEST_${LANG}_${OPENMP_PLAIN_FLAG}})
     file(STRINGS ${BIN_FILE} specstr LIMIT_COUNT 1 REGEX "INFO:OpenMP-date")
@@ -429,9 +425,6 @@ function(_OPENMP_GET_SPEC_DATE LANG SPEC_DATE)
     if("${specstr}" MATCHES "${regex_spec_date}")
       set(${SPEC_DATE} "${CMAKE_MATCH_1}" PARENT_SCOPE)
     endif()
-  else()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Detecting ${LANG} OpenMP version failed with the following output:\n${OpenMP_TRY_COMPILE_OUTPUT}\n\n")
   endif()
 endfunction()
 

Modules/FindQt4.cmake

@@ -623,7 +623,7 @@ if (QT_QMAKE_EXECUTABLE AND
     endif()
     set(Qt4_FOUND FALSE)
     if(Qt4_FIND_REQUIRED)
-      message( FATAL_ERROR "Could NOT find QtCore. Check ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log for more details.")
+      message( FATAL_ERROR "Could NOT find QtCore.")
     else()
       return()
     endif()

Modules/FindThreads.cmake

@@ -136,10 +136,8 @@ macro(_threads_check_flag_pthread)
       try_compile(THREADS_HAVE_PTHREAD_ARG
         SOURCE_FROM_FILE "${_threads_src}" "${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c"
         CMAKE_FLAGS -DLINK_LIBRARIES:STRING=-pthread
-        OUTPUT_VARIABLE _cmake_check_pthreads_output)
+        )
 
-      string(APPEND _cmake_find_threads_output "${_cmake_check_pthreads_output}")
-      unset(_cmake_check_pthreads_output)
       unset(_threads_src)
 
       if(THREADS_HAVE_PTHREAD_ARG)
@@ -239,10 +237,4 @@ if(THREADS_FOUND AND NOT TARGET Threads::Threads)
   if(CMAKE_THREAD_LIBS_INIT)
     set_property(TARGET Threads::Threads PROPERTY INTERFACE_LINK_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
   endif()
-elseif(NOT THREADS_FOUND AND _cmake_find_threads_output)
-  file(APPEND
-    ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-    "Determining if compiler accepts -pthread failed with the following output:\n${_cmake_find_threads_output}\n\n")
 endif()
-
-unset(_cmake_find_threads_output)

Modules/FortranCInterface.cmake

@@ -381,13 +381,9 @@ function(FortranCInterface_VERIFY)
     # Report results.
     if(FortranCInterface_VERIFY_${lang}_COMPILED)
       message(CHECK_PASS "Success")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "${_desc} passed with the following output:\n${_output}\n\n")
       set(FortranCInterface_VERIFIED_${lang} 1 CACHE INTERNAL "Fortran/${lang} compatibility")
     else()
       message(CHECK_FAIL "Failed")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "${_desc} failed with the following output:\n${_output}\n\n")
       set(FortranCInterface_VERIFIED_${lang} 0 CACHE INTERNAL "Fortran/${lang} compatibility")
     endif()
     unset(FortranCInterface_VERIFY_${lang}_COMPILED CACHE)

Modules/FortranCInterface/Detect.cmake

@@ -51,6 +51,7 @@ try_compile(FortranCInterface_COMPILED
   TARGET FortranCInterface
   SOURCE_DIR ${FortranCInterface_SOURCE_DIR}
   BINARY_DIR ${FortranCInterface_BINARY_DIR}
+  LOG_DESCRIPTION "Fortran/C interface test project"
   CMAKE_FLAGS
     "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}"
     "-DCMAKE_Fortran_FLAGS:STRING=${CMAKE_Fortran_FLAGS}"
@@ -58,7 +59,7 @@ try_compile(FortranCInterface_COMPILED
     "-DCMAKE_Fortran_FLAGS_RELEASE:STRING=${CMAKE_Fortran_FLAGS_RELEASE}"
     ${_FortranCInterface_OSX_ARCH}
     ${_FortranCInterface_EXE_LINKER_FLAGS}
-  OUTPUT_VARIABLE FortranCInterface_OUTPUT)
+  )
 set(FortranCInterface_COMPILED ${FortranCInterface_COMPILED})
 unset(FortranCInterface_COMPILED CACHE)
 unset(_FortranCInterface_EXE_LINKER_FLAGS)
@@ -70,9 +71,6 @@ if(FortranCInterface_COMPILED)
   include(${FortranCInterface_BINARY_DIR}/exe-Release.cmake OPTIONAL)
 else()
   set(_result "Failed to compile")
-  file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-    "Fortran/C interface test project failed with the following output:\n"
-    "${FortranCInterface_OUTPUT}\n")
 endif()
 
 # Load symbols from INFO:symbol[] strings in the executable.

Modules/Internal/CMakeTryCompilerOrLinkerFlag.cmake

@@ -51,7 +51,7 @@ function(CMAKE_TRY_COMPILER_OR_LINKER_FLAG lang flag result)
   if (NOT lang MATCHES "^(C|CXX|Fortran|ASM)$")
     # other possible languages are not supported
     # log message to keep trace of this problem...
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+    message(CONFIGURE_LOG
       "Function 'CMAKE_CHECK_COMPILER_FLAG' called with unsupported language: ${lang}\n")
     set(${result} FALSE CACHE INTERNAL ${comment})
     return()
@@ -144,7 +144,7 @@ function(CMAKE_TRY_COMPILER_OR_LINKER_FLAG lang flag result)
     endforeach()
   endif()
   if (DEFINED ${result})
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+    message(CONFIGURE_LOG
         "Determining if the ${flag} option "
         "is supported for ${lang} language failed with the following output:\n"
         "${COMPILER_FLAG_OUTPUT}\n")

Modules/Internal/CheckSourceCompiles.cmake

@@ -122,19 +122,11 @@ function(CMAKE_CHECK_SOURCE_COMPILES _lang _source _var)
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_PASS "Success")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Performing ${_lang_textual} SOURCE FILE Test ${_var} succeeded with the following output:\n"
-        "${OUTPUT}\n"
-        "Source file was:\n${_source}\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "Failed")
       endif()
       set(${_var} "" CACHE INTERNAL "Test ${_var}")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Performing ${_lang_textual} SOURCE FILE Test ${_var} failed with the following output:\n"
-        "${OUTPUT}\n"
-        "Source file was:\n${_source}\n")
     endif()
   endif()
 endfunction()

Modules/Internal/CheckSourceRuns.cmake

@@ -98,8 +98,7 @@ function(CMAKE_CHECK_SOURCE_RUNS _lang _source _var)
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${CMAKE_REQUIRED_FLAGS}
       -DCMAKE_SKIP_RPATH:BOOL=${CMAKE_SKIP_RPATH}
       "${CHECK_${_lang}_SOURCE_COMPILES_ADD_INCLUDES}"
-      COMPILE_OUTPUT_VARIABLE OUTPUT
-      RUN_OUTPUT_VARIABLE RUN_OUTPUT)
+      )
     # if it did not compile make the return value fail code of 1
     if(NOT ${_var}_COMPILED)
       set(${_var}_EXITCODE 1)
@@ -111,13 +110,6 @@ function(CMAKE_CHECK_SOURCE_RUNS _lang _source _var)
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_PASS "Success")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Performing ${_lang_textual} SOURCE FILE Test ${_var} succeeded with the following compile output:\n"
-        "${OUTPUT}\n"
-        "...and run output:\n"
-        "${RUN_OUTPUT}\n"
-        "Return value: ${${_var}}\n"
-        "Source file was:\n${_source}\n")
     else()
       if(CMAKE_CROSSCOMPILING AND "${${_var}_EXITCODE}" MATCHES  "FAILED_TO_RUN")
         set(${_var} "${${_var}_EXITCODE}" PARENT_SCOPE)
@@ -128,14 +120,6 @@ function(CMAKE_CHECK_SOURCE_RUNS _lang _source _var)
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "Failed")
       endif()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Performing ${_lang_textual} SOURCE FILE Test ${_var} failed with the following compile output:\n"
-        "${OUTPUT}\n"
-        "...and run output:\n"
-        "${RUN_OUTPUT}\n"
-        "Return value: ${${_var}_EXITCODE}\n"
-        "Source file was:\n${_source}\n")
-
     endif()
   endif()
 endfunction()

Modules/Internal/FeatureTesting.cmake

@@ -35,27 +35,25 @@ macro(_record_compiler_features lang compile_flags feature_list)
     SOURCE_FROM_VAR "feature_tests.${lang_lc}" _content
     COMPILE_DEFINITIONS "${compile_flags}"
     LINK_LIBRARIES "${compile_flags_for_link}"
-    OUTPUT_VARIABLE _output
     COPY_FILE "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.bin"
     COPY_FILE_ERROR _copy_error
     )
-  if(CMAKE_${lang}_FEATURE_TEST AND NOT _copy_error)
-    set(_result 0)
-  else()
+  if(NOT CMAKE_${lang}_FEATURE_TEST)
+    set(_result 255)
+  elseif(_copy_error)
     set(_result 255)
+    message(WARNING "${_copy_error}")
+  else()
+    set(_result 0)
   endif()
   unset(CMAKE_${lang}_FEATURE_TEST CACHE)
   unset(compile_flags_for_link)
 
   if (_result EQUAL 0)
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "\n\nDetecting ${lang} [${compile_flags}] compiler features compiled with the following output:\n${_output}\n\n")
     if(EXISTS "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.bin")
       file(STRINGS "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.bin"
         features REGEX "${lang}_FEATURE:.*")
       foreach(info ${features})
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-          "    Feature record: ${info}\n")
         string(REPLACE "${lang}_FEATURE:" "" info ${info})
         string(SUBSTRING ${info} 0 1 has_feature)
         if(has_feature)
@@ -64,9 +62,6 @@ macro(_record_compiler_features lang compile_flags feature_list)
         endif()
       endforeach()
     endif()
-  else()
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Detecting ${lang} [${compile_flags}] compiler features failed to compile with the following output:\n${_output}\n${_copy_error}\n\n")
   endif()
 endmacro()
 

Modules/Platform/Android-Determine.cmake

@@ -70,7 +70,7 @@ if(CMAKE_GENERATOR MATCHES "Visual Studio")
       endif()
     endif()
     if(VCXPROJ_INSPECT_RESULT)
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+      message(CONFIGURE_LOG
         "Determining the sysroot for the Android NDK failed.
 The output was:
 ${VCXPROJ_INSPECT_RESULT}
@@ -78,7 +78,7 @@ ${VCXPROJ_INSPECT_OUTPUT}
 
 ")
     else()
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+      message(CONFIGURE_LOG
         "Determining the sysroot for the Android NDK succeeded.
 The output was:
 ${VCXPROJ_INSPECT_RESULT}

Modules/TestBigEndian.cmake

@@ -87,7 +87,6 @@ macro(__TEST_BIG_ENDIAN_LEGACY_IMPL VARIABLE)
 
      try_compile(HAVE_${VARIABLE}
       SOURCE_FROM_VAR "${_test_file}" TEST_ENDIANESS_FILE_CONTENT
-      OUTPUT_VARIABLE OUTPUT
       COPY_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestEndianess.bin" )
 
       if(HAVE_${VARIABLE})
@@ -125,14 +124,8 @@ macro(__TEST_BIG_ENDIAN_LEGACY_IMPL VARIABLE)
           message(CHECK_FAIL "TEST_BIG_ENDIAN found no result!")
           message(SEND_ERROR "TEST_BIG_ENDIAN found no result!")
         endif()
-
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-          "Determining if the system is big endian passed with the following output:\n${OUTPUT}\n${_test_file}:\n${TEST_ENDIANESS_FILE_CONTENT}\n\n")
-
       else()
         message(CHECK_FAIL "failed")
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-          "Determining if the system is big endian failed with the following output:\n${OUTPUT}\n${_test_file}:\n${TEST_ENDIANESS_FILE_CONTENT}\n\n")
         set(${VARIABLE})
       endif()
   endif()

Modules/TestCXXAcceptsFlag.cmake

@@ -27,17 +27,11 @@ macro(CHECK_CXX_ACCEPTS_FLAG FLAGS  VARIABLE)
     try_compile(${VARIABLE}
       SOURCES ${CMAKE_ROOT}/Modules/DummyCXXFile.cxx
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${FLAGS}
-      OUTPUT_VARIABLE OUTPUT)
+      )
     if(${VARIABLE})
       message(CHECK_PASS "yes")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-        "Determining if the CXX compiler accepts the flag ${FLAGS} passed with "
-        "the following output:\n${OUTPUT}\n\n")
     else()
       message(CHECK_FAIL "no")
-      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-        "Determining if the CXX compiler accepts the flag ${FLAGS} failed with "
-        "the following output:\n${OUTPUT}\n\n")
     endif()
   endif()
 endmacro()

Modules/TestForANSIForScope.cmake

@@ -19,21 +19,15 @@ if(NOT DEFINED CMAKE_ANSI_FOR_SCOPE)
   message(CHECK_START "Check for ANSI scope")
   try_compile(CMAKE_ANSI_FOR_SCOPE
     SOURCES ${CMAKE_ROOT}/Modules/TestForAnsiForScope.cxx
-    OUTPUT_VARIABLE OUTPUT)
+    )
   if (CMAKE_ANSI_FOR_SCOPE)
     message(CHECK_PASS "found")
     set (CMAKE_NO_ANSI_FOR_SCOPE 0 CACHE INTERNAL
       "Does the compiler support ansi for scope.")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining if the CXX compiler understands ansi for scopes passed with "
-      "the following output:\n${OUTPUT}\n\n")
   else ()
     message(CHECK_FAIL "not found")
     set (CMAKE_NO_ANSI_FOR_SCOPE 1 CACHE INTERNAL
       "Does the compiler support ansi for scope.")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the CXX compiler understands ansi for scopes failed with "
-      "the following output:\n${OUTPUT}\n\n")
   endif ()
 endif()
 

Modules/TestForSSTREAM.cmake

@@ -18,21 +18,15 @@ if(NOT DEFINED CMAKE_HAS_ANSI_STRING_STREAM)
   message(CHECK_START "Check for sstream")
   try_compile(CMAKE_HAS_ANSI_STRING_STREAM
     SOURCES ${CMAKE_ROOT}/Modules/TestForSSTREAM.cxx
-    OUTPUT_VARIABLE OUTPUT)
+    )
   if (CMAKE_HAS_ANSI_STRING_STREAM)
     message(CHECK_PASS "found")
     set (CMAKE_NO_ANSI_STRING_STREAM 0 CACHE INTERNAL
          "Does the compiler support sstream")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining if the CXX compiler has sstream passed with "
-      "the following output:\n${OUTPUT}\n\n")
   else ()
     message(CHECK_FAIL "not found")
     set (CMAKE_NO_ANSI_STRING_STREAM 1 CACHE INTERNAL
        "Does the compiler support sstream")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the CXX compiler has sstream failed with "
-      "the following output:\n${OUTPUT}\n\n")
   endif ()
 endif()
 

Modules/TestForSTDNamespace.cmake

@@ -18,21 +18,15 @@ if(NOT DEFINED CMAKE_STD_NAMESPACE)
   message(CHECK_START "Check for STD namespace")
   try_compile(CMAKE_STD_NAMESPACE
     SOURCES ${CMAKE_ROOT}/Modules/TestForSTDNamespace.cxx
-    OUTPUT_VARIABLE OUTPUT)
+    )
   if (CMAKE_STD_NAMESPACE)
     message(CHECK_PASS "found")
     set (CMAKE_NO_STD_NAMESPACE 0 CACHE INTERNAL
          "Does the compiler support std::.")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-      "Determining if the CXX compiler has std namespace passed with "
-      "the following output:\n${OUTPUT}\n\n")
   else ()
     message(CHECK_FAIL "not found")
     set (CMAKE_NO_STD_NAMESPACE 1 CACHE INTERNAL
        "Does the compiler support std::.")
-    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining if the CXX compiler has std namespace failed with "
-      "the following output:\n${OUTPUT}\n\n")
   endif ()
 endif()
 

Modules/UsewxWidgets.cmake

@@ -38,18 +38,6 @@ AUTHOR
   Jan Woetzel <jw -at- mip.informatik.uni-kiel.de>
 #]=======================================================================]
 
-# debug message and logging.
-# comment these out for distribution
-if    (NOT LOGFILE )
-  #  set(LOGFILE "${PROJECT_BINARY_DIR}/CMakeOutput.log")
-endif ()
-macro(MSG _MSG)
-  #  file(APPEND ${LOGFILE} "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}):   ${_MSG}\n")
-  #  message(STATUS "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}): ${_MSG}")
-endmacro()
-
-
-MSG("wxWidgets_FOUND=${wxWidgets_FOUND}")
 if   (wxWidgets_FOUND)
   if   (wxWidgets_INCLUDE_DIRS)
     if(wxWidgets_INCLUDE_DIRS_NO_SYSTEM)
@@ -57,45 +45,28 @@ if   (wxWidgets_FOUND)
     else()
       include_directories(SYSTEM ${wxWidgets_INCLUDE_DIRS})
     endif()
-    MSG("wxWidgets_INCLUDE_DIRS=${wxWidgets_INCLUDE_DIRS}")
   endif()
 
   if   (wxWidgets_LIBRARY_DIRS)
     link_directories(${wxWidgets_LIBRARY_DIRS})
-    MSG("wxWidgets_LIBRARY_DIRS=${wxWidgets_LIBRARY_DIRS}")
   endif()
 
   if   (wxWidgets_DEFINITIONS)
     set_property(DIRECTORY APPEND
       PROPERTY COMPILE_DEFINITIONS ${wxWidgets_DEFINITIONS})
-    MSG("wxWidgets_DEFINITIONS=${wxWidgets_DEFINITIONS}")
   endif()
 
   if   (wxWidgets_DEFINITIONS_DEBUG)
     set_property(DIRECTORY APPEND
       PROPERTY COMPILE_DEFINITIONS_DEBUG ${wxWidgets_DEFINITIONS_DEBUG})
-    MSG("wxWidgets_DEFINITIONS_DEBUG=${wxWidgets_DEFINITIONS_DEBUG}")
   endif()
 
   if   (wxWidgets_CXX_FLAGS)
     # Flags are expected to be a string here, not a list.
     string(REPLACE ";" " " wxWidgets_CXX_FLAGS_str "${wxWidgets_CXX_FLAGS}")
     string(APPEND CMAKE_CXX_FLAGS " ${wxWidgets_CXX_FLAGS_str}")
-    MSG("wxWidgets_CXX_FLAGS=${wxWidgets_CXX_FLAGS_str}")
     unset(wxWidgets_CXX_FLAGS_str)
   endif()
-
-  # DEPRECATED JW
-  # just for backward compatibility: add deps to all targets
-  # library projects better use advanced find_package(wxWidgets) directly.
-  #if(wxWidgets_LIBRARIES)
-  #  link_libraries(${wxWidgets_LIBRARIES})
-  #  # BUG: str too long:  MSG("wxWidgets_LIBRARIES=${wxWidgets_LIBRARIES}")
-  #  if(LOGFILE)
-  #    file(APPEND ${LOGFILE} "${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}):   ${wxWidgets_LIBRARIES}\n")
-  #  endif()
-  #endif()
-
 else ()
   message("wxWidgets requested but not found.")
 endif()

Tests/CheckFortran.cmake

@@ -33,6 +33,7 @@ file(WRITE \"\${CMAKE_CURRENT_BINARY_DIR}/result.cmake\"
     RESULT_VARIABLE result
     )
   include(${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/CheckFortran/result.cmake OPTIONAL)
+  # FIXME: Replace with message(CONFIGURE_LOG) when CMake version is high enough.
   if(CMAKE_Fortran_COMPILER AND "${result}" STREQUAL "0")
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
       "${_desc} passed with the following output:\n"

Tests/CheckSwift.cmake

@@ -42,6 +42,7 @@ file(WRITE \"\${CMAKE_CURRENT_BINARY_DIR}/result.cmake\"
 
   include(${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/CheckSwift/result.cmake
     OPTIONAL)
+  # FIXME: Replace with message(CONFIGURE_LOG) when CMake version is high enough.
   if(CMAKE_Swift_COMPILER AND "${result}" STREQUAL "0")
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
       "${_desc} passed with the following output:\n"

Tests/FortranOnly/CMakeLists.txt

@@ -56,8 +56,6 @@ add_custom_target(checksayhello ALL
   )
 add_dependencies(checksayhello sayhello)
 
-set(err_log ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log)
-file(REMOVE "${err_log}")
 include(CheckFortranSourceCompiles)
 unset(HAVE_PRINT CACHE)
 CHECK_Fortran_SOURCE_COMPILES([[
@@ -66,10 +64,24 @@ CHECK_Fortran_SOURCE_COMPILES([[
       END
 ]] HAVE_PRINT)
 if(NOT HAVE_PRINT)
-  if(EXISTS "${err_log}")
-    file(READ "${err_log}" err)
+  set(configure_log "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeConfigureLog.yaml")
+  if(EXISTS "${configure_log}")
+    file(READ "${configure_log}" log_content)
+  else()
+    set(log_content "")
+  endif()
+  if(log_content MATCHES [[(  -
+    kind: "try_compile-v1"(
++    [^
+]+)+
+    checks:
+      - "Performing Test HAVE_PRINT"(
++    [^
+]+)+)]])
+    set(err "${CMAKE_MATCH_1}")
+  else()
+    set(err "")
   endif()
-  string(REPLACE "\n" "\n  " err "  ${err}")
   message(SEND_ERROR "CHECK_Fortran_SOURCE_COMPILES for HAVE_PRINT failed:\n"
     "${err}")
 endif()

Tests/RunCMake/CTestCommandExpandLists/multipleExpandOptions-stdout.txt

@@ -1,2 +1 @@
 -- Configuring incomplete, errors occurred!
-See also ".*/Tests/RunCMake/CTestCommandExpandLists/multipleExpandOptions-build/CMakeFiles/CMakeOutput\.log".

Tests/RunCMake/Configure/ErrorLogs-stderr.txt

@@ -1,4 +1,4 @@
-CMake Error at ErrorLogs.cmake:3 \(message\):
+CMake Error at ErrorLogs.cmake:[0-9]+ \(message\):
   Some error!
 Call Stack \(most recent call first\):
-  CMakeLists.txt:3 \(include\)
+  CMakeLists.txt:[0-9]+ \(include\)

Tests/RunCMake/Configure/ErrorLogs.cmake

@@ -1,3 +1,5 @@
+file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+  "Some detailed output information!\n")
 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
   "Some detailed error information!\n")
 message(SEND_ERROR "Some error!")

Tests/RunCMake/try_compile/CMP0128-common.cmake

@@ -1,10 +1,6 @@
 cmake_policy(SET CMP0067 NEW)
 enable_language(CXX)
 
-# Isolate the one try_compile below in the error log.
-set(CMakeError_log "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log")
-file(REMOVE "${CMakeError_log}")
-
 # Add our own -std= flag to the try_compile check.
 set(CMAKE_REQUIRED_FLAGS -std=c++11)
 
@@ -24,8 +20,21 @@ int main()
 }
 " SRC_COMPILED)
 if(NOT SRC_COMPILED)
-  if(EXISTS "${CMakeError_log}")
-    file(READ "${CMakeError_log}" err_log)
+  message("Check failed to compile:")
+  set(configure_log "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeConfigureLog.yaml")
+  if(EXISTS "${configure_log}")
+    file(READ "${configure_log}" log_content)
+  else()
+    set(log_content "")
+  endif()
+  if(log_content MATCHES [[(  -
+    kind: "try_compile-v1"(
++    [^
+]+)+
+    checks:
+      - "Performing Test SRC_COMPILED"(
++    [^
+]+)+)]])
+    message("${configure_log} contains:\n${CMAKE_MATCH_1}")
   endif()
-  message("${err_log}")
 endif()

Tests/RunCMake/try_compile/ConfigureLog-config.txt

@@ -1,6 +1,13 @@
 ^
 ---
-events:
+events:(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)+
   -
     kind: "try_compile-v1"
     backtrace:
@@ -17,7 +24,14 @@ events:
       variable: "CMAKE_C_ABI_COMPILED"
       cached: true
       stdout: \|.*
-      exitCode: 0
+      exitCode: 0(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)*
   -
     kind: "try_compile-v1"
     backtrace:

Tests/RunCMake/try_compile/Inspect-config.txt

@@ -1,6 +1,13 @@
 ^
 ---
-events:
+events:(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)+
   -
     kind: "try_compile-v1"
     backtrace:
@@ -17,7 +24,14 @@ events:
       variable: "CMAKE_C_ABI_COMPILED"
       cached: true
       stdout: \|.*
-      exitCode: 0
+      exitCode: 0(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)+
   -
     kind: "try_compile-v1"
     backtrace:
@@ -34,5 +48,12 @@ events:
       variable: "CMAKE_CXX_ABI_COMPILED"
       cached: true
       stdout: \|.*
-      exitCode: 0
+      exitCode: 0(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)*
 \.\.\.$

Tests/RunCMake/try_compile/SourceFromBadName-config.txt

@@ -1 +1,11 @@
-^$
+^
+---
+events:(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)+
+\.\.\.$

Tests/RunCMake/try_run/ConfigureLog-config.txt

@@ -1,6 +1,13 @@
 ^
 ---
-events:
+events:(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)+
   -
     kind: "try_compile-v1"
     backtrace:
@@ -16,7 +23,14 @@ events:
       variable: "CMAKE_C_ABI_COMPILED"
       cached: true
       stdout: \|.*
-      exitCode: 0
+      exitCode: 0(
+  -
+    kind: "message-v1"
+    backtrace:(
+      - "[^"]+")+
+    message: \|(
++      [^
+]*)*)*
   -
     kind: "try_run-v1"
     backtrace:

Tests/SystemInformation/DumpInformation.cxx

@@ -63,13 +63,9 @@ int main(int, char*[])
     DumpInformation_BINARY_DIR "/OtherProperties.txt",
     DumpInformation_BINARY_DIR "/../../Source/cmConfigure.h",
     DumpInformation_BINARY_DIR "/../../CMakeCache.txt",
-    DumpInformation_BINARY_DIR "/../../CMakeFiles/CMakeOutput.log",
-    DumpInformation_BINARY_DIR "/../../CMakeFiles/CMakeError.log",
     DumpInformation_BINARY_DIR "/../../Bootstrap.cmk/cmake_bootstrap.log",
     DumpInformation_BINARY_DIR "/../../Source/cmsys/Configure.hxx",
     DumpInformation_BINARY_DIR "/../../Source/cmsys/Configure.h",
-    DumpInformation_BINARY_DIR "/CMakeFiles/CMakeOutput.log",
-    DumpInformation_BINARY_DIR "/CMakeFiles/CMakeError.log",
     0
   };