Merge topic 'use-try_compile-source-from'

41f7b1169a Modules: Use new SOURCES_FROM_* try_compile (2/2)
db76876db5 Modules: Use new SOURCES_FROM_* try_compile (1/2)

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

Modules/CMakeTestCCompiler.cmake

@@ -38,7 +38,7 @@ endif()
 if(NOT CMAKE_C_COMPILER_WORKS)
   PrintTestCompilerStatus("C")
   __TestCompiler_setTryCompileTargetType()
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler.c
+  string(CONCAT __TestCompiler_testCCompilerSource
     "#ifdef __cplusplus\n"
     "# error \"The CMAKE_C_COMPILER is set to a C++ compiler\"\n"
     "#endif\n"
@@ -54,8 +54,9 @@ if(NOT CMAKE_C_COMPILER_WORKS)
   unset(CMAKE_C_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_C_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler.c
+    SOURCE_FROM_VAR testCCompiler.c __TestCompiler_testCCompilerSource
     OUTPUT_VARIABLE __CMAKE_C_COMPILER_OUTPUT)
+  unset(__TestCompiler_testCCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_C_COMPILER_WORKS ${CMAKE_C_COMPILER_WORKS})
   unset(CMAKE_C_COMPILER_WORKS CACHE)

Modules/CMakeTestCSharpCompiler.cmake

@@ -12,8 +12,6 @@ include(CMakeTestCompilerCommon)
 
 unset(CMAKE_CSharp_COMPILER_WORKS CACHE)
 
-set(test_compile_file "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCSharpCompiler.cs")
-
 # This file is used by EnableLanguage in cmGlobalGenerator to
 # determine that the selected C# compiler can actually compile
 # and link the most basic of programs. If not, a fatal error
@@ -23,20 +21,21 @@ if(NOT CMAKE_CSharp_COMPILER_WORKS)
   # Don't call PrintTestCompilerStatus() because the "C#" we want to pass
   # as the LANG doesn't match with the variable name "CMAKE_CSharp_COMPILER"
   message(CHECK_START "Check for working C# compiler: ${CMAKE_CSharp_COMPILER}")
-  file(WRITE "${test_compile_file}"
-    "namespace Test {"
-    "   public class CSharp {"
-    "       static void Main(string[] args) {}"
-    "   }"
-    "}"
+  string(CONCAT __TestCompiler_testCSharpCompilerSource
+    "namespace Test {\n"
+    "   public class CSharp {\n"
+    "       static void Main(string[] args) {}\n"
+    "   }\n"
+    "}\n"
     )
   # Clear result from normal variable.
   unset(CMAKE_CSharp_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_CSharp_COMPILER_WORKS
-    SOURCES "${test_compile_file}"
+    SOURCE_FROM_VAR testCSharpCompiler.cs __TestCompiler_testCSharpCompilerSource
     OUTPUT_VARIABLE __CMAKE_CSharp_COMPILER_OUTPUT
     )
+  unset(__TestCompiler_testCSharpCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_CSharp_COMPILER_WORKS ${CMAKE_CSharp_COMPILER_WORKS})
   unset(CMAKE_CSharp_COMPILER_WORKS CACHE)

Modules/CMakeTestCUDACompiler.cmake

@@ -76,7 +76,7 @@ endif()
 # any makefiles or projects.
 if(NOT CMAKE_CUDA_COMPILER_WORKS)
   PrintTestCompilerStatus("CUDA")
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.cu
+  string(CONCAT __TestCompiler_testCudaCompilerSource
     "#ifndef __CUDACC__\n"
     "# error \"The CMAKE_CUDA_COMPILER is set to an invalid CUDA compiler\"\n"
     "#endif\n"
@@ -87,8 +87,9 @@ if(NOT CMAKE_CUDA_COMPILER_WORKS)
 
   # Puts test result in cache variable.
   try_compile(CMAKE_CUDA_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.cu
+    SOURCE_FROM_VAR main.cu __TestCompiler_testCudaCompilerSource
     OUTPUT_VARIABLE __CMAKE_CUDA_COMPILER_OUTPUT)
+  unset(__TestCompiler_testCudaCompilerSource)
 
   # Move result from cache to normal variable.
   set(CMAKE_CUDA_COMPILER_WORKS ${CMAKE_CUDA_COMPILER_WORKS})

Modules/CMakeTestCXXCompiler.cmake

@@ -38,7 +38,7 @@ endif()
 if(NOT CMAKE_CXX_COMPILER_WORKS)
   PrintTestCompilerStatus("CXX")
   __TestCompiler_setTryCompileTargetType()
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCXXCompiler.cxx
+  string(CONCAT __TestCompiler_testCXXCompilerSource
     "#ifndef __cplusplus\n"
     "# error \"The CMAKE_CXX_COMPILER is set to a C compiler\"\n"
     "#endif\n"
@@ -47,8 +47,9 @@ if(NOT CMAKE_CXX_COMPILER_WORKS)
   unset(CMAKE_CXX_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_CXX_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCXXCompiler.cxx
+    SOURCE_FROM_VAR testCXXCompiler.cxx __TestCompiler_testCXXCompilerSource
     OUTPUT_VARIABLE __CMAKE_CXX_COMPILER_OUTPUT)
+  unset(__TestCompiler_testCXXCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_CXX_COMPILER_WORKS ${CMAKE_CXX_COMPILER_WORKS})
   unset(CMAKE_CXX_COMPILER_WORKS CACHE)

Modules/CMakeTestFortranCompiler.cmake

@@ -38,7 +38,7 @@ endif()
 # any makefiles or projects.
 if(NOT CMAKE_Fortran_COMPILER_WORKS)
   PrintTestCompilerStatus("Fortran")
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler.f "
+  set(__TestCompiler_testFortranCompilerSource "
         PROGRAM TESTFortran
         PRINT *, 'Hello'
         END
@@ -47,8 +47,9 @@ if(NOT CMAKE_Fortran_COMPILER_WORKS)
   unset(CMAKE_Fortran_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_Fortran_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler.f
+    SOURCE_FROM_VAR testFortranCompiler.f __TestCompiler_testFortranCompilerSource
     OUTPUT_VARIABLE OUTPUT)
+  unset(__TestCompiler_testFortranCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_Fortran_COMPILER_WORKS ${CMAKE_Fortran_COMPILER_WORKS})
   unset(CMAKE_Fortran_COMPILER_WORKS CACHE)
@@ -72,14 +73,15 @@ endif()
 # Test for Fortran 90 support by using an f90-specific construct.
 if(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F90)
   message(CHECK_START "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90")
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompilerF90.f90 "
+  set(__TestCompiler_testFortranCompilerSource "
     PROGRAM TESTFortran90
     integer stop ; stop = 1 ; do while ( stop .eq. 0 ) ; end do
     END PROGRAM TESTFortran90
 ")
   try_compile(CMAKE_Fortran_COMPILER_SUPPORTS_F90
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompilerF90.f90
+    SOURCE_FROM_VAR testFortranCompilerF90.f90 __TestCompiler_testFortranCompilerF90Source
     OUTPUT_VARIABLE OUTPUT)
+  unset(__TestCompiler_testFortranCompilerF90Source)
   if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
     message(CHECK_PASS "yes")
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log

Modules/CMakeTestHIPCompiler.cmake

@@ -41,7 +41,7 @@ endif()
 if(NOT CMAKE_HIP_COMPILER_WORKS)
   PrintTestCompilerStatus("HIP")
   __TestCompiler_setTryCompileTargetType()
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testHIPCompiler.hip
+  string(CONCAT __TestCompiler_testHIPCompilerSource
     "#ifndef __HIP__\n"
     "# error \"The CMAKE_HIP_COMPILER is set to a C/CXX compiler\"\n"
     "#endif\n"
@@ -50,8 +50,9 @@ if(NOT CMAKE_HIP_COMPILER_WORKS)
   unset(CMAKE_HIP_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_HIP_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testHIPCompiler.hip
+    SOURCE_FROM_VAR testHIPCompiler.hip __TestCompiler_testHIPCompilerSource
     OUTPUT_VARIABLE __CMAKE_HIP_COMPILER_OUTPUT)
+  unset(__TestCompiler_testHIPCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_HIP_COMPILER_WORKS ${CMAKE_HIP_COMPILER_WORKS})
   unset(CMAKE_HIP_COMPILER_WORKS CACHE)

Modules/CMakeTestOBJCCompiler.cmake

@@ -38,7 +38,7 @@ endif()
 if(NOT CMAKE_OBJC_COMPILER_WORKS)
   PrintTestCompilerStatus("OBJC")
   __TestCompiler_setTryCompileTargetType()
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testOBJCCompiler.m
+  string(CONCAT __TestCompiler_testObjCCompilerSource
     "#ifdef __cplusplus\n"
     "# error \"The CMAKE_OBJC_COMPILER is set to a C++ compiler\"\n"
     "#endif\n"
@@ -51,8 +51,9 @@ if(NOT CMAKE_OBJC_COMPILER_WORKS)
   unset(CMAKE_OBJC_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_OBJC_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testOBJCCompiler.m
+    SOURCE_FROM_VAR testObjCCompiler.m __TestCompiler_testObjCCompilerSource
     OUTPUT_VARIABLE __CMAKE_OBJC_COMPILER_OUTPUT)
+  unset(__TestCompiler_testObjCCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_OBJC_COMPILER_WORKS ${CMAKE_OBJC_COMPILER_WORKS})
   unset(CMAKE_OBJC_COMPILER_WORKS CACHE)

Modules/CMakeTestOBJCXXCompiler.cmake

@@ -38,7 +38,7 @@ endif()
 if(NOT CMAKE_OBJCXX_COMPILER_WORKS)
   PrintTestCompilerStatus("OBJCXX")
   __TestCompiler_setTryCompileTargetType()
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testOBJCXXCompiler.mm
+  string(CONCAT __TestCompiler_testObjCXXCompilerSource
     "#ifndef __cplusplus\n"
     "# error \"The CMAKE_OBJCXX_COMPILER is set to a C compiler\"\n"
     "#endif\n"
@@ -50,8 +50,9 @@ if(NOT CMAKE_OBJCXX_COMPILER_WORKS)
   unset(CMAKE_OBJCXX_COMPILER_WORKS)
   # Puts test result in cache variable.
   try_compile(CMAKE_OBJCXX_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testOBJCXXCompiler.mm
+    SOURCE_FROM_VAR testObjCXXCompiler.mm __TestCompiler_testObjCXXCompilerSource
     OUTPUT_VARIABLE __CMAKE_OBJCXX_COMPILER_OUTPUT)
+  unset(__TestCompiler_testObjCXXCompilerSource)
   # Move result from cache to normal variable.
   set(CMAKE_OBJCXX_COMPILER_WORKS ${CMAKE_OBJCXX_COMPILER_WORKS})
   unset(CMAKE_OBJCXX_COMPILER_WORKS CACHE)

Modules/CMakeTestSwiftCompiler.cmake

@@ -21,13 +21,12 @@ unset(CMAKE_Swift_COMPILER_WORKS CACHE)
 # any makefiles or projects.
 if(NOT CMAKE_Swift_COMPILER_WORKS)
   PrintTestCompilerStatus("Swift")
-  file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.swift
-    "print(\"CMake\")\n")
   # Clear result from normal variable.
   unset(CMAKE_Swift_COMPILER_WORKS)
   # Puts test result in cache variable.
+  set(__CMAKE_Swift_TEST_SOURCE "print(\"CMake\")\n")
   try_compile(CMAKE_Swift_COMPILER_WORKS
-    SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.swift
+    SOURCE_FROM_VAR main.swift __CMAKE_Swift_TEST_SOURCE
     OUTPUT_VARIABLE __CMAKE_Swift_COMPILER_OUTPUT)
   # Move result from cache to normal variable.
   set(CMAKE_Swift_COMPILER_WORKS ${CMAKE_Swift_COMPILER_WORKS})
@@ -64,4 +63,5 @@ else()
   include(${CMAKE_PLATFORM_INFO_DIR}/CMakeSwiftCompiler.cmake)
 endif()
 
+unset(__CMAKE_Swift_TEST_SOURCE)
 unset(__CMAKE_Swift_COMPILER_OUTPUT)

Modules/CheckCXXSymbolExists.cmake

@@ -74,5 +74,5 @@ include_guard(GLOBAL)
 include(CheckSymbolExists)
 
 macro(CHECK_CXX_SYMBOL_EXISTS SYMBOL FILES VARIABLE)
-  __CHECK_SYMBOL_EXISTS_IMPL("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.cxx" "${SYMBOL}" "${FILES}" "${VARIABLE}" )
+  __CHECK_SYMBOL_EXISTS_IMPL(CheckSymbolExists.cxx "${SYMBOL}" "${FILES}" "${VARIABLE}" )
 endmacro()

Modules/CheckFortranFunctionExists.cmake

@@ -58,8 +58,7 @@ macro(CHECK_FORTRAN_FUNCTION_EXISTS FUNCTION VARIABLE)
     else()
       set(CHECK_FUNCTION_EXISTS_ADD_LIBRARIES)
     endif()
-    file(WRITE
-    ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler.f
+    set(__CheckFunction_testFortranCompilerSource
     "
       program TESTFortran
       external ${FUNCTION}
@@ -68,11 +67,12 @@ macro(CHECK_FORTRAN_FUNCTION_EXISTS FUNCTION VARIABLE)
     "
     )
     try_compile(${VARIABLE}
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler.f
+      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")

Modules/CheckFunctionExists.cmake

@@ -81,16 +81,15 @@ macro(CHECK_FUNCTION_EXISTS FUNCTION VARIABLE)
     endif()
 
     if(CMAKE_C_COMPILER_LOADED)
-      set(_cfe_source ${CMAKE_ROOT}/Modules/CheckFunctionExists.c)
+      set(_cfe_source CheckFunctionExists.c)
     elseif(CMAKE_CXX_COMPILER_LOADED)
-      set(_cfe_source ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckFunctionExists/CheckFunctionExists.cxx)
-      configure_file(${CMAKE_ROOT}/Modules/CheckFunctionExists.c "${_cfe_source}" COPYONLY)
+      set(_cfe_source CheckFunctionExists.cxx)
     else()
       message(FATAL_ERROR "CHECK_FUNCTION_EXISTS needs either C or CXX language enabled")
     endif()
 
     try_compile(${VARIABLE}
-      SOURCES ${_cfe_source}
+      SOURCE_FROM_FILE "${_cfe_source}" "${CMAKE_ROOT}/Modules/CheckFunctionExists.c"
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${CHECK_FUNCTION_EXISTS_ADD_LINK_OPTIONS}
       ${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES}

Modules/CheckIncludeFile.cmake

@@ -54,8 +54,8 @@ macro(CHECK_INCLUDE_FILE INCLUDE VARIABLE)
     endif()
     set(MACRO_CHECK_INCLUDE_FILE_FLAGS ${CMAKE_REQUIRED_FLAGS})
     set(CHECK_INCLUDE_FILE_VAR ${INCLUDE})
-    configure_file(${CMAKE_ROOT}/Modules/CheckIncludeFile.c.in
-      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.c)
+    file(READ ${CMAKE_ROOT}/Modules/CheckIncludeFile.c.in _CIF_SOURCE_CONTENT)
+    string(CONFIGURE "${_CIF_SOURCE_CONTENT}" _CIF_SOURCE_CONTENT)
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_START "Looking for ${INCLUDE}")
     endif()
@@ -93,7 +93,7 @@ macro(CHECK_INCLUDE_FILE INCLUDE VARIABLE)
     endif()
 
     try_compile(${VARIABLE}
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.c
+      SOURCE_FROM_VAR CheckIncludeFile.c _CIF_SOURCE_CONTENT
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${_CIF_LINK_OPTIONS}
       ${_CIF_LINK_LIBRARIES}

Modules/CheckIncludeFileCXX.cmake

@@ -53,8 +53,8 @@ macro(CHECK_INCLUDE_FILE_CXX INCLUDE VARIABLE)
     endif()
     set(MACRO_CHECK_INCLUDE_FILE_FLAGS ${CMAKE_REQUIRED_FLAGS})
     set(CHECK_INCLUDE_FILE_VAR ${INCLUDE})
-    configure_file(${CMAKE_ROOT}/Modules/CheckIncludeFile.cxx.in
-      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.cxx)
+    file(READ ${CMAKE_ROOT}/Modules/CheckIncludeFile.cxx.in _CIF_SOURCE_CONTENT)
+    string(CONFIGURE "${_CIF_SOURCE_CONTENT}" _CIF_SOURCE_CONTENT)
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_START "Looking for C++ include ${INCLUDE}")
     endif()
@@ -92,7 +92,7 @@ macro(CHECK_INCLUDE_FILE_CXX INCLUDE VARIABLE)
     endif()
 
     try_compile(${VARIABLE}
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.cxx
+      SOURCE_FROM_VAR CheckIncludeFile.cxx _CIF_SOURCE_CONTENT
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${_CIF_LINK_OPTIONS}
       ${_CIF_LINK_LIBRARIES}

Modules/CheckIncludeFiles.cmake

@@ -52,7 +52,7 @@ include_guard(GLOBAL)
 
 macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
   if(NOT DEFINED "${VARIABLE}")
-    set(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n")
+    set(_src_content "/* */\n")
 
     if("x${ARGN}" STREQUAL "x")
        if(CMAKE_C_COMPILER_LOADED)
@@ -71,9 +71,9 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
     endif()
 
     if(_lang STREQUAL "C")
-      set(src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckIncludeFiles/${VARIABLE}.c)
+      set(src ${VARIABLE}.c)
     elseif(_lang STREQUAL "CXX")
-      set(src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckIncludeFiles/${VARIABLE}.cpp)
+      set(src ${VARIABLE}.cpp)
     else()
       message(FATAL_ERROR "Unknown language:\n  ${_lang}\nSupported languages: C, CXX.\n")
     endif()
@@ -86,13 +86,11 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
     set(CHECK_INCLUDE_FILES_CONTENT "/* */\n")
     set(MACRO_CHECK_INCLUDE_FILES_FLAGS ${CMAKE_REQUIRED_FLAGS})
     foreach(FILE ${INCLUDE})
-      string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT
+      string(APPEND _src_content
         "#include <${FILE}>\n")
     endforeach()
-    string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT
+    string(APPEND _src_content
       "\n\nint main(void){return 0;}\n")
-    configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
-      "${src}" @ONLY)
 
     set(_INCLUDE ${INCLUDE}) # remove empty elements
     if("${_INCLUDE}" MATCHES "^([^;]+);.+;([^;]+)$")
@@ -136,7 +134,7 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
       message(CHECK_START "Looking for ${_description}")
     endif()
     try_compile(${VARIABLE}
-      SOURCES ${src}
+      SOURCE_FROM_VAR "${src}" _src_content
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${_CIF_LINK_OPTIONS}
       ${_CIF_LINK_LIBRARIES}
@@ -163,7 +161,7 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "Determining if files ${INCLUDE} "
         "exist failed with the following output:\n"
-        "${OUTPUT}\nSource:\n${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
+        "${OUTPUT}\nSource:\n${_src_content}\n")
     endif()
   endif()
 endmacro()

Modules/CheckLibraryExists.cmake

@@ -61,16 +61,15 @@ macro(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE)
     endif()
 
     if(CMAKE_C_COMPILER_LOADED)
-      set(_cle_source ${CMAKE_ROOT}/Modules/CheckFunctionExists.c)
+      set(_cle_source CheckFunctionExists.c)
     elseif(CMAKE_CXX_COMPILER_LOADED)
-      set(_cle_source ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckLibraryExists/CheckFunctionExists.cxx)
-      configure_file(${CMAKE_ROOT}/Modules/CheckFunctionExists.c "${_cle_source}" COPYONLY)
+      set(_cle_source CheckFunctionExists.cxx)
     else()
       message(FATAL_ERROR "CHECK_FUNCTION_EXISTS needs either C or CXX language enabled")
     endif()
 
     try_compile(${VARIABLE}
-      SOURCES ${_cle_source}
+      SOURCE_FROM_FILE "${_cle_source}" "${CMAKE_ROOT}/Modules/CheckFunctionExists.c"
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${CHECK_LIBRARY_EXISTS_LINK_OPTIONS}
       LINK_LIBRARIES ${CHECK_LIBRARY_EXISTS_LIBRARIES}

Modules/CheckPrototypeDefinition.cmake

@@ -94,13 +94,11 @@ function(check_prototype_definition _FUNCTION _PROTOTYPE _RETURN _HEADER _VARIAB
     set(CHECK_PROTOTYPE_DEFINITION_PROTO ${_PROTOTYPE})
     set(CHECK_PROTOTYPE_DEFINITION_RETURN ${_RETURN})
 
-    configure_file("${__check_proto_def_dir}/CheckPrototypeDefinition.c.in"
-      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c" @ONLY)
-
-    file(READ ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c _SOURCE)
+    file(READ ${__check_proto_def_dir}/CheckPrototypeDefinition.c.in _SOURCE)
+    string(CONFIGURE "${_SOURCE}" _SOURCE @ONLY)
 
     try_compile(${_VARIABLE}
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckPrototypeDefinition.c
+      SOURCE_FROM_VAR CheckPrototypeDefinition.c _SOURCE
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${CHECK_PROTOTYPE_DEFINITION_LINK_OPTIONS}
       ${CHECK_PROTOTYPE_DEFINITION_LIBS}

Modules/CheckSymbolExists.cmake

@@ -68,11 +68,11 @@ cmake_policy(SET CMP0054 NEW) # if() quoted variables not dereferenced
 macro(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE)
   if(CMAKE_C_COMPILER_LOADED)
     __CHECK_SYMBOL_EXISTS_FILTER_FLAGS(C)
-    __CHECK_SYMBOL_EXISTS_IMPL("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c" "${SYMBOL}" "${FILES}" "${VARIABLE}" )
+    __CHECK_SYMBOL_EXISTS_IMPL(CheckSymbolExists.c "${SYMBOL}" "${FILES}" "${VARIABLE}" )
     __CHECK_SYMBOL_EXISTS_RESTORE_FLAGS(C)
   elseif(CMAKE_CXX_COMPILER_LOADED)
     __CHECK_SYMBOL_EXISTS_FILTER_FLAGS(CXX)
-    __CHECK_SYMBOL_EXISTS_IMPL("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.cxx" "${SYMBOL}" "${FILES}" "${VARIABLE}" )
+    __CHECK_SYMBOL_EXISTS_IMPL(CheckSymbolExists.cxx "${SYMBOL}" "${FILES}" "${VARIABLE}" )
     __CHECK_SYMBOL_EXISTS_RESTORE_FLAGS(CXX)
   else()
     message(FATAL_ERROR "CHECK_SYMBOL_EXISTS needs either C or CXX language enabled")
@@ -92,7 +92,7 @@ endmacro()
 
 macro(__CHECK_SYMBOL_EXISTS_IMPL SOURCEFILE SYMBOL FILES VARIABLE)
   if(NOT DEFINED "${VARIABLE}" OR "x${${VARIABLE}}" STREQUAL "x${VARIABLE}")
-    set(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n")
+    set(_CSE_SOURCE "/* */\n")
     set(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS})
     if(CMAKE_REQUIRED_LINK_OPTIONS)
       set(CHECK_SYMBOL_EXISTS_LINK_OPTIONS
@@ -113,17 +113,17 @@ macro(__CHECK_SYMBOL_EXISTS_IMPL SOURCEFILE SYMBOL FILES VARIABLE)
       set(CMAKE_SYMBOL_EXISTS_INCLUDES)
     endif()
     foreach(FILE ${FILES})
-      string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT
+      string(APPEND _CSE_SOURCE
         "#include <${FILE}>\n")
     endforeach()
-    string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT "
+    string(APPEND _CSE_SOURCE "
 int main(int argc, char** argv)
 {
   (void)argv;")
     set(_CSE_CHECK_NON_MACRO "return ((int*)(&${SYMBOL}))[argc];")
     if("${SYMBOL}" MATCHES "^[a-zA-Z_][a-zA-Z0-9_]*$")
       # The SYMBOL has a legal macro name.  Test whether it exists as a macro.
-      string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT "
+      string(APPEND _CSE_SOURCE "
 #ifndef ${SYMBOL}
   ${_CSE_CHECK_NON_MACRO}
 #else
@@ -132,21 +132,18 @@ int main(int argc, char** argv)
 #endif")
     else()
       # The SYMBOL cannot be a macro (e.g., a template function).
-      string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT "
+      string(APPEND _CSE_SOURCE "
   ${_CSE_CHECK_NON_MACRO}")
     endif()
-    string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT "
+    string(APPEND _CSE_SOURCE "
 }")
     unset(_CSE_CHECK_NON_MACRO)
 
-    configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
-      "${SOURCEFILE}" @ONLY)
-
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_START "Looking for ${SYMBOL}")
     endif()
     try_compile(${VARIABLE}
-      SOURCES "${SOURCEFILE}"
+      SOURCE_FROM_VAR "${SOURCEFILE}" _CSE_SOURCE
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
       ${CHECK_SYMBOL_EXISTS_LINK_OPTIONS}
       ${CHECK_SYMBOL_EXISTS_LIBS}
@@ -163,7 +160,7 @@ int main(int argc, char** argv)
         "Determining if the ${SYMBOL} "
         "exist passed with the following output:\n"
         "${OUTPUT}\nFile ${SOURCEFILE}:\n"
-        "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
+        "${_CSE_SOURCE}\n")
     else()
       if(NOT CMAKE_REQUIRED_QUIET)
         message(CHECK_FAIL "not found")
@@ -173,9 +170,9 @@ int main(int argc, char** argv)
         "Determining if the ${SYMBOL} "
         "exist failed with the following output:\n"
         "${OUTPUT}\nFile ${SOURCEFILE}:\n"
-        "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
+        "${_CSE_SOURCE}\n")
     endif()
-    unset(CMAKE_CONFIGURABLE_FILE_CONTENT)
+    unset(_CSE_SOURCE)
   endif()
 endmacro()
 

Modules/CheckTypeSize.cmake

@@ -104,9 +104,9 @@ function(__check_type_size_impl type var map builtin language)
 
   # Perform language check
   if(language STREQUAL "C")
-    set(src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize/${var}.c)
+    set(src ${var}.c)
   elseif(language STREQUAL "CXX")
-    set(src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize/${var}.cpp)
+    set(src ${var}.cpp)
   else()
     message(FATAL_ERROR "Unknown language:\n  ${language}\nSupported languages: C, CXX.\n")
   endif()
@@ -142,8 +142,9 @@ function(__check_type_size_impl type var map builtin language)
 
   # Perform the check.
   set(bin ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize/${var}.bin)
-  configure_file(${__check_type_size_dir}/CheckTypeSize.c.in ${src} @ONLY)
-  try_compile(HAVE_${var} SOURCES ${src}
+  file(READ ${__check_type_size_dir}/CheckTypeSize.c.in src_content)
+  string(CONFIGURE "${src_content}" src_content @ONLY)
+  try_compile(HAVE_${var} SOURCE_FROM_VAR "${src}" src_content
     COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
     LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS}
     LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES}
@@ -209,9 +210,8 @@ function(__check_type_size_impl type var map builtin language)
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_FAIL "failed")
     endif()
-    file(READ ${src} content)
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-      "Determining size of ${type} failed with the following output:\n${output}\n${src}:\n${content}\n\n")
+      "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/FindMFC.cmake

@@ -29,21 +29,19 @@ endif()
 if(MFC_ATTEMPT_TRY_COMPILE)
   if(NOT DEFINED MFC_HAVE_MFC)
     set(CHECK_INCLUDE_FILE_VAR "afxwin.h")
-    configure_file(${CMAKE_ROOT}/Modules/CheckIncludeFile.cxx.in
-      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.cxx)
+    file(READ ${CMAKE_ROOT}/Modules/CheckIncludeFile.cxx.in _CIF_SOURCE_CONTENT)
+    string(CONFIGURE "${_CIF_SOURCE_CONTENT}" _CIF_SOURCE_CONTENT)
     message(CHECK_START "Looking for MFC")
     # Try both shared and static as the root project may have set the /MT flag
     try_compile(MFC_HAVE_MFC
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.cxx
+      SOURCE_FROM_VAR CheckIncludeFile.cxx _CIF_SOURCE_CONTENT
       CMAKE_FLAGS
       -DCMAKE_MFC_FLAG:STRING=2
       -DCOMPILE_DEFINITIONS:STRING=-D_AFXDLL
       OUTPUT_VARIABLE OUTPUT)
     if(NOT MFC_HAVE_MFC)
-      configure_file(${CMAKE_ROOT}/Modules/CheckIncludeFile.cxx.in
-        ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.cxx)
       try_compile(MFC_HAVE_MFC
-        SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFile.cxx
+        SOURCE_FROM_VAR CheckIncludeFile.cxx _CIF_SOURCE_CONTENT
         CMAKE_FLAGS
         -DCMAKE_MFC_FLAG:STRING=1
         OUTPUT_VARIABLE OUTPUT)

Modules/FindMPI.cmake

@@ -1246,20 +1246,22 @@ function(_MPI_try_staged_settings LANG MPI_TEST_FILE_NAME MODE RUN_BINARY SUPPRE
     else() # F77 header
       set(MPI_Fortran_INCLUDE_LINE "implicit none\n      include 'mpif.h'")
     endif()
-    configure_file("${SRC_DIR}/${MPI_TEST_FILE_NAME}.f90.in" "${WORK_DIR}/${MPI_TEST_FILE_NAME}.f90" @ONLY)
-    set(MPI_TEST_SOURCE_FILE "${WORK_DIR}/${MPI_TEST_FILE_NAME}.f90")
+    file(READ "${SRC_DIR}/${MPI_TEST_FILE_NAME}.f90.in" MPI_TEST_SOURCE_CONTENT)
+    string(CONFIGURE "${MPI_TEST_SOURCE_CONTENT}" MPI_TEST_SOURCE_CONTENT)
+    set(MPI_TEST_SOURCE_FILE "${MPI_TEST_FILE_NAME}.f90")
   elseif(LANG STREQUAL "CXX")
-    configure_file("${SRC_DIR}/${MPI_TEST_FILE_NAME}.c" "${WORK_DIR}/${MPI_TEST_FILE_NAME}.cpp" COPYONLY)
-    set(MPI_TEST_SOURCE_FILE "${WORK_DIR}/${MPI_TEST_FILE_NAME}.cpp")
+    file(READ "${SRC_DIR}/${MPI_TEST_FILE_NAME}.c" MPI_TEST_SOURCE_CONTENT)
+    set(MPI_TEST_SOURCE_FILE "${MPI_TEST_FILE_NAME}.cpp")
     if(MODE STREQUAL "TEST_MPICXX")
       set(MPI_TEST_COMPILE_DEFINITIONS TEST_MPI_MPICXX)
     endif()
   else() # C
-    set(MPI_TEST_SOURCE_FILE "${SRC_DIR}/${MPI_TEST_FILE_NAME}.c")
+    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(RUN_BINARY)
     try_run(MPI_RUN_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE} MPI_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}
-      SOURCES "${MPI_TEST_SOURCE_FILE}"
+      SOURCE_FROM_VAR "${MPI_TEST_SOURCE_FILE}" MPI_TEST_SOURCE_CONTENT
       COMPILE_DEFINITIONS ${MPI_TEST_COMPILE_DEFINITIONS}
       LINK_LIBRARIES MPI::MPI_${LANG}
       RUN_OUTPUT_VARIABLE MPI_RUN_OUTPUT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}
@@ -1267,7 +1269,7 @@ function(_MPI_try_staged_settings LANG MPI_TEST_FILE_NAME MODE RUN_BINARY SUPPRE
     set(MPI_RUN_OUTPUT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE} "${MPI_RUN_OUTPUT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}}" PARENT_SCOPE)
   else()
     try_compile(MPI_RESULT_${LANG}_${MPI_TEST_FILE_NAME}_${MODE}
-      SOURCES "${MPI_TEST_SOURCE_FILE}"
+      SOURCE_FROM_VAR "${MPI_TEST_SOURCE_FILE}" MPI_TEST_SOURCE_CONTENT
       COMPILE_DEFINITIONS ${MPI_TEST_COMPILE_DEFINITIONS}
       LINK_LIBRARIES MPI::MPI_${LANG}
       COPY_FILE "${BIN_FILE}"

Modules/FindOpenACC.cmake

@@ -128,21 +128,18 @@ set(OpenACC_Fortran_CHECK_VERSION_SOURCE
 )
 
 
-function(_OPENACC_WRITE_SOURCE_FILE LANG SRC_FILE_CONTENT_VAR SRC_FILE_NAME SRC_FILE_FULLPATH)
-  set(WORK_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindOpenACC)
+macro(_OPENACC_PREPARE_SOURCE LANG CONTENT_ID NAME_PREFIX FULLNAME_VAR CONTENT_VAR)
   if("${LANG}" STREQUAL "C")
-    set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.c")
-    file(WRITE "${SRC_FILE}" "${OpenACC_C_CXX_${SRC_FILE_CONTENT_VAR}}")
+    set(${FULLNAME_VAR} "${NAME_PREFIX}.c")
+    set(${CONTENT_VAR} "${OpenACC_C_CXX_${CONTENT_ID}}")
   elseif("${LANG}" STREQUAL "CXX")
-    set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.cpp")
-    file(WRITE "${SRC_FILE}" "${OpenACC_C_CXX_${SRC_FILE_CONTENT_VAR}}")
+    set(${FULLNAME_VAR} "${NAME_PREFIX}.cpp")
+    set(${CONTENT_VAR} "${OpenACC_C_CXX_${CONTENT_ID}}")
   elseif("${LANG}" STREQUAL "Fortran")
-    set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.F90")
-    file(WRITE "${SRC_FILE}_in" "${OpenACC_Fortran_${SRC_FILE_CONTENT_VAR}}")
-    configure_file("${SRC_FILE}_in" "${SRC_FILE}" @ONLY)
+    set(${FULLNAME_VAR} "${NAME_PREFIX}.F90")
+    set(${CONTENT_VAR} "${OpenACC_Fortran_${CONTENT_ID}}")
   endif()
-  set(${SRC_FILE_FULLPATH} "${SRC_FILE}" PARENT_SCOPE)
-endfunction()
+endmacro()
 
 
 function(_OPENACC_GET_FLAGS_CANDIDATE LANG FLAG_VAR)
@@ -184,10 +181,12 @@ endfunction()
 function(_OPENACC_GET_FLAGS LANG FLAG_VAR)
   set(FLAG_CANDIDATES "")
   _OPENACC_GET_FLAGS_CANDIDATE("${LANG}" FLAG_CANDIDATES)
-  _OPENACC_WRITE_SOURCE_FILE("${LANG}" "TEST_SOURCE" OpenACCTryFlag _OPENACC_TEST_SRC)
+  _OPENACC_PREPARE_SOURCE("${LANG}" TEST_SOURCE OpenACCTryFlag
+    _OPENACC_TEST_SRC_NAME _OPENACC_TEST_SRC_CONTENT)
 
   foreach(FLAG IN LISTS FLAG_CANDIDATES)
-    try_compile(OpenACC_FLAG_TEST_RESULT SOURCES ${_OPENACC_TEST_SRC}
+    try_compile(OpenACC_FLAG_TEST_RESULT
+      SOURCE_FROM_VAR "${_OPENACC_TEST_SRC_NAME}" _OPENACC_TEST_SRC_CONTENT
       CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${FLAG}"
       OUTPUT_VARIABLE OpenACC_TRY_COMPILE_OUTPUT
     )
@@ -212,13 +211,15 @@ endfunction()
 
 
 function(_OPENACC_GET_SPEC_DATE LANG SPEC_DATE)
-  _OPENACC_WRITE_SOURCE_FILE("${LANG}" "CHECK_VERSION_SOURCE" OpenACCCheckVersion _OPENACC_TEST_SRC)
+  _OPENACC_PREPARE_SOURCE(${LANG} CHECK_VERSION_SOURCE OpenACCCheckVersion
+    _OPENACC_TEST_SRC_NAME _OPENACC_TEST_SRC_CONTENT)
 
   set(BIN_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindOpenACC/accver_${LANG}.bin")
-  try_compile(OpenACC_SPECTEST_${LANG} SOURCES "${_OPENACC_TEST_SRC}"
-              CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OpenACC_${LANG}_FLAGS}"
-              COPY_FILE ${BIN_FILE}
-              OUTPUT_VARIABLE OUTPUT)
+  try_compile(OpenACC_SPECTEST_${LANG}
+    SOURCE_FROM_VAR "${_OPENACC_TEST_SRC_NAME}" _OPENACC_TEST_SRC_CONTENT
+    CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OpenACC_${LANG}_FLAGS}"
+    COPY_FILE "${BIN_FILE}"
+    OUTPUT_VARIABLE OUTPUT)
 
   if(${OpenACC_SPECTEST_${LANG}})
     file(STRINGS ${BIN_FILE} specstr LIMIT_COUNT 1 REGEX "INFO:OpenACC-date")

Modules/FindOpenMP.cmake

@@ -178,27 +178,25 @@ set(OpenMP_Fortran_TEST_SOURCE
   "
 )
 
-function(_OPENMP_WRITE_SOURCE_FILE LANG SRC_FILE_CONTENT_VAR SRC_FILE_NAME SRC_FILE_FULLPATH)
-  set(WORK_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindOpenMP)
+macro(_OPENMP_PREPARE_SOURCE LANG CONTENT_ID NAME_PREFIX FULLNAME_VAR CONTENT_VAR)
   if("${LANG}" STREQUAL "C")
-    set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.c")
-    file(WRITE "${SRC_FILE}" "${OpenMP_C_CXX_${SRC_FILE_CONTENT_VAR}}")
+    set(${FULLNAME_VAR} "${NAME_PREFIX}.c")
+    set(${CONTENT_VAR} "${OpenMP_C_CXX_${CONTENT_ID}}")
   elseif("${LANG}" STREQUAL "CXX")
-    set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.cpp")
-    file(WRITE "${SRC_FILE}" "${OpenMP_C_CXX_${SRC_FILE_CONTENT_VAR}}")
+    set(${FULLNAME_VAR} "${NAME_PREFIX}.cpp")
+    set(${CONTENT_VAR} "${OpenMP_C_CXX_${CONTENT_ID}}")
   elseif("${LANG}" STREQUAL "Fortran")
-    set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.f90")
-    file(WRITE "${SRC_FILE}_in" "${OpenMP_Fortran_${SRC_FILE_CONTENT_VAR}}")
-    configure_file("${SRC_FILE}_in" "${SRC_FILE}" @ONLY)
+    set(${FULLNAME_VAR} "${NAME_PREFIX}.F90")
+    string(CONFIGURE "${OpenMP_Fortran_${CONTENT_ID}}" ${CONTENT_VAR} @ONLY)
   endif()
-  set(${SRC_FILE_FULLPATH} "${SRC_FILE}" PARENT_SCOPE)
-endfunction()
+endmacro()
 
 include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseImplicitLinkInfo.cmake)
 
 function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
   _OPENMP_FLAG_CANDIDATES("${LANG}")
-  _OPENMP_WRITE_SOURCE_FILE("${LANG}" "TEST_SOURCE" OpenMPTryFlag _OPENMP_TEST_SRC)
+  _OPENMP_PREPARE_SOURCE("${LANG}" TEST_SOURCE OpenMPTryFlag
+    _OPENMP_TEST_SRC_NAME _OPENMP_TEST_SRC_CONTENT)
 
   unset(OpenMP_VERBOSE_COMPILE_OPTIONS)
   separate_arguments(OpenMP_VERBOSE_OPTIONS NATIVE_COMMAND "${CMAKE_${LANG}_VERBOSE_FLAG}")
@@ -215,7 +213,7 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
     endif()
     string(REGEX REPLACE "[-/=+]" "" OPENMP_PLAIN_FLAG "${OPENMP_FLAG}")
     try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
-      SOURCES ${_OPENMP_TEST_SRC}
+      SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
       CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
       LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG}
       OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
@@ -313,7 +311,7 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
         # explicitly add a search path if the header can't be found on the
         # default header search path already.
         try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
-          SOURCES ${_OPENMP_TEST_SRC}
+          SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
           CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
           LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} ${OpenMP_libomp_LIBRARY}
           OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
@@ -324,7 +322,7 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
           set(OpenMP_${LANG}_INCLUDE_DIR "${OpenMP_${LANG}_INCLUDE_DIR}" PARENT_SCOPE)
           if(OpenMP_${LANG}_INCLUDE_DIR)
             try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
-              SOURCES ${_OPENMP_TEST_SRC}
+              SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
               CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
                           "-DINCLUDE_DIRECTORIES:STRING=${OpenMP_${LANG}_INCLUDE_DIR}"
               LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} ${OpenMP_libomp_LIBRARY}
@@ -347,7 +345,7 @@ function(_OPENMP_GET_FLAGS LANG FLAG_MODE OPENMP_FLAG_VAR OPENMP_LIB_NAMES_VAR)
       mark_as_advanced(OpenMP_libomp_LIBRARY)
       if(OpenMP_libomp_LIBRARY)
         try_compile( OpenMP_COMPILE_RESULT_${FLAG_MODE}_${OPENMP_PLAIN_FLAG}
-          SOURCES ${_OPENMP_TEST_SRC}
+          SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
           CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OPENMP_FLAGS_TEST}"
           LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} ${OpenMP_libomp_LIBRARY}
           OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT
@@ -409,7 +407,8 @@ set(OpenMP_Fortran_CHECK_VERSION_SOURCE
 ")
 
 function(_OPENMP_GET_SPEC_DATE LANG SPEC_DATE)
-  _OPENMP_WRITE_SOURCE_FILE("${LANG}" "CHECK_VERSION_SOURCE" OpenMPCheckVersion _OPENMP_TEST_SRC)
+  _OPENMP_PREPARE_SOURCE("${LANG}" CHECK_VERSION_SOURCE OpenMPCheckVersion
+    _OPENMP_TEST_SRC_NAME _OPENMP_TEST_SRC_CONTENT)
 
   unset(_includeDirFlags)
   if(OpenMP_${LANG}_INCLUDE_DIR)
@@ -419,10 +418,10 @@ function(_OPENMP_GET_SPEC_DATE LANG SPEC_DATE)
   set(BIN_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindOpenMP/ompver_${LANG}.bin")
   string(REGEX REPLACE "[-/=+]" "" OPENMP_PLAIN_FLAG "${OPENMP_FLAG}")
   try_compile(OpenMP_SPECTEST_${LANG}_${OPENMP_PLAIN_FLAG}
-              SOURCES "${_OPENMP_TEST_SRC}"
-              CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OpenMP_${LANG}_FLAGS}" ${_includeDirFlags}
-              COPY_FILE ${BIN_FILE}
-              OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT)
+    SOURCE_FROM_VAR "${_OPENMP_TEST_SRC_NAME}" _OPENMP_TEST_SRC_CONTENT
+    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")

Modules/FindThreads.cmake

@@ -129,13 +129,12 @@ macro(_threads_check_flag_pthread)
     elseif(NOT DEFINED THREADS_HAVE_PTHREAD_ARG)
       message(CHECK_START "Check if compiler accepts -pthread")
       if(CMAKE_C_COMPILER_LOADED)
-        set(_threads_src ${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c)
+        set(_threads_src CheckForPthreads.c)
       elseif(CMAKE_CXX_COMPILER_LOADED)
-        set(_threads_src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindThreads/CheckForPthreads.cxx)
-        configure_file(${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c "${_threads_src}" COPYONLY)
+        set(_threads_src CheckForPthreads.cxx)
       endif()
       try_compile(THREADS_HAVE_PTHREAD_ARG
-        SOURCES ${_threads_src}
+        SOURCE_FROM_FILE "${_threads_src}" "${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c"
         CMAKE_FLAGS -DLINK_LIBRARIES:STRING=-pthread
         OUTPUT_VARIABLE _cmake_check_pthreads_output)
 

Modules/Internal/CheckSourceCompiles.cmake

@@ -86,14 +86,13 @@ function(CMAKE_CHECK_SOURCE_COMPILES _lang _source _var)
     else()
       set(CHECK_${LANG}_SOURCE_COMPILES_ADD_INCLUDES)
     endif()
-    file(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.${_SRC_EXT}"
-      "${_source}\n")
 
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_START "Performing Test ${_var}")
     endif()
+    string(APPEND _source "\n")
     try_compile(${_var}
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.${_SRC_EXT}
+      SOURCE_FROM_VAR "src.${_SRC_EXT}" _source
       COMPILE_DEFINITIONS -D${_var} ${CMAKE_REQUIRED_DEFINITIONS}
       ${CHECK_${LANG}_SOURCE_COMPILES_ADD_LINK_OPTIONS}
       ${CHECK_${LANG}_SOURCE_COMPILES_ADD_LIBRARIES}

Modules/Internal/CheckSourceRuns.cmake

@@ -85,14 +85,13 @@ function(CMAKE_CHECK_SOURCE_RUNS _lang _source _var)
     else()
       set(CHECK_${_lang}_SOURCE_COMPILES_ADD_INCLUDES)
     endif()
-    file(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.${_SRC_EXT}"
-      "${_source}\n")
 
     if(NOT CMAKE_REQUIRED_QUIET)
       message(CHECK_START "Performing Test ${_var}")
     endif()
+    string(APPEND _source "\n")
     try_run(${_var}_EXITCODE ${_var}_COMPILED
-      SOURCES ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.${_SRC_EXT}
+      SOURCE_FROM_VAR "src.${_SRC_EXT}" _source
       COMPILE_DEFINITIONS -D${_var} ${CMAKE_REQUIRED_DEFINITIONS}
       ${CHECK_${_lang}_SOURCE_COMPILES_ADD_LINK_OPTIONS}
       ${CHECK_${_lang}_SOURCE_COMPILES_ADD_LIBRARIES}

Modules/Internal/FeatureTesting.cmake

@@ -4,7 +4,7 @@ macro(_record_compiler_features lang compile_flags feature_list)
 
   string(TOLOWER ${lang} lang_lc)
   file(REMOVE "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.bin")
-  file(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.${lang_lc}" "
+  set(_content "
   const char features[] = {\"\\n\"\n")
 
   get_property(known_features GLOBAL PROPERTY CMAKE_${lang}_KNOWN_FEATURES)
@@ -16,10 +16,11 @@ macro(_record_compiler_features lang compile_flags feature_list)
       else()
         set(_feature_condition "#if ${_cmake_feature_test_${feature}}\n\"1\"\n#else\n\"0\"\n#endif\n")
       endif()
-      file(APPEND "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.${lang_lc}" "\"${lang}_FEATURE:\"\n${_feature_condition}\"${feature}\\n\"\n")
+      string(APPEND _content
+        "\"${lang}_FEATURE:\"\n${_feature_condition}\"${feature}\\n\"\n")
     endif()
   endforeach()
-  file(APPEND "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.${lang_lc}"
+  string(APPEND _content
     "\n};\n\nint main(int argc, char** argv) { (void)argv; return features[argc]; }\n")
 
   if(CMAKE_${lang}_LINK_WITH_STANDARD_COMPILE_OPTION)
@@ -31,7 +32,7 @@ macro(_record_compiler_features lang compile_flags feature_list)
   endif()
 
   try_compile(CMAKE_${lang}_FEATURE_TEST
-    SOURCES "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.${lang_lc}"
+    SOURCE_FROM_VAR "feature_tests.${lang_lc}" _content
     COMPILE_DEFINITIONS "${compile_flags}"
     LINK_LIBRARIES "${compile_flags_for_link}"
     OUTPUT_VARIABLE _output

Modules/TestBigEndian.cmake

@@ -77,19 +77,16 @@ macro(__TEST_BIG_ENDIAN_LEGACY_IMPL VARIABLE)
     endif()
 
     if(_test_language STREQUAL "CXX")
-      set(_test_file "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/TestEndianess.cpp")
+      set(_test_file TestEndianess.cpp)
     else()
-      set(_test_file "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/TestEndianess.c")
+      set(_test_file TestEndianess.c)
     endif()
 
-    configure_file("${CMAKE_ROOT}/Modules/TestEndianess.c.in"
-                   ${_test_file}
-                   @ONLY)
-
-     file(READ ${_test_file} TEST_ENDIANESS_FILE_CONTENT)
+    file(READ "${CMAKE_ROOT}/Modules/TestEndianess.c.in" TEST_ENDIANESS_FILE_CONTENT)
+    string(CONFIGURE "${TEST_ENDIANESS_FILE_CONTENT}" TEST_ENDIANESS_FILE_CONTENT @ONLY)
 
      try_compile(HAVE_${VARIABLE}
-      SOURCES ${_test_file}
+      SOURCE_FROM_VAR "${_test_file}" TEST_ENDIANESS_FILE_CONTENT
       OUTPUT_VARIABLE OUTPUT
       COPY_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestEndianess.bin" )
 
@@ -130,12 +127,12 @@ macro(__TEST_BIG_ENDIAN_LEGACY_IMPL VARIABLE)
         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}\nTestEndianess.c:\n${TEST_ENDIANESS_FILE_CONTENT}\n\n")
+          "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}\nTestEndianess.c:\n${TEST_ENDIANESS_FILE_CONTENT}\n\n")
+          "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()