kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: put cmake files intoa CMakeFiles subdir to clean up bin tree

This commit is contained in:
Ken Martin 2005-07-29 09:19:25 -04:00
parent ad46c80f7a
commit c6b011e35e
33 changed files with 109 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Modules/CMakeDetermineCCompiler.cmake
View File

@ -67,11 +67,11 @@ IF(NOT CMAKE_COMPILER_IS_GNUCC_RUN)
IF(NOT CMAKE_COMPILER_RETURN) IF(NOT CMAKE_COMPILER_RETURN)
IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
SET(CMAKE_COMPILER_IS_GNUCC 1) SET(CMAKE_COMPILER_IS_GNUCC 1)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the C compiler is GNU succeeded with " "Determining if the C compiler is GNU succeeded with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n") "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the C compiler is GNU failed with " "Determining if the C compiler is GNU failed with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n") "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
@ -87,7 +87,7 @@ ENDIF(NOT CMAKE_COMPILER_IS_GNUCC_RUN)
# configure variables set in this file for fast reload later on # configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
${CMAKE_BINARY_DIR}/CMakeCCompiler.cmake IMMEDIATE) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeCCompiler.cmake IMMEDIATE)
MARK_AS_ADVANCED(CMAKE_AR) MARK_AS_ADVANCED(CMAKE_AR)
SET(CMAKE_C_COMPILER_ENV_VAR "CC") SET(CMAKE_C_COMPILER_ENV_VAR "CC")

6
Modules/CMakeDetermineCXXCompiler.cmake
View File

@ -53,11 +53,11 @@ IF(NOT CMAKE_COMPILER_IS_GNUCXX_RUN)
IF(NOT CMAKE_COMPILER_RETURN) IF(NOT CMAKE_COMPILER_RETURN)
IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
SET(CMAKE_COMPILER_IS_GNUCXX 1) SET(CMAKE_COMPILER_IS_GNUCXX 1)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the C++ compiler is GNU succeeded with " "Determining if the C++ compiler is GNU succeeded with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n") "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the C++ compiler is GNU failed with " "Determining if the C++ compiler is GNU failed with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n") "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
@ -66,6 +66,6 @@ ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX_RUN)
# configure all variables set in this file # configure all variables set in this file
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
${CMAKE_BINARY_DIR}/CMakeCXXCompiler.cmake IMMEDIATE) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeCXXCompiler.cmake IMMEDIATE)
SET(CMAKE_CXX_COMPILER_ENV_VAR "CXX") SET(CMAKE_CXX_COMPILER_ENV_VAR "CXX")

6
Modules/CMakeDetermineFortranCompiler.cmake
View File

@ -90,11 +90,11 @@ IF(NOT CMAKE_COMPILER_IS_GNUG77_RUN)
IF(NOT CMAKE_COMPILER_RETURN) IF(NOT CMAKE_COMPILER_RETURN)
IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
SET(CMAKE_COMPILER_IS_GNUG77 1) SET(CMAKE_COMPILER_IS_GNUG77 1)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the Fortran compiler is GNU succeeded with " "Determining if the Fortran compiler is GNU succeeded with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n") "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the Fortran compiler is GNU failed with " "Determining if the Fortran compiler is GNU failed with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n") "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" ) ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
@ -110,6 +110,6 @@ ENDIF(NOT CMAKE_COMPILER_IS_GNUG77_RUN)
# configure variables set in this file for fast reload later on # configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
${CMAKE_BINARY_DIR}/CMakeFortranCompiler.cmake IMMEDIATE) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeFortranCompiler.cmake IMMEDIATE)
MARK_AS_ADVANCED(CMAKE_AR) MARK_AS_ADVANCED(CMAKE_AR)
SET(CMAKE_Fortran_COMPILER_ENV_VAR "FC") SET(CMAKE_Fortran_COMPILER_ENV_VAR "FC")

2
Modules/CMakeDetermineJavaCompiler.cmake
View File

@ -81,6 +81,6 @@ MARK_AS_ADVANCED(CMAKE_Java_COMPILER)
# configure variables set in this file for fast reload later on # configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeJavaCompiler.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeJavaCompiler.cmake.in
${CMAKE_BINARY_DIR}/CMakeJavaCompiler.cmake IMMEDIATE @ONLY) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeJavaCompiler.cmake IMMEDIATE @ONLY)
MARK_AS_ADVANCED(CMAKE_AR CMAKE_Java_COMPILER_FULLPATH) MARK_AS_ADVANCED(CMAKE_AR CMAKE_Java_COMPILER_FULLPATH)
SET(CMAKE_Java_COMPILER_ENV_VAR "JAVA_COMPILER") SET(CMAKE_Java_COMPILER_ENV_VAR "JAVA_COMPILER")

2
Modules/CMakeDetermineRCCompiler.cmake
View File

@ -43,5 +43,5 @@ MARK_AS_ADVANCED(CMAKE_RC_COMPILER)
# configure variables set in this file for fast reload later on # configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeRCCompiler.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeRCCompiler.cmake.in
${CMAKE_BINARY_DIR}/CMakeRCCompiler.cmake IMMEDIATE) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeRCCompiler.cmake IMMEDIATE)
SET(CMAKE_RC_COMPILER_ENV_VAR "RC") SET(CMAKE_RC_COMPILER_ENV_VAR "RC")

4
Modules/CMakeDetermineSystem.cmake
View File

@ -70,10 +70,10 @@ IF(CMAKE_SYSTEM_VERSION)
ENDIF(CMAKE_SYSTEM_VERSION) ENDIF(CMAKE_SYSTEM_VERSION)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n") "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
# configure variables set in this file for fast reload # configure variables set in this file for fast reload
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in
${CMAKE_BINARY_DIR}/CMakeSystem.cmake IMMEDIATE) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeSystem.cmake IMMEDIATE)

4
Modules/CMakeTestCCompiler.cmake
View File

@ -18,7 +18,7 @@ ENDIF(NOT CMAKE_C_COMPILER_WORKS)
IF(NOT CMAKE_C_COMPILER_WORKS) IF(NOT CMAKE_C_COMPILER_WORKS)
MESSAGE(STATUS "Check for working C compiler: ${CMAKE_C_COMPILER} -- broken") MESSAGE(STATUS "Check for working C compiler: ${CMAKE_C_COMPILER} -- broken")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the C compiler works failed with " "Determining if the C compiler works failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
MESSAGE(FATAL_ERROR "The C compiler \"${CMAKE_C_COMPILER}\" " MESSAGE(FATAL_ERROR "The C compiler \"${CMAKE_C_COMPILER}\" "
@ -28,7 +28,7 @@ IF(NOT CMAKE_C_COMPILER_WORKS)
ELSE(NOT CMAKE_C_COMPILER_WORKS) ELSE(NOT CMAKE_C_COMPILER_WORKS)
IF(C_TEST_WAS_RUN) IF(C_TEST_WAS_RUN)
MESSAGE(STATUS "Check for working C compiler: ${CMAKE_C_COMPILER} -- works") MESSAGE(STATUS "Check for working C compiler: ${CMAKE_C_COMPILER} -- works")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the C compiler works passed with " "Determining if the C compiler works passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ENDIF(C_TEST_WAS_RUN) ENDIF(C_TEST_WAS_RUN)

4
Modules/CMakeTestCXXCompiler.cmake
View File

@ -18,7 +18,7 @@ ENDIF(NOT CMAKE_CXX_COMPILER_WORKS)
IF(NOT CMAKE_CXX_COMPILER_WORKS) IF(NOT CMAKE_CXX_COMPILER_WORKS)
MESSAGE(STATUS "Check for working CXX compiler: ${CMAKE_CXX_COMPILER} -- broken") MESSAGE(STATUS "Check for working CXX compiler: ${CMAKE_CXX_COMPILER} -- broken")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the CXX compiler works failed with " "Determining if the CXX compiler works failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
MESSAGE(FATAL_ERROR "The C++ compiler \"${CMAKE_CXX_COMPILER}\" " MESSAGE(FATAL_ERROR "The C++ compiler \"${CMAKE_CXX_COMPILER}\" "
@ -28,7 +28,7 @@ IF(NOT CMAKE_CXX_COMPILER_WORKS)
ELSE(NOT CMAKE_CXX_COMPILER_WORKS) ELSE(NOT CMAKE_CXX_COMPILER_WORKS)
IF(CXX_TEST_WAS_RUN) IF(CXX_TEST_WAS_RUN)
MESSAGE(STATUS "Check for working CXX compiler: ${CMAKE_CXX_COMPILER} -- works") MESSAGE(STATUS "Check for working CXX compiler: ${CMAKE_CXX_COMPILER} -- works")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the CXX compiler works passed with " "Determining if the CXX compiler works passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ENDIF(CXX_TEST_WAS_RUN) ENDIF(CXX_TEST_WAS_RUN)

8
Modules/CMakeTestFortranCompiler.cmake
View File

@ -18,7 +18,7 @@ ENDIF(NOT CMAKE_Fortran_COMPILER_WORKS)
IF(NOT CMAKE_Fortran_COMPILER_WORKS) IF(NOT CMAKE_Fortran_COMPILER_WORKS)
MESSAGE(STATUS "Check for working Fortran compiler: ${CMAKE_Fortran_COMPILER} -- broken") MESSAGE(STATUS "Check for working Fortran compiler: ${CMAKE_Fortran_COMPILER} -- broken")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the Fortran compiler works failed with " "Determining if the Fortran compiler works failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
MESSAGE(FATAL_ERROR "The Fortran compiler \"${CMAKE_Fortran_COMPILER}\" " MESSAGE(FATAL_ERROR "The Fortran compiler \"${CMAKE_Fortran_COMPILER}\" "
@ -28,7 +28,7 @@ IF(NOT CMAKE_Fortran_COMPILER_WORKS)
ELSE(NOT CMAKE_Fortran_COMPILER_WORKS) ELSE(NOT CMAKE_Fortran_COMPILER_WORKS)
IF(FORTRAN_TEST_WAS_RUN) IF(FORTRAN_TEST_WAS_RUN)
MESSAGE(STATUS "Check for working Fortran compiler: ${CMAKE_Fortran_COMPILER} -- works") MESSAGE(STATUS "Check for working Fortran compiler: ${CMAKE_Fortran_COMPILER} -- works")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the Fortran compiler works passed with " "Determining if the Fortran compiler works passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ENDIF(FORTRAN_TEST_WAS_RUN) ENDIF(FORTRAN_TEST_WAS_RUN)
@ -50,13 +50,13 @@ IF(CMAKE_Fortran_COMPILER_WORKS)
OUTPUT_VARIABLE OUTPUT) OUTPUT_VARIABLE OUTPUT)
IF(CMAKE_Fortran_COMPILER_SUPPORTS_F90) IF(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
MESSAGE(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- yes") MESSAGE(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- yes")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the Fortran compiler supports Fortran 90 passed with " "Determining if the Fortran compiler supports Fortran 90 passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
SET(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1 CACHE INTERNAL "") SET(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1 CACHE INTERNAL "")
ELSE(CMAKE_Fortran_COMPILER_SUPPORTS_F90) ELSE(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
MESSAGE(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- no") MESSAGE(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- no")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the Fortran compiler supports Fortran 90 failed with " "Determining if the Fortran compiler supports Fortran 90 failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
SET(CMAKE_Fortran_COMPILER_SUPPORTS_F90 0 CACHE INTERNAL "") SET(CMAKE_Fortran_COMPILER_SUPPORTS_F90 0 CACHE INTERNAL "")

4
Modules/CheckFunctionExists.cmake
View File

@ -24,13 +24,13 @@ MACRO(CHECK_FUNCTION_EXISTS FUNCTION VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
SET(${VARIABLE} 1 CACHE INTERNAL "Have function ${FUNCTION}") SET(${VARIABLE} 1 CACHE INTERNAL "Have function ${FUNCTION}")
MESSAGE(STATUS "Looking for ${FUNCTION} - found") MESSAGE(STATUS "Looking for ${FUNCTION} - found")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the function ${FUNCTION} exists passed with the following output:\n" "Determining if the function ${FUNCTION} exists passed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Looking for ${FUNCTION} - not found") MESSAGE(STATUS "Looking for ${FUNCTION} - not found")
SET(${VARIABLE} "" CACHE INTERNAL "Have function ${FUNCTION}") SET(${VARIABLE} "" CACHE INTERNAL "Have function ${FUNCTION}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the function ${FUNCTION} exists failed with the following output:\n" "Determining if the function ${FUNCTION} exists failed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ENDIF(${VARIABLE}) ENDIF(${VARIABLE})

4
Modules/CheckIncludeFile.cmake
View File

@ -32,14 +32,14 @@ MACRO(CHECK_INCLUDE_FILE INCLUDE VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
MESSAGE(STATUS "Looking for ${INCLUDE} - found") MESSAGE(STATUS "Looking for ${INCLUDE} - found")
SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}") SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the include file ${INCLUDE} " "Determining if the include file ${INCLUDE} "
"exists passed with the following output:\n" "exists passed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Looking for ${INCLUDE} - not found.") MESSAGE(STATUS "Looking for ${INCLUDE} - not found.")
SET(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}") SET(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the include file ${INCLUDE} " "Determining if the include file ${INCLUDE} "
"exists failed with the following output:\n" "exists failed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")

4
Modules/CheckIncludeFileCXX.cmake
View File

@ -30,14 +30,14 @@ MACRO(CHECK_INCLUDE_FILE_CXX INCLUDE VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
MESSAGE(STATUS "Checking for CXX include file ${INCLUDE} -- found") MESSAGE(STATUS "Checking for CXX include file ${INCLUDE} -- found")
SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}") SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${INCLUDE}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the include file ${INCLUDE} " "Determining if the include file ${INCLUDE} "
"exists passed with the following output:\n" "exists passed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Checking for CXX include file ${INCLUDE} -- not found") MESSAGE(STATUS "Checking for CXX include file ${INCLUDE} -- not found")
SET(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}") SET(${VARIABLE} "" CACHE INTERNAL "Have include ${INCLUDE}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the include file ${INCLUDE} " "Determining if the include file ${INCLUDE} "
"exists failed with the following output:\n" "exists failed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")

4
Modules/CheckIncludeFiles.cmake
View File

@ -29,14 +29,14 @@ MACRO(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
MESSAGE(STATUS "Looking for include files ${VARIABLE} - found") MESSAGE(STATUS "Looking for include files ${VARIABLE} - found")
SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${VARIABLE}") SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${VARIABLE}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if files ${INCLUDE} " "Determining if files ${INCLUDE} "
"exist passed with the following output:\n" "exist passed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Looking for include files ${VARIABLE} - not found.") MESSAGE(STATUS "Looking for include files ${VARIABLE} - not found.")
SET(${VARIABLE} "" CACHE INTERNAL "Have includes ${VARIABLE}") SET(${VARIABLE} "" CACHE INTERNAL "Have includes ${VARIABLE}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if files ${INCLUDE} " "Determining if files ${INCLUDE} "
"exist failed with the following output:\n" "exist failed with the following output:\n"
"${OUTPUT}\nSource:\n${CHECK_INCLUDE_FILES_CONTENT}\n") "${OUTPUT}\nSource:\n${CHECK_INCLUDE_FILES_CONTENT}\n")

4
Modules/CheckLibraryExists.cmake
View File

@ -28,14 +28,14 @@ MACRO(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
MESSAGE(STATUS "Looking for ${FUNCTION} in ${LIBRARY} - found") MESSAGE(STATUS "Looking for ${FUNCTION} in ${LIBRARY} - found")
SET(${VARIABLE} 1 CACHE INTERNAL "Have library ${LIBRARY}") SET(${VARIABLE} 1 CACHE INTERNAL "Have library ${LIBRARY}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the function ${FUNCTION} exists in the ${LIBRARY} " "Determining if the function ${FUNCTION} exists in the ${LIBRARY} "
"passed with the following output:\n" "passed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Looking for ${FUNCTION} in ${LIBRARY} - not found") MESSAGE(STATUS "Looking for ${FUNCTION} in ${LIBRARY} - not found")
SET(${VARIABLE} "" CACHE INTERNAL "Have library ${LIBRARY}") SET(${VARIABLE} "" CACHE INTERNAL "Have library ${LIBRARY}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the function ${FUNCTION} exists in the ${LIBRARY} " "Determining if the function ${FUNCTION} exists in the ${LIBRARY} "
"failed with the following output:\n" "failed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")

4
Modules/CheckSymbolExists.cmake
View File

@ -36,7 +36,7 @@ MACRO(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
MESSAGE(STATUS "Looking for ${SYMBOL} - found") MESSAGE(STATUS "Looking for ${SYMBOL} - found")
SET(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}") SET(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the ${SYMBOL} " "Determining if the ${SYMBOL} "
"exist passed with the following output:\n" "exist passed with the following output:\n"
"${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.c:\n" "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.c:\n"
@ -44,7 +44,7 @@ MACRO(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE)
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Looking for ${SYMBOL} - not found.") MESSAGE(STATUS "Looking for ${SYMBOL} - not found.")
SET(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}") SET(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the ${SYMBOL} " "Determining if the ${SYMBOL} "
"exist failed with the following output:\n" "exist failed with the following output:\n"
"${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.c:\n" "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.c:\n"

4
Modules/CheckTypeSize.cmake
View File

@ -39,11 +39,11 @@ MACRO(CHECK_TYPE_SIZE TYPE VARIABLE)
OUTPUT_VARIABLE OUTPUT) OUTPUT_VARIABLE OUTPUT)
IF(HAVE_${VARIABLE}) IF(HAVE_${VARIABLE})
MESSAGE(STATUS "Check size of ${TYPE} - done") MESSAGE(STATUS "Check size of ${TYPE} - done")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n") "Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n")
ELSE(HAVE_${VARIABLE}) ELSE(HAVE_${VARIABLE})
MESSAGE(STATUS "Check size of ${TYPE} - failed") MESSAGE(STATUS "Check size of ${TYPE} - failed")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining size of ${TYPE} failed with the following output:\n${OUTPUT}\nCheckTypeSize.c:\n${CHECK_TYPE_SIZE_FILE_CONTENT}\n\n") "Determining size of ${TYPE} failed with the following output:\n${OUTPUT}\nCheckTypeSize.c:\n${CHECK_TYPE_SIZE_FILE_CONTENT}\n\n")
ENDIF(HAVE_${VARIABLE}) ENDIF(HAVE_${VARIABLE})
ENDIF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$") ENDIF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")

4
Modules/CheckVariableExists.cmake
View File

@ -23,13 +23,13 @@ MACRO(CHECK_VARIABLE_EXISTS VAR VARIABLE)
IF(${VARIABLE}) IF(${VARIABLE})
SET(${VARIABLE} 1 CACHE INTERNAL "Have variable ${VAR}") SET(${VARIABLE} 1 CACHE INTERNAL "Have variable ${VAR}")
MESSAGE(STATUS "Looking for ${VAR} - found") MESSAGE(STATUS "Looking for ${VAR} - found")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the variable ${VAR} exists passed with the following output:\n" "Determining if the variable ${VAR} exists passed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
SET(${VARIABLE} "" CACHE INTERNAL "Have variable ${VAR}") SET(${VARIABLE} "" CACHE INTERNAL "Have variable ${VAR}")
MESSAGE(STATUS "Looking for ${VAR} - not found") MESSAGE(STATUS "Looking for ${VAR} - not found")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the variable ${VAR} exists failed with the following output:\n" "Determining if the variable ${VAR} exists failed with the following output:\n"
"${OUTPUT}\n\n") "${OUTPUT}\n\n")
ENDIF(${VARIABLE}) ENDIF(${VARIABLE})

4
Modules/FindThreads.cmake
View File

@ -62,12 +62,12 @@ ELSE(CMAKE_HAVE_SPROC_H)
MESSAGE(STATUS "Check if compiler accepts -pthread - yes") MESSAGE(STATUS "Check if compiler accepts -pthread - yes")
ELSE(THREADS_PTHREAD_ARG MATCHES "^2$") ELSE(THREADS_PTHREAD_ARG MATCHES "^2$")
MESSAGE(STATUS "Check if compiler accepts -pthread - no") MESSAGE(STATUS "Check if compiler accepts -pthread - no")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if compiler accepts -pthread returned ${THREADS_PTHREAD_ARG} instead of 2. The compiler had the following output:\n${OUTPUT}\n\n") "Determining if compiler accepts -pthread returned ${THREADS_PTHREAD_ARG} instead of 2. The compiler had the following output:\n${OUTPUT}\n\n")
ENDIF(THREADS_PTHREAD_ARG MATCHES "^2$") ENDIF(THREADS_PTHREAD_ARG MATCHES "^2$")
ELSE(THREADS_HAVE_PTHREAD_ARG) ELSE(THREADS_HAVE_PTHREAD_ARG)
MESSAGE(STATUS "Check if compiler accepts -pthread - no") MESSAGE(STATUS "Check if compiler accepts -pthread - no")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if compiler accepts -pthread failed with the following output:\n${OUTPUT}\n\n") "Determining if compiler accepts -pthread failed with the following output:\n${OUTPUT}\n\n")
ENDIF(THREADS_HAVE_PTHREAD_ARG) ENDIF(THREADS_HAVE_PTHREAD_ARG)
ENDIF("THREADS_HAVE_PTHREAD_ARG" MATCHES "^THREADS_HAVE_PTHREAD_ARG") ENDIF("THREADS_HAVE_PTHREAD_ARG" MATCHES "^THREADS_HAVE_PTHREAD_ARG")

12
Modules/Platform/Windows-cl.cmake
View File

@ -1,5 +1,5 @@
# try to load any previously computed information for C on this platform # try to load any previously computed information for C on this platform
INCLUDE( ${CMAKE_BINARY_DIR}/CMakeCPlatform.cmake OPTIONAL) INCLUDE( ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeCPlatform.cmake OPTIONAL)
SET(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:") SET(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:")
SET(CMAKE_LINK_LIBRARY_FLAG "") SET(CMAKE_LINK_LIBRARY_FLAG "")
@ -84,7 +84,7 @@ IF(CMAKE_GENERATOR MATCHES "NMake Makefiles")
RETURN_VALUE CMAKE_COMPILER_RETURN RETURN_VALUE CMAKE_COMPILER_RETURN
) )
IF(NOT CMAKE_COMPILER_RETURN) IF(NOT CMAKE_COMPILER_RETURN)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining the version of compiler passed with the following output:\n" "Determining the version of compiler passed with the following output:\n"
"${CMAKE_COMPILER_OUTPUT}\n\n") "${CMAKE_COMPILER_OUTPUT}\n\n")
STRING(REGEX REPLACE "\n" " " compilerVersion "${CMAKE_COMPILER_OUTPUT}") STRING(REGEX REPLACE "\n" " " compilerVersion "${CMAKE_COMPILER_OUTPUT}")
@ -103,7 +103,7 @@ IF(CMAKE_GENERATOR MATCHES "NMake Makefiles")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*VERSION=1[4-9][0-9][0-9].*" ) ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*VERSION=1[4-9][0-9][0-9].*" )
ELSE(NOT CMAKE_COMPILER_RETURN) ELSE(NOT CMAKE_COMPILER_RETURN)
MESSAGE(STATUS "Check for CL compiler version - failed") MESSAGE(STATUS "Check for CL compiler version - failed")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining the version of compiler failed with the following output:\n" "Determining the version of compiler failed with the following output:\n"
"${CMAKE_COMPILER_OUTPUT}\n\n") "${CMAKE_COMPILER_OUTPUT}\n\n")
ENDIF(NOT CMAKE_COMPILER_RETURN) ENDIF(NOT CMAKE_COMPILER_RETURN)
@ -122,13 +122,13 @@ IF(CMAKE_GENERATOR MATCHES "NMake Makefiles")
RETURN_VALUE CMAKE_COMPILER_RETURN RETURN_VALUE CMAKE_COMPILER_RETURN
) )
IF(CMAKE_COMPILER_RETURN) IF(CMAKE_COMPILER_RETURN)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if this is a free VC compiler failed with the following output:\n" "Determining if this is a free VC compiler failed with the following output:\n"
"${CMAKE_COMPILER_OUTPUT}\n\n") "${CMAKE_COMPILER_OUTPUT}\n\n")
MESSAGE(STATUS "Check if this is a free VC compiler - yes") MESSAGE(STATUS "Check if this is a free VC compiler - yes")
SET(CMAKE_USING_VC_FREE_TOOLS 1) SET(CMAKE_USING_VC_FREE_TOOLS 1)
ELSE(CMAKE_COMPILER_RETURN) ELSE(CMAKE_COMPILER_RETURN)
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if this is a free VC compiler passed with the following output:\n" "Determining if this is a free VC compiler passed with the following output:\n"
"${CMAKE_COMPILER_OUTPUT}\n\n") "${CMAKE_COMPILER_OUTPUT}\n\n")
MESSAGE(STATUS "Check if this is a free VC compiler - no") MESSAGE(STATUS "Check if this is a free VC compiler - no")
@ -210,4 +210,4 @@ SET (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_RELW
# save computed information for this platform # save computed information for this platform
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/Platform/Windows-cl.cmake.in CONFIGURE_FILE(${CMAKE_ROOT}/Modules/Platform/Windows-cl.cmake.in
${CMAKE_BINARY_DIR}/CMakeCPlatform.cmake IMMEDIATE) ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeCPlatform.cmake IMMEDIATE)

10
Modules/TestBigEndian.cmake
View File

@ -15,21 +15,21 @@ MACRO(TEST_BIG_ENDIAN VARIABLE)
ENDIF("${VARIABLE}" STREQUAL "FAILED_TO_RUN") ENDIF("${VARIABLE}" STREQUAL "FAILED_TO_RUN")
MESSAGE(STATUS "Check if the system is big endian") MESSAGE(STATUS "Check if the system is big endian")
IF(HAVE_${VARIABLE}) IF(HAVE_${VARIABLE})
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining the endianes of the system passed. The system is ") "Determining the endianes of the system passed. The system is ")
IF(${VARIABLE}) IF(${VARIABLE})
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"big endian") "big endian")
MESSAGE(STATUS "Check if the system is big endian - big endian") MESSAGE(STATUS "Check if the system is big endian - big endian")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"little endian") "little endian")
MESSAGE(STATUS "Check if the system is big endian - little endian") MESSAGE(STATUS "Check if the system is big endian - little endian")
ENDIF(${VARIABLE}) ENDIF(${VARIABLE})
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Test produced following output:\n${OUTPUT}\n\n") "Test produced following output:\n${OUTPUT}\n\n")
ELSE(HAVE_${VARIABLE}) ELSE(HAVE_${VARIABLE})
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining the endianes of the system failed with the following output:\n${OUTPUT}\n\n") "Determining the endianes of the system failed with the following output:\n${OUTPUT}\n\n")
MESSAGE("Check if the system is big endian - failed") MESSAGE("Check if the system is big endian - failed")
ENDIF(HAVE_${VARIABLE}) ENDIF(HAVE_${VARIABLE})

4
Modules/TestCXXAcceptsFlag.cmake
View File

@ -16,12 +16,12 @@ MACRO(CHECK_CXX_ACCEPTS_FLAG FLAGS VARIABLE)
OUTPUT_VARIABLE OUTPUT) OUTPUT_VARIABLE OUTPUT)
IF(${VARIABLE}) IF(${VARIABLE})
MESSAGE(STATUS "Checking to see if CXX compiler accepts flag ${FLAGS} - yes") MESSAGE(STATUS "Checking to see if CXX compiler accepts flag ${FLAGS} - yes")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the CXX compiler accepts the flag ${FLAGS} passed with " "Determining if the CXX compiler accepts the flag ${FLAGS} passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ELSE(${VARIABLE}) ELSE(${VARIABLE})
MESSAGE(STATUS "Checking to see if CXX compiler accepts flag ${FLAGS} - no") MESSAGE(STATUS "Checking to see if CXX compiler accepts flag ${FLAGS} - no")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the CXX compiler accepts the flag ${FLAGS} failed with " "Determining if the CXX compiler accepts the flag ${FLAGS} failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ENDIF(${VARIABLE}) ENDIF(${VARIABLE})

4
Modules/TestForANSIForScope.cmake
View File

@ -13,14 +13,14 @@ IF("CMAKE_ANSI_FOR_SCOPE" MATCHES "^CMAKE_ANSI_FOR_SCOPE$")
MESSAGE(STATUS "Check for ANSI scope - found") MESSAGE(STATUS "Check for ANSI scope - found")
SET (CMAKE_NO_ANSI_FOR_SCOPE 0 CACHE INTERNAL SET (CMAKE_NO_ANSI_FOR_SCOPE 0 CACHE INTERNAL
"Does the compiler support ansi for scope.") "Does the compiler support ansi for scope.")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the CXX compiler understands ansi for scopes passed with " "Determining if the CXX compiler understands ansi for scopes passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ELSE (CMAKE_ANSI_FOR_SCOPE) ELSE (CMAKE_ANSI_FOR_SCOPE)
MESSAGE(STATUS "Check for ANSI scope - not found") MESSAGE(STATUS "Check for ANSI scope - not found")
SET (CMAKE_NO_ANSI_FOR_SCOPE 1 CACHE INTERNAL SET (CMAKE_NO_ANSI_FOR_SCOPE 1 CACHE INTERNAL
"Does the compiler support ansi for scope.") "Does the compiler support ansi for scope.")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the CXX compiler understands ansi for scopes failed with " "Determining if the CXX compiler understands ansi for scopes failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ENDIF (CMAKE_ANSI_FOR_SCOPE) ENDIF (CMAKE_ANSI_FOR_SCOPE)

4
Modules/TestForSTDNamespace.cmake
View File

@ -12,14 +12,14 @@ IF("CMAKE_STD_NAMESPACE" MATCHES "^CMAKE_STD_NAMESPACE$")
MESSAGE(STATUS "Check for STD namespace - found") MESSAGE(STATUS "Check for STD namespace - found")
SET (CMAKE_NO_STD_NAMESPACE 0 CACHE INTERNAL SET (CMAKE_NO_STD_NAMESPACE 0 CACHE INTERNAL
"Does the compiler support std::.") "Does the compiler support std::.")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeOutput.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Determining if the CXX compiler has std namespace passed with " "Determining if the CXX compiler has std namespace passed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ELSE (CMAKE_STD_NAMESPACE) ELSE (CMAKE_STD_NAMESPACE)
MESSAGE(STATUS "Check for STD namespace - not found") MESSAGE(STATUS "Check for STD namespace - not found")
SET (CMAKE_NO_STD_NAMESPACE 1 CACHE INTERNAL SET (CMAKE_NO_STD_NAMESPACE 1 CACHE INTERNAL
"Does the compiler support std::.") "Does the compiler support std::.")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Determining if the CXX compiler has std namespace failed with " "Determining if the CXX compiler has std namespace failed with "
"the following output:\n${OUTPUT}\n\n") "the following output:\n${OUTPUT}\n\n")
ENDIF (CMAKE_STD_NAMESPACE) ENDIF (CMAKE_STD_NAMESPACE)

2
Source/cmCacheManager.cxx
View File

@ -557,6 +557,8 @@ bool cmCacheManager::SaveCache(const char* path)
cacheFile.c_str()); cacheFile.c_str());
cmSystemTools::RemoveFile(tempFile.c_str()); cmSystemTools::RemoveFile(tempFile.c_str());
std::string checkCacheFile = path; std::string checkCacheFile = path;
checkCacheFile += "/CMakeFiles";
cmSystemTools::MakeDirectory(checkCacheFile.c_str());
checkCacheFile += "/cmake.check_cache"; checkCacheFile += "/cmake.check_cache";
std::ofstream checkCache(checkCacheFile.c_str()); std::ofstream checkCache(checkCacheFile.c_str());
if(!checkCache) if(!checkCache)

21
Source/cmGlobalGenerator.cxx
View File

@ -100,8 +100,9 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
} }
// enable the given language // enable the given language
void cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages, void
cmMakefile *mf) cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *mf)
{ {
if(languages.size() == 0) if(languages.size() == 0)
{ {
@ -113,6 +114,8 @@ void cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
mf->AddDefinition("RUN_CONFIGURE", true); mf->AddDefinition("RUN_CONFIGURE", true);
bool needTestLanguage = false; bool needTestLanguage = false;
std::string rootBin = mf->GetHomeOutputDirectory(); std::string rootBin = mf->GetHomeOutputDirectory();
rootBin += "/CMakeFiles";
// If the configuration files path has been set, // If the configuration files path has been set,
// then we are in a try compile and need to copy the enable language // then we are in a try compile and need to copy the enable language
// files into the try compile directory // files into the try compile directory
@ -251,10 +254,12 @@ void cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
std::string determineCompiler = "CMakeDetermine"; std::string determineCompiler = "CMakeDetermine";
determineCompiler += lang; determineCompiler += lang;
determineCompiler += "Compiler.cmake"; determineCompiler += "Compiler.cmake";
std::string determineFile = mf->GetModulesFile(determineCompiler.c_str()); std::string determineFile =
mf->GetModulesFile(determineCompiler.c_str());
if(!mf->ReadListFile(0,determineFile.c_str())) if(!mf->ReadListFile(0,determineFile.c_str()))
{ {
cmSystemTools::Error("Could not find cmake module file:", determineFile.c_str()); cmSystemTools::Error("Could not find cmake module file:",
determineFile.c_str());
} }
// Some generators like visual studio should not use the env variables // Some generators like visual studio should not use the env variables
// So the global generator can specify that in this variable // So the global generator can specify that in this variable
@ -344,7 +349,8 @@ void cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
std::string ifpath = mf->GetModulesFile(testLang.c_str()); std::string ifpath = mf->GetModulesFile(testLang.c_str());
if(!mf->ReadListFile(0,ifpath.c_str())) if(!mf->ReadListFile(0,ifpath.c_str()))
{ {
cmSystemTools::Error("Could not find cmake module file:", ifpath.c_str()); cmSystemTools::Error("Could not find cmake module file:",
ifpath.c_str());
} }
// **** Step 8, load backwards compatibility stuff for C and CXX // **** Step 8, load backwards compatibility stuff for C and CXX
// for old versions of CMake ListFiles C and CXX had some // for old versions of CMake ListFiles C and CXX had some
@ -785,8 +791,9 @@ cmLocalGenerator *cmGlobalGenerator::CreateLocalGenerator()
void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen ) void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen )
{ {
this->SetConfiguredFilesPath( std::string cfp = gen->GetCMakeInstance()->GetHomeOutputDirectory();
gen->GetCMakeInstance()->GetHomeOutputDirectory()); cfp += "/CMakeFiles";
this->SetConfiguredFilesPath(cfp.c_str());
const char* make = const char* make =
gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM"); gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make, this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,

24
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -171,7 +171,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
// see if the build system must be regenerated. // see if the build system must be regenerated.
std::string makefileName = std::string makefileName =
this->GetCMakeInstance()->GetHomeOutputDirectory(); this->GetCMakeInstance()->GetHomeOutputDirectory();
makefileName += "/Makefile2"; makefileName += "/CMakeFiles/Makefile2";
cmGeneratedFileStream makefileStream(makefileName.c_str()); cmGeneratedFileStream makefileStream(makefileName.c_str());
if(!makefileStream) if(!makefileStream)
{ {
@ -240,7 +240,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
// see if the build system must be regenerated. // see if the build system must be regenerated.
std::string cmakefileName = std::string cmakefileName =
this->GetCMakeInstance()->GetHomeOutputDirectory(); this->GetCMakeInstance()->GetHomeOutputDirectory();
cmakefileName += "/Makefile.cmake"; cmakefileName += "/CMakeFiles/Makefile.cmake";
cmGeneratedFileStream cmakefileStream(cmakefileName.c_str()); cmGeneratedFileStream cmakefileStream(cmakefileName.c_str());
if(!cmakefileStream) if(!cmakefileStream)
{ {
@ -305,7 +305,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
// Build the path to the cache check file. // Build the path to the cache check file.
std::string check = this->GetCMakeInstance()->GetHomeOutputDirectory(); std::string check = this->GetCMakeInstance()->GetHomeOutputDirectory();
check += "/cmake.check_cache"; check += "/CMakeFiles/cmake.check_cache";
// Set the corresponding makefile in the cmake file. // Set the corresponding makefile in the cmake file.
cmakefileStream cmakefileStream
@ -322,7 +322,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
{ {
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]); lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
tmpStr = lg->GetMakefile()->GetStartOutputDirectory(); tmpStr = lg->GetMakefile()->GetStartOutputDirectory();
tmpStr += "/CMakeDirectoryInformation.cmake"; tmpStr += "/CMakeFiles/CMakeDirectoryInformation.cmake";
cmakefileStream << " \"" << cmakefileStream << " \"" <<
lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str() << "\"\n"; lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str() << "\"\n";
} }
@ -374,7 +374,7 @@ void cmGlobalUnixMakefileGenerator3
// Check the build system in this directory. // Check the build system in this directory.
depends.push_back("cmake_check_build_system"); depends.push_back("cmake_check_build_system");
commands.push_back(lg->GetRecursiveMakeCall("Makefile2","all")); commands.push_back(lg->GetRecursiveMakeCall("CMakeFiles/Makefile2","all"));
// Write the rule. // Write the rule.
lg->WriteMakeRule(makefileStream, "The main all target", "all", depends, commands); lg->WriteMakeRule(makefileStream, "The main all target", "all", depends, commands);
@ -382,14 +382,14 @@ void cmGlobalUnixMakefileGenerator3
// write the clean // write the clean
depends.clear(); depends.clear();
commands.clear(); commands.clear();
commands.push_back(lg->GetRecursiveMakeCall("Makefile2","clean")); commands.push_back(lg->GetRecursiveMakeCall("CMakeFiles/Makefile2","clean"));
lg->WriteMakeRule(makefileStream, "The main clean target", "clean", lg->WriteMakeRule(makefileStream, "The main clean target", "clean",
depends, commands); depends, commands);
// write the depend rule, really a recompute depends rule // write the depend rule, really a recompute depends rule
depends.clear(); depends.clear();
commands.clear(); commands.clear();
std::string cmakefileName = "Makefile.cmake"; std::string cmakefileName = "CMakeFiles/Makefile.cmake";
std::string runRule = std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)"; "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system "; runRule += " --check-build-system ";
@ -472,7 +472,8 @@ cmGlobalUnixMakefileGenerator3
// write the directory rule // write the directory rule
commands.clear(); commands.clear();
commands.push_back commands.push_back
(lg->GetRecursiveMakeCall("Makefile2",makeTargetName.c_str())); (lg->GetRecursiveMakeCall("CMakeFiles/Makefile2",
makeTargetName.c_str()));
// Write the rule. // Write the rule.
lg->WriteMakeRule(ruleFileStream, "Convenience name for directory.", lg->WriteMakeRule(ruleFileStream, "Convenience name for directory.",
@ -602,7 +603,8 @@ cmGlobalUnixMakefileGenerator3
// write the directory rule // write the directory rule
commands.clear(); commands.clear();
commands.push_back commands.push_back
(lg->GetRecursiveMakeCall("Makefile2",makeTargetName.c_str())); (lg->GetRecursiveMakeCall("CMakeFiles/Makefile2",
makeTargetName.c_str()));
// Write the rule. // Write the rule.
lg->WriteMakeRule(ruleFileStream, "Convenience name for directory.", lg->WriteMakeRule(ruleFileStream, "Convenience name for directory.",
@ -703,7 +705,7 @@ cmGlobalUnixMakefileGenerator3
// Write the rule. // Write the rule.
commands.clear(); commands.clear();
commands.push_back(lg->GetRecursiveMakeCall("Makefile2", commands.push_back(lg->GetRecursiveMakeCall("CMakeFiles/Makefile2",
t->second.GetName())); t->second.GetName()));
depends.clear(); depends.clear();
depends.push_back("cmake_check_build_system"); depends.push_back("cmake_check_build_system");
@ -798,7 +800,7 @@ cmGlobalUnixMakefileGenerator3
// Write the rule. // Write the rule.
commands.clear(); commands.clear();
commands.push_back(lg->GetRecursiveMakeCall("Makefile2", commands.push_back(lg->GetRecursiveMakeCall("CMakeFiles/Makefile2",
localName.c_str())); localName.c_str()));
depends.clear(); depends.clear();
depends.push_back("cmake_check_build_system"); depends.push_back("cmake_check_build_system");

2
Source/cmGlobalXCodeGenerator.cxx
View File

@ -367,7 +367,7 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(cmLocalGenerator* root)
m_CurrentReRunCMakeMakefile += "/ReRunCMake.make"; m_CurrentReRunCMakeMakefile += "/ReRunCMake.make";
cmGeneratedFileStream makefileStream(m_CurrentReRunCMakeMakefile.c_str()); cmGeneratedFileStream makefileStream(m_CurrentReRunCMakeMakefile.c_str());
makefileStream << "# Generated by CMake, DO NOT EDIT\n"; makefileStream << "# Generated by CMake, DO NOT EDIT\n";
makefileStream << "cmake.check_cache: "; makefileStream << "CMakeFiles/cmake.check_cache: ";
for(std::vector<std::string>::const_iterator i = lfiles.begin(); for(std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i) i != lfiles.end(); ++i)
{ {

5
Source/cmLocalGenerator.cxx
View File

@ -43,6 +43,11 @@ cmLocalGenerator::~cmLocalGenerator()
void cmLocalGenerator::Configure() void cmLocalGenerator::Configure()
{ {
// make sure the CMakeFiles dir is there
std::string filesDir = m_Makefile->GetStartOutputDirectory();
filesDir += "/CMakeFiles";
cmSystemTools::MakeDirectory(filesDir.c_str());
// find & read the list file // find & read the list file
std::string currentStart = m_Makefile->GetStartDirectory(); std::string currentStart = m_Makefile->GetStartDirectory();
currentStart += "/CMakeLists.txt"; currentStart += "/CMakeLists.txt";

16
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -172,7 +172,7 @@ void cmLocalUnixMakefileGenerator3
void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile() void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
{ {
std::string infoFileName = m_Makefile->GetStartOutputDirectory(); std::string infoFileName = m_Makefile->GetStartOutputDirectory();
infoFileName += "/CMakeDirectoryInformation.cmake"; infoFileName += "/CMakeFiles/CMakeDirectoryInformation.cmake";
// Open the output file. // Open the output file.
cmGeneratedFileStream infoFileStream(infoFileName.c_str()); cmGeneratedFileStream infoFileStream(infoFileName.c_str());
@ -1048,7 +1048,7 @@ cmLocalUnixMakefileGenerator3
// the --check-build-system flag. // the --check-build-system flag.
{ {
// Build command to run CMake to check if anything needs regenerating. // Build command to run CMake to check if anything needs regenerating.
std::string cmakefileName = "Makefile.cmake"; std::string cmakefileName = "CMakeFiles/Makefile.cmake";
std::string runRule = std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)"; "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system "; runRule += " --check-build-system ";
@ -1866,6 +1866,10 @@ cmLocalUnixMakefileGenerator3::GetTargetDirectory(cmTarget& target)
{ {
dir += prefix; dir += prefix;
} }
else
{
dir = "CMakeFiles/";
}
dir += target.GetName(); dir += target.GetName();
dir += ".dir"; dir += ".dir";
return dir; return dir;
@ -2579,7 +2583,7 @@ cmLocalUnixMakefileGenerator3
bool haveDirectoryInfo = false; bool haveDirectoryInfo = false;
std::string dirInfoFile = args[4]; std::string dirInfoFile = args[4];
dirInfoFile += "/CMakeDirectoryInformation.cmake"; dirInfoFile += "/CMakeFiles/CMakeDirectoryInformation.cmake";
if(mf->ReadListFile(0, dirInfoFile.c_str()) && if(mf->ReadListFile(0, dirInfoFile.c_str()) &&
!cmSystemTools::GetErrorOccuredFlag()) !cmSystemTools::GetErrorOccuredFlag())
{ {
@ -2754,7 +2758,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
std::string dir = m_Makefile->GetStartOutputDirectory(); std::string dir = m_Makefile->GetStartOutputDirectory();
dir += "/directorystart"; dir += "/directorystart";
dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE); dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE);
this->CreateJumpCommand(commands,"Makefile2",dir); this->CreateJumpCommand(commands,"CMakeFiles/Makefile2",dir);
this->WriteMakeRule(ruleFileStream, "The main all target", "all", depends, commands); this->WriteMakeRule(ruleFileStream, "The main all target", "all", depends, commands);
// Write the clean rule. // Write the clean rule.
@ -2762,7 +2766,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
dir += "/clean"; dir += "/clean";
dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE); dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE);
commands.clear(); commands.clear();
this->CreateJumpCommand(commands,"Makefile2",dir); this->CreateJumpCommand(commands,"CMakeFiles/Makefile2",dir);
this->WriteMakeRule(ruleFileStream, "The main clean target", "clean", depends, commands); this->WriteMakeRule(ruleFileStream, "The main clean target", "clean", depends, commands);
// write our targets, and while doing it collect up the object // write our targets, and while doing it collect up the object
@ -2819,7 +2823,7 @@ void cmLocalUnixMakefileGenerator3
commands.clear(); commands.clear();
depends.clear(); depends.clear();
this->CreateJumpCommand(commands,"Makefile2",localName); this->CreateJumpCommand(commands,"CMakeFiles/Makefile2",localName);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.", this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
localName.c_str(), depends, commands); localName.c_str(), depends, commands);

2
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -1432,7 +1432,7 @@ std::string cmLocalVisualStudio7Generator::GetTargetDirectory(cmTarget& target)
// Put a prefix on the name if one is given by the CMake code. // Put a prefix on the name if one is given by the CMake code.
if(const char* prefix = m_Makefile->GetDefinition("CMAKE_TARGET_DIR_PREFIX")) if(const char* prefix = m_Makefile->GetDefinition("CMAKE_TARGET_DIR_PREFIX"))
{ {
dir += prefix; dir = prefix;
} }
dir += target.GetName(); dir += target.GetName();
dir += ".dir"; dir += ".dir";

2
Tests/MakeClean/ToClean/CMakeLists.txt
View File

@ -6,7 +6,7 @@ ADD_EXECUTABLE(toclean toclean.cxx)
# List some build-time-generated files. # List some build-time-generated files.
GET_TARGET_PROPERTY(TOCLEAN_FILES toclean LOCATION) GET_TARGET_PROPERTY(TOCLEAN_FILES toclean LOCATION)
SET(TOCLEAN_FILES ${TOCLEAN_FILES} SET(TOCLEAN_FILES ${TOCLEAN_FILES}
"${ToClean_BINARY_DIR}/toclean.dir/toclean${CMAKE_CXX_OUTPUT_EXTENSION}") "${ToClean_BINARY_DIR}/CMakeFiles/toclean.dir/toclean${CMAKE_CXX_OUTPUT_EXTENSION}")
# Create a file that must be registered for cleaning. # Create a file that must be registered for cleaning.
FILE(WRITE "${ToClean_BINARY_DIR}/Registered.txt" FILE(WRITE "${ToClean_BINARY_DIR}/Registered.txt"

8
Utilities/cmcurl/CMakeLists.txt
View File

@ -376,7 +376,7 @@ MACRO(CURL_INTERNAL_TEST CURL_TEST)
ELSE(${CURL_TEST}) ELSE(${CURL_TEST})
MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed") MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}") SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeError.log FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Performing Curl Test ${CURL_TEST} failed with the following output:\n" "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
"${OUTPUT}\n") "${OUTPUT}\n")
ENDIF(${CURL_TEST}) ENDIF(${CURL_TEST})
@ -404,14 +404,14 @@ MACRO(CURL_INTERNAL_TEST_RUN CURL_TEST)
ELSE(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST}) ELSE(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed") MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}") SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
FILE(APPEND "${CMAKE_BINARY_DIR}/CMakeError.log" FILE(APPEND "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log"
"Performing Curl Test ${CURL_TEST} failed with the following output:\n" "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
"${OUTPUT}") "${OUTPUT}")
IF(${CURL_TEST}_COMPILE) IF(${CURL_TEST}_COMPILE)
FILE(APPEND "${CMAKE_BINARY_DIR}/CMakeError.log" FILE(APPEND "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log"
"There was a running problem of this test\n") "There was a running problem of this test\n")
ENDIF(${CURL_TEST}_COMPILE) ENDIF(${CURL_TEST}_COMPILE)
FILE(APPEND "${CMAKE_BINARY_DIR}/CMakeError.log" FILE(APPEND "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log"
"\n\n") "\n\n")
ENDIF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST}) ENDIF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
ENDIF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$") ENDIF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")

4
Utilities/cmxmlrpc/CMake/TryCompileFromSource.cmake
View File

@ -28,14 +28,14 @@ MACRO(TRY_COMPILE_FROM_SOURCE SOURCE VAR)
IF(${VAR}) IF(${VAR})
SET(${VAR} 1 CACHE INTERNAL "Test ${FUNCTION}") SET(${VAR} 1 CACHE INTERNAL "Test ${FUNCTION}")
MESSAGE(STATUS "Performing Test ${VAR} - Success") MESSAGE(STATUS "Performing Test ${VAR} - Success")
WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeOutput.log WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log
"Performing C SOURCE FILE Test ${VAR} succeded with the following output:\n" "Performing C SOURCE FILE Test ${VAR} succeded with the following output:\n"
"${OUTPUT}\n" "${OUTPUT}\n"
"Source file was:\n${src}\n" APPEND) "Source file was:\n${src}\n" APPEND)
ELSE(${VAR}) ELSE(${VAR})
MESSAGE(STATUS "Performing Test ${VAR} - Failed") MESSAGE(STATUS "Performing Test ${VAR} - Failed")
SET(${VAR} "" CACHE INTERNAL "Test ${FUNCTION}") SET(${VAR} "" CACHE INTERNAL "Test ${FUNCTION}")
WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeError.log WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
"Performing C SOURCE FILE Test ${VAR} failed with the following output:\n" "Performing C SOURCE FILE Test ${VAR} failed with the following output:\n"
"${OUTPUT}\n" "${OUTPUT}\n"
"Source file was:\n${src}\n" APPEND) "Source file was:\n${src}\n" APPEND)