1 files changed, 179 insertions, 0 deletions
diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake
new file mode 100644
index 000000000..9028e8e06
--- /dev/null
+++ b/Modules/CMakeDetermineCCompiler.cmake
@@ -0,0 +1,179 @@
+
+#=============================================================================
+# Copyright 2002-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# 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 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.
+#
+# 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
+
+IF(NOT CMAKE_C_COMPILER)
+  SET(CMAKE_C_COMPILER_INIT NOTFOUND)
+
+  # prefer the environment variable CC
+  IF($ENV{CC} MATCHES ".+")
+    GET_FILENAME_COMPONENT(CMAKE_C_COMPILER_INIT $ENV{CC} PROGRAM PROGRAM_ARGS CMAKE_C_FLAGS_ENV_INIT)
+    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(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
+      MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable CC:\n$ENV{CC}.")
+    ENDIF(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
+  ENDIF($ENV{CC} MATCHES ".+")
+
+  # next try prefer the compiler specified by the generator
+  IF(CMAKE_GENERATOR_CC)
+    IF(NOT CMAKE_C_COMPILER_INIT)
+      SET(CMAKE_C_COMPILER_INIT ${CMAKE_GENERATOR_CC})
+    ENDIF(NOT CMAKE_C_COMPILER_INIT)
+  ENDIF(CMAKE_GENERATOR_CC)
+
+  # finally list compilers to try
+  IF(CMAKE_C_COMPILER_INIT)
+    SET(CMAKE_C_COMPILER_LIST ${CMAKE_C_COMPILER_INIT})
+  ELSE(CMAKE_C_COMPILER_INIT)
+    SET(CMAKE_C_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}gcc ${_CMAKE_TOOLCHAIN_PREFIX}cc cl 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)
+
+  # we only get here if CMAKE_C_COMPILER was specified using -D or a pre-made CMakeCache.txt
+  # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
+  # if CMAKE_C_COMPILER is a list of length 2, use the first item as
+  # CMAKE_C_COMPILER and the 2nd one as CMAKE_C_COMPILER_ARG1
+
+  LIST(LENGTH CMAKE_C_COMPILER _CMAKE_C_COMPILER_LIST_LENGTH)
+  IF("${_CMAKE_C_COMPILER_LIST_LENGTH}" EQUAL 2)
+    LIST(GET CMAKE_C_COMPILER 1 CMAKE_C_COMPILER_ARG1)
+    LIST(GET CMAKE_C_COMPILER 0 CMAKE_C_COMPILER)
+  ENDIF("${_CMAKE_C_COMPILER_LIST_LENGTH}" EQUAL 2)
+
+  # if a compiler was specified by the user but without path,
+  # now try to find it with the full path
+  # if it is found, force it into the cache,
+  # if not, don't overwrite the setting (which was given by the user) with "NOTFOUND"
+  # if the C compiler already had a path, reuse it for searching the CXX compiler
+  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)
+    IF(CMAKE_C_COMPILER_WITH_PATH)
+      SET(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_WITH_PATH} CACHE STRING "C compiler" FORCE)
+    ENDIF(CMAKE_C_COMPILER_WITH_PATH)
+  ENDIF(NOT _CMAKE_USER_C_COMPILER_PATH)
+ENDIF(NOT CMAKE_C_COMPILER)
+MARK_AS_ADVANCED(CMAKE_C_COMPILER)
+
+IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_C_COMPILER}" PATH)
+ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+
+# Build a small source file to identify the compiler.
+IF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+  SET(CMAKE_C_COMPILER_ID_RUN 1)
+  SET(CMAKE_C_PLATFORM_ID "Windows")
+  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)
+
+  # Each entry in this list is a set of extra flags to try
+  # adding to the compile line to see if it helps produce
+  # a valid identification file.
+  SET(CMAKE_C_COMPILER_ID_TEST_FLAGS
+    # Try compiling to an object file only.
+    "-c"
+
+    # Try enabling ANSI mode on HP.
+    "-Aa"
+    )
+
+  # Try to identify the compiler.
+  SET(CMAKE_C_COMPILER_ID)
+  FILE(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
+    CMAKE_C_COMPILER_ID_PLATFORM_CONTENT)
+  INCLUDE(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
+  CMAKE_DETERMINE_COMPILER_ID(C CFLAGS CMakeCCompilerId.c)
+
+  # Set old compiler and platform id variables.
+  IF("${CMAKE_C_COMPILER_ID}" MATCHES "GNU")
+    SET(CMAKE_COMPILER_IS_GNUCC 1)
+  ENDIF("${CMAKE_C_COMPILER_ID}" MATCHES "GNU")
+  IF("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
+    SET(CMAKE_COMPILER_IS_MINGW 1)
+  ELSEIF("${CMAKE_C_PLATFORM_ID}" MATCHES "Cygwin")
+    SET(CMAKE_COMPILER_IS_CYGWIN 1)
+  ENDIF("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
+ENDIF(NOT CMAKE_C_COMPILER_ID_RUN)
+
+# 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, optionally
+# with a 3-component version number at the end (e.g. arm-eabi-gcc-4.5.2).
+# The other tools of the toolchain usually have the same prefix
+# NAME_WE cannot be used since then this test will fail for names lile
+# "arm-unknown-nto-qnx6.3.0-gcc.exe", where BASENAME would be
+# "arm-unknown-nto-qnx6" instead of the correct "arm-unknown-nto-qnx6.3.0-"
+IF (CMAKE_CROSSCOMPILING
+    AND "${CMAKE_C_COMPILER_ID}" MATCHES "GNU"
+    AND NOT _CMAKE_TOOLCHAIN_PREFIX)
+  GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_C_COMPILER}" NAME)
+  IF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+
+  # if "llvm-" is part of the prefix, remove it, since llvm doesn't have its own binutils
+  # but uses the regular ar, objcopy, etc. (instead of llvm-objcopy etc.)
+  IF ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
+    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  ENDIF ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
+
+ENDIF (CMAKE_CROSSCOMPILING
+    AND "${CMAKE_C_COMPILER_ID}" MATCHES "GNU"
+    AND NOT _CMAKE_TOOLCHAIN_PREFIX)
+
+INCLUDE(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake)
+INCLUDE(CMakeFindBinUtils)
+IF(MSVC_C_ARCHITECTURE_ID)
+  SET(SET_MSVC_C_ARCHITECTURE_ID
+    "SET(MSVC_C_ARCHITECTURE_ID ${MSVC_C_ARCHITECTURE_ID})")
+ENDIF(MSVC_C_ARCHITECTURE_ID)
+# 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"
+  @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
+  )
+SET(CMAKE_C_COMPILER_ENV_VAR "CC")