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

BUG: Search for the compiler only once and store a full path to it in the cache. This avoids problems with the case of locations in the PATH variable on Windows that change the compiler name when CMake is re-run. CMakeFiles/CMake*Compiler.cmake files should hold the full path to the compiler always.

Browse Source
This commit is contained in:
Brad King 2006-08-29 13:59:15 -04:00
parent bdb530191d
commit 7001a88a74
4 changed files with 49 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Modules/CMakeDetermineCCompiler.cmake
View File

@ -28,17 +28,18 @@ IF(NOT CMAKE_C_COMPILER)
ENDIF(NOT CMAKE_C_COMPILER_INIT) ENDIF(NOT CMAKE_C_COMPILER_INIT)
ENDIF(CMAKE_GENERATOR_CC) ENDIF(CMAKE_GENERATOR_CC)
# if no compiler has been specified yet, then look for one # finally list compilers to try
IF(NOT CMAKE_C_COMPILER_INIT) IF(CMAKE_C_COMPILER_INIT)
# if not in the envionment then search for the compiler in the path SET(CMAKE_C_COMPILER_LIST ${CMAKE_C_COMPILER_INIT})
SET(CMAKE_C_COMPILER_LIST gcc cc cl bcc xlc) ELSE(CMAKE_C_COMPILER_INIT)
FIND_PROGRAM(CMAKE_C_COMPILER_FULLPATH NAMES ${CMAKE_C_COMPILER_LIST} ) SET(CMAKE_C_COMPILER_LIST gcc cc cl bcc xlc)
GET_FILENAME_COMPONENT(CMAKE_C_COMPILER_INIT ENDIF(CMAKE_C_COMPILER_INIT)
${CMAKE_C_COMPILER_FULLPATH} NAME)
SET(CMAKE_C_COMPILER_FULLPATH "${CMAKE_C_COMPILER_FULLPATH}" CACHE INTERNAL "full path to the compiler cmake found")
ENDIF(NOT CMAKE_C_COMPILER_INIT)
SET(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_INIT} CACHE STRING "C compiler") # Find the compiler.
FIND_PROGRAM(CMAKE_C_COMPILER NAMES ${CMAKE_C_COMPILER_LIST} DOC "C compiler")
IF(CMAKE_C_COMPILER_INIT AND NOT CMAKE_C_COMPILER)
SET(CMAKE_C_COMPILER "${CMAKE_C_COMPILER_INIT}" CACHE FILEPATH "C compiler" FORCE)
ENDIF(CMAKE_C_COMPILER_INIT AND NOT CMAKE_C_COMPILER)
ENDIF(NOT CMAKE_C_COMPILER) ENDIF(NOT CMAKE_C_COMPILER)
MARK_AS_ADVANCED(CMAKE_C_COMPILER) MARK_AS_ADVANCED(CMAKE_C_COMPILER)
GET_FILENAME_COMPONENT(COMPILER_LOCATION "${CMAKE_C_COMPILER}" GET_FILENAME_COMPONENT(COMPILER_LOCATION "${CMAKE_C_COMPILER}"

21
Modules/CMakeDetermineCXXCompiler.cmake
View File

@ -28,17 +28,18 @@ IF(NOT CMAKE_CXX_COMPILER)
ENDIF(NOT CMAKE_CXX_COMPILER_INIT) ENDIF(NOT CMAKE_CXX_COMPILER_INIT)
ENDIF(CMAKE_GENERATOR_CXX) ENDIF(CMAKE_GENERATOR_CXX)
# if no compiler has been found yet, then try to find one # finally list compilers to try
IF(NOT CMAKE_CXX_COMPILER_INIT) IF(CMAKE_CXX_COMPILER_INIT)
# if not in the envionment then search for the compiler in the path SET(CMAKE_CXX_COMPILER_LIST ${CMAKE_CXX_COMPILER_INIT})
ELSE(CMAKE_CXX_COMPILER_INIT)
SET(CMAKE_CXX_COMPILER_LIST c++ g++ CC aCC cl bcc xlC) SET(CMAKE_CXX_COMPILER_LIST c++ g++ CC aCC cl bcc xlC)
FIND_PROGRAM(CMAKE_CXX_COMPILER_FULLPATH NAMES ${CMAKE_CXX_COMPILER_LIST}) ENDIF(CMAKE_CXX_COMPILER_INIT)
GET_FILENAME_COMPONENT(CMAKE_CXX_COMPILER_INIT
${CMAKE_CXX_COMPILER_FULLPATH} NAME) # Find the compiler.
SET(CMAKE_CXX_COMPILER_FULLPATH "${CMAKE_CXX_COMPILER_FULLPATH}" CACHE INTERNAL "full path to the compiler cmake found") FIND_PROGRAM(CMAKE_CXX_COMPILER NAMES ${CMAKE_CXX_COMPILER_LIST} DOC "C++ compiler")
ENDIF(NOT CMAKE_CXX_COMPILER_INIT) IF(CMAKE_CXX_COMPILER_INIT AND NOT CMAKE_CXX_COMPILER)
SET(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER_INIT} SET(CMAKE_CXX_COMPILER "${CMAKE_CXX_COMPILER_INIT}" CACHE FILEPATH "C++ compiler" FORCE)
CACHE STRING "C++ compiler") ENDIF(CMAKE_CXX_COMPILER_INIT AND NOT CMAKE_CXX_COMPILER)
ENDIF(NOT CMAKE_CXX_COMPILER) ENDIF(NOT CMAKE_CXX_COMPILER)
MARK_AS_ADVANCED(CMAKE_CXX_COMPILER) MARK_AS_ADVANCED(CMAKE_CXX_COMPILER)

29
Modules/CMakeDetermineFortranCompiler.cmake
View File

@ -24,11 +24,11 @@ IF(NOT CMAKE_Fortran_COMPILER)
SET(CMAKE_Fortran_COMPILER_INIT ${CMAKE_GENERATOR_FC}) SET(CMAKE_Fortran_COMPILER_INIT ${CMAKE_GENERATOR_FC})
ENDIF(NOT CMAKE_Fortran_COMPILER_INIT) ENDIF(NOT CMAKE_Fortran_COMPILER_INIT)
ENDIF(CMAKE_GENERATOR_FC) ENDIF(CMAKE_GENERATOR_FC)
# finally list compilers to try
# if no compiler has been specified yet, then look for one IF(CMAKE_Fortran_COMPILER_INIT)
IF(NOT CMAKE_Fortran_COMPILER_INIT) SET(CMAKE_Fortran_COMPILER_LIST ${CMAKE_Fortran_COMPILER_INIT})
# if not in the envionment then search for the compiler in the path ELSE(CMAKE_Fortran_COMPILER_INIT)
# Known compilers: # Known compilers:
# f77/f90/f95: generic compiler names # f77/f90/f95: generic compiler names
# g77: GNU Fortran 77 compiler # g77: GNU Fortran 77 compiler
@ -51,16 +51,17 @@ IF(NOT CMAKE_Fortran_COMPILER)
# NOTE for testing purposes this list is DUPLICATED in # NOTE for testing purposes this list is DUPLICATED in
# CMake/Source/CMakeLists.txt, IF YOU CHANGE THIS LIST, # CMake/Source/CMakeLists.txt, IF YOU CHANGE THIS LIST,
# PLEASE UPDATE THAT FILE AS WELL! # PLEASE UPDATE THAT FILE AS WELL!
SET(CMAKE_Fortran_COMPILER_LIST ifort ifc efc f95 pgf95 SET(CMAKE_Fortran_COMPILER_LIST
lf95 xlf95 fort gfortran f90 pgf90 xlf90 epcf90 fort77 frt pgf77 xlf fl32 af77 g77 f77 ) ifort ifc efc f95 pgf95 lf95 xlf95 fort gfortran f90
FIND_PROGRAM(CMAKE_Fortran_COMPILER_FULLPATH NAMES ${CMAKE_Fortran_COMPILER_LIST} ) pgf90 xlf90 epcf90 fort77 frt pgf77 xlf fl32 af77 g77 f77
GET_FILENAME_COMPONENT(CMAKE_Fortran_COMPILER_INIT )
${CMAKE_Fortran_COMPILER_FULLPATH} NAME) ENDIF(CMAKE_Fortran_COMPILER_INIT)
SET(CMAKE_Fortran_COMPILER_FULLPATH "${CMAKE_Fortran_COMPILER_FULLPATH}"
CACHE INTERNAL "full path to the compiler cmake found")
ENDIF(NOT CMAKE_Fortran_COMPILER_INIT)
SET(CMAKE_Fortran_COMPILER ${CMAKE_Fortran_COMPILER_INIT} CACHE STRING "Fortran compiler") # Find the compiler.
FIND_PROGRAM(CMAKE_Fortran_COMPILER NAMES ${CMAKE_Fortran_COMPILER_LIST} DOC "Fortran compiler")
IF(CMAKE_Fortran_COMPILER_INIT AND NOT CMAKE_Fortran_COMPILER)
SET(CMAKE_Fortran_COMPILER "${CMAKE_Fortran_COMPILER_INIT}" CACHE FILEPATH "Fortran compiler" FORCE)
ENDIF(CMAKE_Fortran_COMPILER_INIT AND NOT CMAKE_Fortran_COMPILER)
ENDIF(NOT CMAKE_Fortran_COMPILER) ENDIF(NOT CMAKE_Fortran_COMPILER)
MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER) MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER)

24
Modules/CMakeDetermineRCCompiler.cmake
View File

@ -24,19 +24,19 @@ IF(NOT CMAKE_RC_COMPILER)
SET(CMAKE_RC_COMPILER_INIT ${CMAKE_GENERATOR_RC}) SET(CMAKE_RC_COMPILER_INIT ${CMAKE_GENERATOR_RC})
ENDIF(NOT CMAKE_RC_COMPILER_INIT) ENDIF(NOT CMAKE_RC_COMPILER_INIT)
ENDIF(CMAKE_GENERATOR_RC) ENDIF(CMAKE_GENERATOR_RC)
# if no compiler has been specified yet, then look for one
IF(NOT CMAKE_RC_COMPILER_INIT)
SET(CMAKE_RC_COMPILER_LIST rc)
FIND_PROGRAM(CMAKE_RC_COMPILER_FULLPATH NAMES ${CMAKE_RC_COMPILER_LIST} )
GET_FILENAME_COMPONENT(CMAKE_RC_COMPILER_INIT
${CMAKE_RC_COMPILER_FULLPATH} NAME)
SET(CMAKE_RC_COMPILER_FULLPATH "${CMAKE_RC_COMPILER_FULLPATH}"
CACHE INTERNAL "full path to the compiler cmake found")
ENDIF(NOT CMAKE_RC_COMPILER_INIT)
SET(CMAKE_RC_COMPILER ${CMAKE_RC_COMPILER_INIT} CACHE STRING "RC compiler") # finally list compilers to try
IF(CMAKE_RC_COMPILER_INIT)
SET(CMAKE_RC_COMPILER_LIST ${CMAKE_RC_COMPILER_INIT})
ELSE(CMAKE_RC_COMPILER_INIT)
SET(CMAKE_RC_COMPILER_LIST c++ g++ CC aCC cl bcc xlC)
ENDIF(CMAKE_RC_COMPILER_INIT)
# Find the compiler.
FIND_PROGRAM(CMAKE_RC_COMPILER NAMES ${CMAKE_RC_COMPILER_LIST} DOC "RC compiler")
IF(CMAKE_RC_COMPILER_INIT AND NOT CMAKE_RC_COMPILER)
SET(CMAKE_RC_COMPILER "${CMAKE_RC_COMPILER_INIT}" CACHE FILEPATH "RC compiler" FORCE)
ENDIF(CMAKE_RC_COMPILER_INIT AND NOT CMAKE_RC_COMPILER)
ENDIF(NOT CMAKE_RC_COMPILER) ENDIF(NOT CMAKE_RC_COMPILER)
MARK_AS_ADVANCED(CMAKE_RC_COMPILER) MARK_AS_ADVANCED(CMAKE_RC_COMPILER)