[cmake-commits] alex committed CMakeCCompiler.cmake.in 1.14 1.15
CMakeCInformation.cmake 1.11 1.12 CMakeCXXCompiler.cmake.in
1.13 1.14 CMakeCXXInformation.cmake 1.14 1.15
CMakeDetermineCCompiler.cmake 1.40 1.41
CMakeDetermineCXXCompiler.cmake 1.35 1.36
CMakeDetermineFortranCompiler.cmake 1.15 1.16
CMakeDetermineSystem.cmake 1.18 1.19 CMakeFindBinUtils.cmake
1.1 1.2 CMakeLists.txt 1.9 1.10 CMakeSystem.cmake.in 1.4 1.5
CMakeSystemSpecificInformation.cmake 1.36 1.37
CMakeTestCCompiler.cmake 1.20 1.21 CTest.cmake 1.8 1.9
CheckTypeSize.cmake 1.23 1.24
cmake-commits at cmake.org
cmake-commits at cmake.org
Thu May 17 13:20:45 EDT 2007
Update of /cvsroot/CMake/CMake/Modules
In directory public:/mounts/ram/cvs-serv15479/Modules
Modified Files:
CMakeCCompiler.cmake.in CMakeCInformation.cmake
CMakeCXXCompiler.cmake.in CMakeCXXInformation.cmake
CMakeDetermineCCompiler.cmake CMakeDetermineCXXCompiler.cmake
CMakeDetermineFortranCompiler.cmake CMakeDetermineSystem.cmake
CMakeLists.txt CMakeSystem.cmake.in
CMakeSystemSpecificInformation.cmake CMakeTestCCompiler.cmake
CTest.cmake CheckTypeSize.cmake
Added Files:
CMakeFindBinUtils.cmake
Log Message:
ENH: merge CMake-CrossCompileBasic to HEAD
-add a RESULT_VARIABLE to INCLUDE()
-add CMAKE_TOOLCHAIN_FILE for specifiying your (potentially crosscompiling) toolchain
-have TRY_RUN() complain if you try to use it in crosscompiling mode (which were compiled but cannot run on this system)
-use CMAKE_EXECUTABLE_SUFFIX in TRY_RUN(), probably TRY_RUN won't be able to
run the executables if they have a different suffix because they are
probably crosscompiled, but nevertheless it should be able to find them
-make several cmake variables presettable by the user: CMAKE_C/CXX_COMPILER, CMAKE_C/CXX_OUTPUT_EXTENSION, CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_INFO_FILE
-support prefix for GNU toolchains (arm-elf-gcc, arm-elf-ar, arm-elf-strip etc.)
-move ranlib on OSX from the file command to a command in executed in cmake_install.cmake
-add support for stripping during install in cmake_install.cmake
-split out cl.cmake from Windows-cl.cmake, first (very incomplete) step to support MS crosscompiling tools
-remove stdio.h from the simple C program which checks if the compiler works, since this may not exist for some embedded platforms
-create a new CMakeFindBinUtils.cmake which collects the search fro ar, ranlib, strip, ld, link, install_name_tool and other tools like these
-add support for CMAKE_FIND_ROOT_PATH for all FIND_XXX commands, which is a
list of directories which will be prepended to all search directories, right
now as a cmake variable, turning it into a global cmake property may need
some more work
-remove cmTestTestHandler::TryExecutable(), it's unused
-split cmFileCommand::HandleInstall() into slightly smaller functions
Alex
Index: CMakeDetermineSystem.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeDetermineSystem.cmake,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -d -r1.18 -r1.19
--- CMakeDetermineSystem.cmake 21 Feb 2007 15:29:36 -0000 1.18
+++ CMakeDetermineSystem.cmake 17 May 2007 17:20:43 -0000 1.19
@@ -25,37 +25,60 @@
# Ultrix ULTRIX
# cygwin CYGWIN_NT-5.1
# MacOSX Darwin
-IF(UNIX)
- FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
- IF(CMAKE_UNAME)
- EXEC_PROGRAM(uname ARGS -s OUTPUT_VARIABLE CMAKE_SYSTEM_NAME)
- EXEC_PROGRAM(uname ARGS -r OUTPUT_VARIABLE CMAKE_SYSTEM_VERSION)
- IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
- EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR
- RETURN_VALUE val)
- ELSE(CMAKE_SYSTEM_NAME MATCHES "Linux")
- EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR
- RETURN_VALUE val)
- IF("${val}" GREATER 0)
+
+IF(CMAKE_TOOLCHAIN_FILE)
+ # at first try to load it as path relative to the directory from which cmake has been run
+ INCLUDE("${CMAKE_BINARY_DIR}/${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE)
+ IF(NOT _INCLUDED_TOOLCHAIN_FILE)
+ # if the file isn't found there, check the default locations
+ INCLUDE("${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE)
+ ENDIF(NOT _INCLUDED_TOOLCHAIN_FILE)
+
+ IF(_INCLUDED_TOOLCHAIN_FILE)
+ SET(CMAKE_TOOLCHAIN_FILE "${_INCLUDED_TOOLCHAIN_FILE}")
+ ELSE(_INCLUDED_TOOLCHAIN_FILE)
+ MESSAGE(FATAL_ERROR "Could not find toolchain file: ${CMAKE_TOOLCHAIN_FILE}")
+ ENDIF(_INCLUDED_TOOLCHAIN_FILE)
+
+ IF(NOT DEFINED CMAKE_CROSSCOMPILING)
+ SET(CMAKE_CROSSCOMPILING TRUE)
+ ENDIF(NOT DEFINED CMAKE_CROSSCOMPILING)
+ENDIF(CMAKE_TOOLCHAIN_FILE)
+
+IF(NOT CMAKE_SYSTEM_NAME)
+ IF(UNIX)
+ FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
+ IF(CMAKE_UNAME)
+ EXEC_PROGRAM(uname ARGS -s OUTPUT_VARIABLE CMAKE_SYSTEM_NAME)
+ EXEC_PROGRAM(uname ARGS -r OUTPUT_VARIABLE CMAKE_SYSTEM_VERSION)
+ IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR
RETURN_VALUE val)
+ ELSE(CMAKE_SYSTEM_NAME MATCHES "Linux")
+ EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR
+ RETURN_VALUE val)
+ IF("${val}" GREATER 0)
+ EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR
+ RETURN_VALUE val)
+ ENDIF("${val}" GREATER 0)
+ ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
+ # check the return of the last uname -m or -p
+ IF("${val}" GREATER 0)
+ SET(CMAKE_SYSTEM_PROCESSOR "unknown")
ENDIF("${val}" GREATER 0)
- ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
- # check the return of the last uname -m or -p
- IF("${val}" GREATER 0)
- SET(CMAKE_SYSTEM_PROCESSOR "unknown")
- ENDIF("${val}" GREATER 0)
- SET(CMAKE_UNAME ${CMAKE_UNAME} CACHE INTERNAL "uname command")
- # processor may have double quote in the name, and that needs to be removed
- STRING(REGEX REPLACE "\"" "" CMAKE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
- STRING(REGEX REPLACE "/" "_" CMAKE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
- ENDIF(CMAKE_UNAME)
-ELSE(UNIX)
- IF(WIN32)
- SET (CMAKE_SYSTEM_NAME "Windows")
- SET (CMAKE_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
- ENDIF(WIN32)
-ENDIF(UNIX)
+ SET(CMAKE_UNAME ${CMAKE_UNAME} CACHE INTERNAL "uname command")
+ # processor may have double quote in the name, and that needs to be removed
+ STRING(REGEX REPLACE "\"" "" CMAKE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
+ STRING(REGEX REPLACE "/" "_" CMAKE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
+ ENDIF(CMAKE_UNAME)
+ ELSE(UNIX)
+ IF(WIN32)
+ SET (CMAKE_SYSTEM_NAME "Windows")
+ SET (CMAKE_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
+ ENDIF(WIN32)
+ ENDIF(UNIX)
+ENDIF(NOT CMAKE_SYSTEM_NAME)
+
IF(NOT CMAKE_SYSTEM_NAME)
SET(CMAKE_SYSTEM_NAME "UnknownOS")
Index: CheckTypeSize.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CheckTypeSize.cmake,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- CheckTypeSize.cmake 14 Jun 2006 16:28:29 -0000 1.23
+++ CheckTypeSize.cmake 17 May 2007 17:20:43 -0000 1.24
@@ -13,6 +13,7 @@
# CMAKE_REQUIRED_LIBRARIES = list of libraries to link
MACRO(CHECK_TYPE_SIZE TYPE VARIABLE)
+ IF(NOT DEFINED ${VARIABLE})
SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS 1)
IF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")
SET(CHECK_TYPE_SIZE_TYPE "${TYPE}")
@@ -65,4 +66,5 @@
ENDIF(HAVE_${VARIABLE})
ENDIF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")
SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS )
+ ENDIF(NOT DEFINED ${VARIABLE})
ENDMACRO(CHECK_TYPE_SIZE)
Index: CMakeDetermineCXXCompiler.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeDetermineCXXCompiler.cmake,v
retrieving revision 1.35
retrieving revision 1.36
diff -u -d -r1.35 -r1.36
--- CMakeDetermineCXXCompiler.cmake 3 May 2007 12:24:32 -0000 1.35
+++ CMakeDetermineCXXCompiler.cmake 17 May 2007 17:20:43 -0000 1.36
@@ -5,13 +5,21 @@
# use environment variable CXX first if defined by user, next use
# the cmake variable CMAKE_GENERATOR_CXX which can be defined by a generator
# as a default compiler
+# If the internal cmake variable _CMAKE_TOOLCHAIN_PREFIX is set, this is used
+# as prefix for the tools (e.g. arm-elf-g++, arm-elf-ar etc.)
+# It also tries to detect a MS crosscompiler and find out its
+# suffix (clarm.exe), which will be stored in _CMAKE_TOOLCHAIN_SUFFIX and
+# reused for the C compiler.
#
# Sets the following variables:
# CMAKE_CXX_COMPILER
# CMAKE_COMPILER_IS_GNUCXX
# CMAKE_AR
# CMAKE_RANLIB
-
+#
+# If not already set before, it also sets
+# _CMAKE_TOOLCHAIN_PREFIX
+# _CMAKE_TOOLCHAIN_SUFFIX
IF(NOT CMAKE_CXX_COMPILER)
SET(CMAKE_CXX_COMPILER_INIT NOTFOUND)
@@ -22,10 +30,9 @@
IF(CMAKE_CXX_FLAGS_ENV_INIT)
SET(CMAKE_CXX_COMPILER_ARG1 "${CMAKE_CXX_FLAGS_ENV_INIT}" CACHE STRING "First argument to CXX compiler")
ENDIF(CMAKE_CXX_FLAGS_ENV_INIT)
- IF(EXISTS ${CMAKE_CXX_COMPILER_INIT})
- ELSE(EXISTS ${CMAKE_CXX_COMPILER_INIT})
+ IF(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable CXX:\n$ENV{CXX}.\n${CMAKE_CXX_COMPILER_INIT}")
- ENDIF(EXISTS ${CMAKE_CXX_COMPILER_INIT})
+ ENDIF(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
ENDIF($ENV{CXX} MATCHES ".+")
# next prefer the generator specified compiler
@@ -39,27 +46,65 @@
IF(CMAKE_CXX_COMPILER_INIT)
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 ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ CC aCC cl${_CMAKE_TOOLCHAIN_SUFFIX} bcc xlC)
ENDIF(CMAKE_CXX_COMPILER_INIT)
# Find the compiler.
+ IF (_CMAKE_USER_C_COMPILER_PATH)
+ FIND_PROGRAM(CMAKE_CXX_COMPILER NAMES ${CMAKE_CXX_COMPILER_LIST} PATHS ${_CMAKE_USER_C_COMPILER_PATH} DOC "C++ compiler" NO_DEFAULT_PATH)
+ ENDIF (_CMAKE_USER_C_COMPILER_PATH)
FIND_PROGRAM(CMAKE_CXX_COMPILER NAMES ${CMAKE_CXX_COMPILER_LIST} DOC "C++ compiler")
+
IF(CMAKE_CXX_COMPILER_INIT AND NOT CMAKE_CXX_COMPILER)
SET(CMAKE_CXX_COMPILER "${CMAKE_CXX_COMPILER_INIT}" CACHE FILEPATH "C++ compiler" FORCE)
ENDIF(CMAKE_CXX_COMPILER_INIT AND NOT CMAKE_CXX_COMPILER)
+ELSE(NOT CMAKE_CXX_COMPILER)
+
+# if a compiler was specified by the user but without path,
+# now try to find it with the full path and force it into the cache
+ GET_FILENAME_COMPONENT(_CMAKE_USER_CXX_COMPILER_PATH "${CMAKE_CXX_COMPILER}" PATH)
+ IF(NOT _CMAKE_USER_CXX_COMPILER_PATH)
+ FIND_PROGRAM(CMAKE_CXX_COMPILER_WITH_PATH NAMES ${CMAKE_CXX_COMPILER})
+ MARK_AS_ADVANCED(CMAKE_CXX_COMPILER_WITH_PATH)
+ SET(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER_WITH_PATH} CACHE FILEPATH "CXX compiler" FORCE)
+ ENDIF(NOT _CMAKE_USER_CXX_COMPILER_PATH)
ENDIF(NOT CMAKE_CXX_COMPILER)
MARK_AS_ADVANCED(CMAKE_CXX_COMPILER)
-GET_FILENAME_COMPONENT(COMPILER_LOCATION "${CMAKE_CXX_COMPILER}" PATH)
+IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+ GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_CXX_COMPILER}" PATH)
+ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
-FIND_PROGRAM(CMAKE_AR NAMES ar PATHS ${COMPILER_LOCATION})
-MARK_AS_ADVANCED(CMAKE_AR)
+# if we have a g++ cross compiler, they have usually some prefix, like
+# e.g. powerpc-linux-g++, arm-elf-g++ or i586-mingw32msvc-g++
+# the other tools of the toolchain usually have the same prefix
+IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+ GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_CXX_COMPILER}" NAME_WE)
+ IF (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+")
+ STRING(REGEX REPLACE "^(.+-)[gc]\\+\\+" "\\1" _CMAKE_TOOLCHAIN_PREFIX "${COMPILER_BASENAME}")
+ ENDIF (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+")
+ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+
+# if we have a MS cross compiler, it usually has a suffix, like
+# e.g. clarm.exe or clmips.exe. Use this suffix for the CXX compiler too.
+IF (NOT _CMAKE_TOOLCHAIN_SUFFIX)
+ GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_CXX_COMPILER}" NAME)
+ IF (COMPILER_BASENAME MATCHES "^cl(.+)\\.exe$")
+ STRING(REGEX REPLACE "^cl(.+)\\.exe$" "\\1" _CMAKE_TOOLCHAIN_SUFFIX "${COMPILER_BASENAME}")
+ ENDIF (COMPILER_BASENAME MATCHES "^cl(.+)\\.exe$")
+ENDIF (NOT _CMAKE_TOOLCHAIN_SUFFIX)
+
+
+# some exotic compilers have different extensions (e.g. sdcc uses .rel)
+# so don't overwrite it if it has been already defined by the user
+IF(NOT CMAKE_CXX_OUTPUT_EXTENSION)
+ IF(UNIX)
+ SET(CMAKE_CXX_OUTPUT_EXTENSION .o)
+ ELSE(UNIX)
+ SET(CMAKE_CXX_OUTPUT_EXTENSION .obj)
+ ENDIF(UNIX)
+ENDIF(NOT CMAKE_CXX_OUTPUT_EXTENSION)
-FIND_PROGRAM(CMAKE_RANLIB NAMES ranlib)
-IF(NOT CMAKE_RANLIB)
- SET(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
-ENDIF(NOT CMAKE_RANLIB)
-MARK_AS_ADVANCED(CMAKE_RANLIB)
# This block was used before the compiler was identified by building a
# source file. Unless g++ crashes when building a small C++
@@ -101,6 +146,8 @@
ENDIF("${CMAKE_CXX_PLATFORM_ID}" MATCHES "MinGW")
ENDIF(NOT CMAKE_CXX_COMPILER_ID_RUN)
+INCLUDE(CMakeFindBinUtils)
+
# configure all variables set in this file
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake IMMEDIATE)
Index: CMakeCInformation.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeCInformation.cmake,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- CMakeCInformation.cmake 3 May 2007 12:24:32 -0000 1.11
+++ CMakeCInformation.cmake 17 May 2007 17:20:43 -0000 1.12
@@ -3,18 +3,21 @@
# It also loads the available platform file for the system-compiler
# if it exists.
-GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_C_COMPILER} NAME_WE)
-IF(CMAKE_COMPILER_IS_GNUCC)
- SET(CMAKE_BASE_NAME gcc)
-ENDIF(CMAKE_COMPILER_IS_GNUCC)
-IF(CMAKE_C_COMPILER_ID)
- IF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C.cmake)
- SET(CMAKE_BASE_NAME ${CMAKE_C_COMPILER_ID}-C)
- ENDIF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C.cmake)
-ENDIF(CMAKE_C_COMPILER_ID)
-SET(CMAKE_SYSTEM_AND_C_COMPILER_INFO_FILE
- ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
-INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
+IF(NOT CMAKE_SYSTEM_AND_C_COMPILER_INFO_FILE)
+ GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_C_COMPILER} NAME_WE)
+ IF(CMAKE_COMPILER_IS_GNUCC)
+ SET(CMAKE_BASE_NAME gcc)
+ ENDIF(CMAKE_COMPILER_IS_GNUCC)
+ IF(CMAKE_C_COMPILER_ID)
+ IF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C.cmake)
+ SET(CMAKE_BASE_NAME ${CMAKE_C_COMPILER_ID}-C)
+ ENDIF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C.cmake)
+ ENDIF(CMAKE_C_COMPILER_ID)
+ SET(CMAKE_SYSTEM_AND_C_COMPILER_INFO_FILE
+ ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
+ENDIF(NOT CMAKE_SYSTEM_AND_C_COMPILER_INFO_FILE)
+
+INCLUDE(${CMAKE_SYSTEM_AND_C_COMPILER_INFO_FILE} OPTIONAL)
# This should be included before the _INIT variables are
# used to initialize the cache. Since the rule variables
Index: CMakeTestCCompiler.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeTestCCompiler.cmake,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- CMakeTestCCompiler.cmake 26 Jul 2006 18:10:14 -0000 1.20
+++ CMakeTestCCompiler.cmake 17 May 2007 17:20:43 -0000 1.21
@@ -10,7 +10,6 @@
"#ifdef __cplusplus\n"
"# error \"The CMAKE_C_COMPILER is set to a C++ compiler\"\n"
"#endif\n"
- "#include <stdio.h>\n"
"#if defined(__CLASSIC_C__)\n"
"int main(argc, argv)\n"
" int argc;\n"
@@ -18,7 +17,7 @@
"#else\n"
"int main(int argc, char* argv[])\n"
"#endif\n"
- "{ printf(\"%s\\n\", argv[0]); return argc-1;}\n")
+ "{ return argc-1;}\n")
TRY_COMPILE(CMAKE_C_COMPILER_WORKS ${CMAKE_BINARY_DIR}
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler.c
OUTPUT_VARIABLE OUTPUT)
Index: CMakeCXXCompiler.cmake.in
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeCXXCompiler.cmake.in,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- CMakeCXXCompiler.cmake.in 28 Apr 2007 13:35:01 -0000 1.13
+++ CMakeCXXCompiler.cmake.in 17 May 2007 17:20:43 -0000 1.14
@@ -22,11 +22,8 @@
SET(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;H;o;O;obj;OBJ;def;DEF;rc;RC)
SET(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm)
SET(CMAKE_CXX_LINKER_PREFERENCE Prefered)
-IF(UNIX)
- SET(CMAKE_CXX_OUTPUT_EXTENSION .o)
-ELSE(UNIX)
- SET(CMAKE_CXX_OUTPUT_EXTENSION .obj)
-ENDIF(UNIX)
+SET(CMAKE_CXX_OUTPUT_EXTENSION @CMAKE_CXX_OUTPUT_EXTENSION@)
+
# save the size of void* in case where cache is removed
# and the this file is still around
SET(CMAKE_SIZEOF_VOID_P @CMAKE_SIZEOF_VOID_P@)
Index: CMakeDetermineFortranCompiler.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeDetermineFortranCompiler.cmake,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- CMakeDetermineFortranCompiler.cmake 3 May 2007 12:24:32 -0000 1.15
+++ CMakeDetermineFortranCompiler.cmake 17 May 2007 17:20:43 -0000 1.16
@@ -66,14 +66,6 @@
MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER)
-FIND_PROGRAM(CMAKE_AR NAMES ar )
-
-FIND_PROGRAM(CMAKE_RANLIB NAMES ranlib)
-IF(NOT CMAKE_RANLIB)
- SET(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
-ENDIF(NOT CMAKE_RANLIB)
-MARK_AS_ADVANCED(CMAKE_RANLIB)
-
# Build a small source file to identify the compiler.
IF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
SET(CMAKE_Fortran_COMPILER_ID_RUN 1)
@@ -130,8 +122,9 @@
ENDIF("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "MinGW")
ENDIF(NOT CMAKE_Fortran_COMPILER_ID_RUN)
+INCLUDE(CMakeFindBinUtils)
+
# configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeFortranCompiler.cmake IMMEDIATE)
-MARK_AS_ADVANCED(CMAKE_AR)
SET(CMAKE_Fortran_COMPILER_ENV_VAR "FC")
--- NEW FILE: CMakeFindBinUtils.cmake ---
# search for additional tools required for C/C++ (and other languages ?)
#
# If the internal cmake variable _CMAKE_TOOLCHAIN_PREFIX is set, this is used
# as prefix for the tools (e.g. arm-elf-gcc etc.)
# If the cmake variable _CMAKE_TOOLCHAIN_LOCATION is set, the compiler is
# searched only there. The other tools are at first searched there, then
# also in the default locations.
#
# Sets the following variables:
# CMAKE_AR
# CMAKE_RANLIB
# CMAKE_LINKER
# CMAKE_STRIP
# CMAKE_INSTALL_NAME_TOOL
# on UNIX, cygwin and mingw
IF(UNIX OR CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
FIND_PROGRAM(CMAKE_AR NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar PATHS ${_CMAKE_TOOLCHAIN_LOCATION} NO_DEFAULT_PATH)
FIND_PROGRAM(CMAKE_AR NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar)
FIND_PROGRAM(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib ${_CMAKE_TOOLCHAIN_LOCATION} NO_DEFAULT_PATH)
FIND_PROGRAM(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib)
IF(NOT CMAKE_RANLIB)
SET(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
ENDIF(NOT CMAKE_RANLIB)
FIND_PROGRAM(CMAKE_STRIP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip PATHS ${_CMAKE_TOOLCHAIN_LOCATION} NO_DEFAULT_PATH)
FIND_PROGRAM(CMAKE_STRIP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip)
FIND_PROGRAM(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld PATHS ${_CMAKE_TOOLCHAIN_LOCATION} NO_DEFAULT_PATH)
FIND_PROGRAM(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld)
MARK_AS_ADVANCED(CMAKE_AR CMAKE_RANLIB CMAKE_STRIP CMAKE_LINKER)
ENDIF(UNIX OR CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
IF(APPLE)
FIND_PROGRAM(CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool PATHS ${_CMAKE_TOOLCHAIN_LOCATION} NO_DEFAULT_PATH)
FIND_PROGRAM(CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool)
MARK_AS_ADVANCED(CMAKE_INSTALL_NAME_TOOL)
ENDIF(APPLE)
IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "MSVC" OR "${CMAKE_C_COMPILER_ID}" MATCHES "MSVC")
FIND_PROGRAM(CMAKE_LINKER NAMES link PATHS ${_CMAKE_TOOLCHAIN_LOCATION} NO_DEFAULT_PATH)
FIND_PROGRAM(CMAKE_LINKER NAMES link)
MARK_AS_ADVANCED(CMAKE_LINKER)
ENDIF("${CMAKE_CXX_COMPILER_ID}" MATCHES "MSVC" OR "${CMAKE_C_COMPILER_ID}" MATCHES "MSVC")
# maybe check for more tools ?
Index: CMakeSystemSpecificInformation.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeSystemSpecificInformation.cmake,v
retrieving revision 1.36
retrieving revision 1.37
diff -u -d -r1.36 -r1.37
--- CMakeSystemSpecificInformation.cmake 15 Sep 2006 18:08:36 -0000 1.36
+++ CMakeSystemSpecificInformation.cmake 17 May 2007 17:20:43 -0000 1.37
@@ -7,10 +7,13 @@
INCLUDE(CMakeGenericSystem)
# 2. now include SystemName.cmake file to set the system specific information
-SET(CMAKE_SYSTEM_INFO_FILE ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}.cmake)
-IF(EXISTS ${CMAKE_SYSTEM_INFO_FILE})
- INCLUDE(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
-ELSE(EXISTS ${CMAKE_SYSTEM_INFO_FILE})
+IF(NOT CMAKE_SYSTEM_INFO_FILE)
+ SET(CMAKE_SYSTEM_INFO_FILE Platform/${CMAKE_SYSTEM_NAME})
+ENDIF(NOT CMAKE_SYSTEM_INFO_FILE)
+
+INCLUDE(${CMAKE_SYSTEM_INFO_FILE} OPTIONAL RESULT_VARIABLE _INCLUDED_SYSTEM_INFO_FILE)
+
+IF(NOT _INCLUDED_SYSTEM_INFO_FILE)
MESSAGE("System is unknown to cmake, create:\n${CMAKE_SYSTEM_INFO_FILE}"
" to use this system, please send your config file to "
"cmake at www.cmake.org so it can be added to cmake")
@@ -20,7 +23,7 @@
MESSAGE("You CMakeCache.txt file was copied to CopyOfCMakeCache.txt. "
"Please send that file to cmake at www.cmake.org.")
ENDIF(EXISTS ${CMAKE_BINARY_DIR}/CMakeCache.txt)
-ENDIF(EXISTS ${CMAKE_SYSTEM_INFO_FILE})
+ENDIF(NOT _INCLUDED_SYSTEM_INFO_FILE)
# for most systems a module is the same as a shared library
Index: CMakeLists.txt
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeLists.txt,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- CMakeLists.txt 30 Apr 2007 22:09:04 -0000 1.9
+++ CMakeLists.txt 17 May 2007 17:20:43 -0000 1.10
@@ -1,4 +1,6 @@
# just install the modules
+# new file added, force rerunning cmake
+
SUBDIRS(Platform)
INSTALL_FILES(${CMAKE_DATA_DIR}/Modules .*\\.cmake$)
INSTALL_FILES(${CMAKE_DATA_DIR}/Modules .*\\.cpp$)
Index: CMakeCXXInformation.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeCXXInformation.cmake,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- CMakeCXXInformation.cmake 3 May 2007 12:24:32 -0000 1.14
+++ CMakeCXXInformation.cmake 17 May 2007 17:20:43 -0000 1.15
@@ -3,19 +3,23 @@
# It also loads the available platform file for the system-compiler
# if it exists.
-GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
-# since the gnu compiler has several names force g++
-IF(CMAKE_COMPILER_IS_GNUCXX)
- SET(CMAKE_BASE_NAME g++)
-ENDIF(CMAKE_COMPILER_IS_GNUCXX)
-IF(CMAKE_CXX_COMPILER_ID)
- IF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX.cmake)
- SET(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER_ID}-CXX)
- ENDIF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX.cmake)
-ENDIF(CMAKE_CXX_COMPILER_ID)
-SET(CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE
- ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
-INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
+IF(NOT CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE)
+ GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
+ # since the gnu compiler has several names force g++
+ IF(CMAKE_COMPILER_IS_GNUCXX)
+ SET(CMAKE_BASE_NAME g++)
+ ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+ IF(CMAKE_CXX_COMPILER_ID)
+ IF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX.cmake)
+ SET(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER_ID}-CXX)
+ ENDIF(EXISTS ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX.cmake)
+ ENDIF(CMAKE_CXX_COMPILER_ID)
+ SET(CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE
+ ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
+ENDIF(NOT CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE)
+
+INCLUDE(${CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE} OPTIONAL)
+
# This should be included before the _INIT variables are
# used to initialize the cache. Since the rule variables
# have if blocks on them, users can still define them here.
Index: CMakeCCompiler.cmake.in
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeCCompiler.cmake.in,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- CMakeCCompiler.cmake.in 28 Apr 2007 13:35:01 -0000 1.14
+++ CMakeCCompiler.cmake.in 17 May 2007 17:20:43 -0000 1.15
@@ -22,11 +22,8 @@
SET(CMAKE_C_SOURCE_FILE_EXTENSIONS c)
SET(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
SET(CMAKE_C_LINKER_PREFERENCE None)
-IF(UNIX)
- SET(CMAKE_C_OUTPUT_EXTENSION .o)
-ELSE(UNIX)
- SET(CMAKE_C_OUTPUT_EXTENSION .obj)
-ENDIF(UNIX)
+SET(CMAKE_C_OUTPUT_EXTENSION @CMAKE_C_OUTPUT_EXTENSION@)
+
# save the size of void* in case where cache is removed
# and the this file is still around
SET(CMAKE_SIZEOF_VOID_P @CMAKE_SIZEOF_VOID_P@)
Index: CTest.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CTest.cmake,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- CTest.cmake 15 May 2007 14:23:40 -0000 1.8
+++ CTest.cmake 17 May 2007 17:20:43 -0000 1.9
@@ -46,6 +46,7 @@
SET_IF_SET_AND_NOT_SET(DROP_SITE_MODE "${CTEST_DROP_SITE_MODE}")
SET_IF_SET_AND_NOT_SET(DROP_LOCATION "${CTEST_DROP_LOCATION}")
SET_IF_SET_AND_NOT_SET(TRIGGER_SITE "${CTEST_TRIGGER_SITE}")
+ SET_IF_SET_AND_NOT_SET(UPDATE_TYPE "${CTEST_UPDATE_TYPE}")
ENDIF(EXISTS "${PROJECT_SOURCE_DIR}/CTestConfig.cmake")
# the project can have a DartConfig.cmake file
Index: CMakeSystem.cmake.in
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeSystem.cmake.in,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- CMakeSystem.cmake.in 11 Jun 2003 14:07:57 -0000 1.4
+++ CMakeSystem.cmake.in 17 May 2007 17:20:43 -0000 1.5
@@ -1,5 +1,21 @@
-SET(CMAKE_SYSTEM "@CMAKE_SYSTEM@")
-SET(CMAKE_SYSTEM_NAME "@CMAKE_SYSTEM_NAME@")
-SET(CMAKE_SYSTEM_VERSION "@CMAKE_SYSTEM_VERSION@")
-SET(CMAKE_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@")
+IF("@CMAKE_TOOLCHAIN_FILE@" STREQUAL "")
+
+ SET(CMAKE_SYSTEM "@CMAKE_SYSTEM@")
+ SET(CMAKE_SYSTEM_NAME "@CMAKE_SYSTEM_NAME@")
+ SET(CMAKE_SYSTEM_VERSION "@CMAKE_SYSTEM_VERSION@")
+ SET(CMAKE_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@")
+
+ELSE("@CMAKE_TOOLCHAIN_FILE@" STREQUAL "")
+
+ INCLUDE("@CMAKE_TOOLCHAIN_FILE@")
+
+# set CMAKE_SYSTEM to the CMAKE_SYSTEM_NAME
+ SET(CMAKE_SYSTEM ${CMAKE_SYSTEM_NAME})
+# if there is a CMAKE_SYSTEM_VERSION then add a -${CMAKE_SYSTEM_VERSION}
+ IF(CMAKE_SYSTEM_VERSION)
+ SET(CMAKE_SYSTEM ${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION})
+ ENDIF(CMAKE_SYSTEM_VERSION)
+
+ENDIF("@CMAKE_TOOLCHAIN_FILE@" STREQUAL "")
+
SET(CMAKE_SYSTEM_LOADED 1)
Index: CMakeDetermineCCompiler.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CMakeDetermineCCompiler.cmake,v
retrieving revision 1.40
retrieving revision 1.41
diff -u -d -r1.40 -r1.41
--- CMakeDetermineCCompiler.cmake 3 May 2007 12:24:32 -0000 1.40
+++ CMakeDetermineCCompiler.cmake 17 May 2007 17:20:43 -0000 1.41
@@ -2,9 +2,26 @@
# determine the compiler to use for C programs
# NOTE, a generator may set CMAKE_C_COMPILER before
# loading this file to force a compiler.
-# use environment variable CCC first if defined by user, next use
+# use environment variable CC first if defined by user, next use
# the cmake variable CMAKE_GENERATOR_CC which can be defined by a generator
# as a default compiler
+# If the internal cmake variable _CMAKE_TOOLCHAIN_PREFIX is set, this is used
+# as prefix for the tools (e.g. arm-elf-gcc, arm-elf-ar etc.). This works
+# currently with the GNU crosscompilers.
+# It also tries to detect a MS crosscompiler and find out its
+# suffix (clarm.exe), which will be stored in _CMAKE_TOOLCHAIN_SUFFIX and
+# reused for the CXX compiler.
+#
+#
+# Sets the following variables:
+# CMAKE_C_COMPILER
+# CMAKE_AR
+# CMAKE_RANLIB
+# CMAKE_COMPILER_IS_GNUCC
+#
+# If not already set before, it also sets
+# _CMAKE_TOOLCHAIN_PREFIX
+# _CMAKE_TOOLCHAIN_SUFFIX
IF(NOT CMAKE_C_COMPILER)
SET(CMAKE_CXX_COMPILER_INIT NOTFOUND)
@@ -15,10 +32,9 @@
IF(CMAKE_C_FLAGS_ENV_INIT)
SET(CMAKE_C_COMPILER_ARG1 "${CMAKE_C_FLAGS_ENV_INIT}" CACHE STRING "First argument to C compiler")
ENDIF(CMAKE_C_FLAGS_ENV_INIT)
- IF(EXISTS ${CMAKE_C_COMPILER_INIT})
- ELSE(EXISTS ${CMAKE_C_COMPILER_INIT})
+ IF(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable CC:\n$ENV{CC}.")
- ENDIF(EXISTS ${CMAKE_C_COMPILER_INIT})
+ ENDIF(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
ENDIF($ENV{CC} MATCHES ".+")
# next try prefer the compiler specified by the generator
@@ -32,26 +48,64 @@
IF(CMAKE_C_COMPILER_INIT)
SET(CMAKE_C_COMPILER_LIST ${CMAKE_C_COMPILER_INIT})
ELSE(CMAKE_C_COMPILER_INIT)
- SET(CMAKE_C_COMPILER_LIST gcc cc cl bcc xlc)
+ SET(CMAKE_C_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}gcc ${_CMAKE_TOOLCHAIN_PREFIX}cc cl${_CMAKE_TOOLCHAIN_SUFFIX} bcc xlc)
ENDIF(CMAKE_C_COMPILER_INIT)
# Find the compiler.
+ IF (_CMAKE_USER_CXX_COMPILER_PATH)
+ FIND_PROGRAM(CMAKE_C_COMPILER NAMES ${CMAKE_C_COMPILER_LIST} PATHS ${_CMAKE_USER_CXX_COMPILER_PATH} DOC "C compiler" NO_DEFAULT_PATH)
+ ENDIF (_CMAKE_USER_CXX_COMPILER_PATH)
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)
+ELSE(NOT CMAKE_C_COMPILER)
+
+ # if a compiler was specified by the user but without path,
+ # now try to find it with the full path and force it into the cache
+ GET_FILENAME_COMPONENT(_CMAKE_USER_C_COMPILER_PATH "${CMAKE_C_COMPILER}" PATH)
+ IF(NOT _CMAKE_USER_C_COMPILER_PATH)
+ FIND_PROGRAM(CMAKE_C_COMPILER_WITH_PATH NAMES ${CMAKE_C_COMPILER})
+ MARK_AS_ADVANCED(CMAKE_C_COMPILER_WITH_PATH)
+ SET(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_WITH_PATH} CACHE FILEPATH "C compiler" FORCE)
+ ENDIF(NOT _CMAKE_USER_C_COMPILER_PATH)
ENDIF(NOT CMAKE_C_COMPILER)
-MARK_AS_ADVANCED(CMAKE_C_COMPILER)
-GET_FILENAME_COMPONENT(COMPILER_LOCATION "${CMAKE_C_COMPILER}"
- PATH)
+MARK_AS_ADVANCED(CMAKE_C_COMPILER)
-FIND_PROGRAM(CMAKE_AR NAMES ar PATHS ${COMPILER_LOCATION} )
+IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+ GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_C_COMPILER}" PATH)
+ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+
+# if we have a gcc cross compiler, they have usually some prefix, like
+# e.g. powerpc-linux-gcc, arm-elf-gcc or i586-mingw32msvc-gcc
+# the other tools of the toolchain usually have the same prefix
+IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+ GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_C_COMPILER}" NAME_WE)
+ IF (COMPILER_BASENAME MATCHES "^(.+-)g?cc")
+ STRING(REGEX REPLACE "^(.+-)g?cc" "\\1" _CMAKE_TOOLCHAIN_PREFIX "${COMPILER_BASENAME}")
+ ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?cc")
+ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+
+# if we have a MS cross compiler, it usually has a suffix, like
+# e.g. clarm.exe or clmips.exe. Use this suffix for the CXX compiler too.
+IF (NOT _CMAKE_TOOLCHAIN_SUFFIX)
+ GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_C_COMPILER}" NAME)
+ IF (COMPILER_BASENAME MATCHES "^cl(.+)\\.exe$")
+ STRING(REGEX REPLACE "^cl(.+)\\.exe$" "\\1" _CMAKE_TOOLCHAIN_SUFFIX "${COMPILER_BASENAME}")
+ ENDIF (COMPILER_BASENAME MATCHES "^cl(.+)\\.exe$")
+ENDIF (NOT _CMAKE_TOOLCHAIN_SUFFIX)
+
+# some exotic compilers have different extensions (e.g. sdcc uses .rel)
+# so don't overwrite it if it has been already defined by the user
+IF(NOT CMAKE_C_OUTPUT_EXTENSION)
+ IF(UNIX)
+ SET(CMAKE_C_OUTPUT_EXTENSION .o)
+ ELSE(UNIX)
+ SET(CMAKE_C_OUTPUT_EXTENSION .obj)
+ ENDIF(UNIX)
+ENDIF(NOT CMAKE_C_OUTPUT_EXTENSION)
-FIND_PROGRAM(CMAKE_RANLIB NAMES ranlib)
-IF(NOT CMAKE_RANLIB)
- SET(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
-ENDIF(NOT CMAKE_RANLIB)
-MARK_AS_ADVANCED(CMAKE_RANLIB)
# Build a small source file to identify the compiler.
IF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
@@ -62,6 +116,7 @@
# the user may be using an integrated Intel compiler.
# SET(CMAKE_C_COMPILER_ID "MSVC")
ENDIF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+
IF(NOT CMAKE_C_COMPILER_ID_RUN)
SET(CMAKE_C_COMPILER_ID_RUN 1)
@@ -81,9 +136,10 @@
ENDIF("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
ENDIF(NOT CMAKE_C_COMPILER_ID_RUN)
+INCLUDE(CMakeFindBinUtils)
+
# configure variables set in this file for fast reload later on
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
"${CMAKE_PLATFORM_ROOT_BIN}/CMakeCCompiler.cmake" IMMEDIATE)
-MARK_AS_ADVANCED(CMAKE_AR)
SET(CMAKE_C_COMPILER_ENV_VAR "CC")
More information about the Cmake-commits
mailing list