ENH: always provide CMAKE_SYSTEM_XXX() and MAKE_HOST_SYSTEM_XXX() variables,

so when cross compiling the build host platform can be tested

Alex

Modules/CMakeDetermineSystem.cmake

@@ -27,6 +27,43 @@
 # MacOSX                        Darwin
 
 
+# find out on which system cmake runs
+IF(UNIX)
+  FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
+  IF(CMAKE_UNAME)
+    EXEC_PROGRAM(uname ARGS -s OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_NAME)
+    EXEC_PROGRAM(uname ARGS -r OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION)
+    IF(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
+      EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
+        RETURN_VALUE val)
+    ELSE(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
+      EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
+        RETURN_VALUE val)
+      IF("${val}" GREATER 0)
+        EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
+          RETURN_VALUE val)
+      ENDIF("${val}" GREATER 0)
+    ENDIF(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
+    # check the return of the last uname -m or -p 
+    IF("${val}" GREATER 0)
+        SET(CMAKE_HOST_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_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+    STRING(REGEX REPLACE "/" "_" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+  ENDIF(CMAKE_UNAME)
+ELSE(UNIX)
+  IF(WIN32)
+    SET (CMAKE_HOST_SYSTEM_NAME "Windows")
+    SET (CMAKE_HOST_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
+  ENDIF(WIN32)
+ENDIF(UNIX)
+
+# if a toolchain file is used, the user wants to cross compile.
+# in this case read the toolchain file and keep the CMAKE_HOST_SYSTEM_*
+# variables around so they can be used in CMakeLists.txt. 
+# In all other cases, the host and target platform are the same.
 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)
@@ -44,72 +81,52 @@ IF(CMAKE_TOOLCHAIN_FILE)
   IF(NOT DEFINED CMAKE_CROSSCOMPILING)
     SET(CMAKE_CROSSCOMPILING TRUE)
   ENDIF(NOT DEFINED CMAKE_CROSSCOMPILING)
+
+ELSE(CMAKE_TOOLCHAIN_FILE)
+
+  SET(CMAKE_SYSTEM_NAME      "${CMAKE_HOST_SYSTEM_NAME}")
+  SET(CMAKE_SYSTEM_VERSION   "${CMAKE_HOST_SYSTEM_VERSION}")
+  SET(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+  SET(CMAKE_CROSSCOMPILING FALSE)
+
 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)
-      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")
-ENDIF(NOT CMAKE_SYSTEM_NAME)
-
-# fix for BSD/OS , remove the /
-IF(CMAKE_SYSTEM_NAME MATCHES BSD.OS)
-  SET(CMAKE_SYSTEM_NAME BSDOS)
-ENDIF(CMAKE_SYSTEM_NAME MATCHES BSD.OS)
-
-# fix for CYGWIN which has windows version in it 
-IF(CMAKE_SYSTEM_NAME MATCHES CYGWIN)
-  SET(CMAKE_SYSTEM_NAME CYGWIN)
-ENDIF(CMAKE_SYSTEM_NAME MATCHES CYGWIN)
-
-# 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)
-
-
-FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
-  "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
+MACRO(ADJUST_CMAKE_SYSTEM_VARIABLES _PREFIX)
+  IF(NOT ${_PREFIX}_NAME)
+    SET(${_PREFIX}_NAME "UnknownOS")
+  ENDIF(NOT ${_PREFIX}_NAME)
+
+  # fix for BSD/OS , remove the /
+  IF(${_PREFIX}_NAME MATCHES BSD.OS)
+    SET(${_PREFIX}_NAME BSDOS)
+  ENDIF(${_PREFIX}_NAME MATCHES BSD.OS)
+
+  # fix for CYGWIN which has windows version in it 
+  IF(${_PREFIX}_NAME MATCHES CYGWIN)
+    SET(${_PREFIX}_NAME CYGWIN)
+  ENDIF(${_PREFIX}_NAME MATCHES CYGWIN)
+
+  # set CMAKE_SYSTEM to the CMAKE_SYSTEM_NAME
+  SET(${_PREFIX}  ${${_PREFIX}_NAME})
+  # if there is a CMAKE_SYSTEM_VERSION then add a -${CMAKE_SYSTEM_VERSION}
+  IF(${_PREFIX}_VERSION)
+    SET(${_PREFIX} ${${_PREFIX}}-${${_PREFIX}_VERSION})
+  ENDIF(${_PREFIX}_VERSION)
+
+ENDMACRO(ADJUST_CMAKE_SYSTEM_VARIABLES _PREFIX)
+
+ADJUST_CMAKE_SYSTEM_VARIABLES(CMAKE_SYSTEM)
+ADJUST_CMAKE_SYSTEM_VARIABLES(CMAKE_HOST_SYSTEM)
 
 # if a toolchain file is used use configure_file() to copy it into the 
 # build tree, because this way e.g. ${CMAKE_SOURCE_DIR} will be replaced
 # with its full path, and so it will also work when used in try_compile()
 IF (CMAKE_TOOLCHAIN_FILE)
+  FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+    "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
+  FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+    "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n")
+
   SET(_OWN_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
   CONFIGURE_FILE(${CMAKE_TOOLCHAIN_FILE}
                ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeToolchainFile.cmake)
@@ -119,6 +136,8 @@ IF (CMAKE_TOOLCHAIN_FILE)
                IMMEDIATE @ONLY)
 
 ELSE (CMAKE_TOOLCHAIN_FILE)
+  FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+    "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
 
   # configure variables set in this file for fast reload, the template file is defined at the top of this file
   CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in

Modules/CMakeSystem.cmake.in

@@ -3,4 +3,11 @@ SET(CMAKE_SYSTEM_NAME "@CMAKE_SYSTEM_NAME@")
 SET(CMAKE_SYSTEM_VERSION "@CMAKE_SYSTEM_VERSION@")
 SET(CMAKE_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@")
 
+SET(CMAKE_HOST_SYSTEM "@CMAKE_HOST_SYSTEM@")
+SET(CMAKE_HOST_SYSTEM_NAME "@CMAKE_HOST_SYSTEM_NAME@")
+SET(CMAKE_HOST_SYSTEM_VERSION "@CMAKE_HOST_SYSTEM_VERSION@")
+SET(CMAKE_HOST_SYSTEM_PROCESSOR "@CMAKE_HOST_SYSTEM_PROCESSOR@")
+
+SET(CMAKE_CROSSCOMPILING "@CMAKE_CROSSCOMPILING@")
+
 SET(CMAKE_SYSTEM_LOADED 1)

Modules/CMakeSystemWithToolchainFile.cmake.in

@@ -8,4 +8,10 @@ IF(CMAKE_SYSTEM_VERSION)
   SET(CMAKE_SYSTEM ${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION})
 ENDIF(CMAKE_SYSTEM_VERSION)
 
+SET(CMAKE_HOST_SYSTEM "@CMAKE_HOST_SYSTEM@")
+SET(CMAKE_HOST_SYSTEM_NAME "@CMAKE_HOST_SYSTEM_NAME@")
+SET(CMAKE_HOST_SYSTEM_VERSION "@CMAKE_HOST_SYSTEM_VERSION@")
+SET(CMAKE_HOST_SYSTEM_PROCESSOR "@CMAKE_HOST_SYSTEM_PROCESSOR@")
+SET(CMAKE_CROSSCOMPILING "@CMAKE_CROSSCOMPILING@")
+
 SET(CMAKE_SYSTEM_LOADED 1)

Tests/CMakeTests/ToolchainTest.cmake.in

@@ -15,6 +15,45 @@ set(CMAKE_CXX_COMPILER_ID_RUN 1)
 
 set(MY_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@")
 
+# at first load CMakeDetermineSystem.cmake without toolchain file
+set(CMAKE_TOOLCHAIN_FILE)
+include(CMakeDetermineSystem)
+
+# check that CMAKE_SYSTEM_XXX and CMAKE_HOST_SYSTEM_xxx are identical
+if(NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}")
+   message(FATAL_ERROR "CMAKE_SYSTEM_NAME and CMAKE_HOST_SYSTEM_NAME not identical: \"${CMAKE_SYSTEM_NAME}\" vs. \"${CMAKE_HOST_SYSTEM_NAME}\"")
+endif(NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}")
+
+if(NOT "${CMAKE_SYSTEM}" STREQUAL "${CMAKE_HOST_SYSTEM}")
+   message(FATAL_ERROR "CMAKE_SYSTEM and CMAKE_HOST_SYSTEM not identical: \"${CMAKE_SYSTEM}\" vs. \"${CMAKE_HOST_SYSTEM}\"")
+endif(NOT "${CMAKE_SYSTEM}" STREQUAL "${CMAKE_HOST_SYSTEM}")
+
+if(NOT "${CMAKE_SYSTEM_VERSION}" STREQUAL "${CMAKE_HOST_SYSTEM_VERSION}")
+   message(FATAL_ERROR "CMAKE_SYSTEM_VERSION and CMAKE_HOST_SYSTEM_VERSION not identical: \"${CMAKE_SYSTEM_VERSION}\" vs. \"${CMAKE_HOST_SYSTEM_VERSION}\"")
+endif(NOT "${CMAKE_SYSTEM_VERSION}" STREQUAL "${CMAKE_HOST_SYSTEM_VERSION}")
+
+if(NOT "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+   message(FATAL_ERROR "CMAKE_SYSTEM_PROCESSOR and CMAKE_HOST_SYSTEM_PROCESSOR not identical: \"${CMAKE_SYSTEM_PROCESSOR}\" vs. \"${CMAKE_HOST_SYSTEM_PROCESSOR}\"")
+endif(NOT "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+
+# save the values so we can compare them to CMAKE_HOST_SYSTEM_XXX in the toolchain case
+
+set(NATIVE_SYSTEM           "${CMAKE_SYSTEM}")
+set(NATIVE_SYSTEM_NAME      "${CMAKE_SYSTEM_NAME}")
+set(NATIVE_SYSTEM_VERSION   "${CMAKE_SYSTEM_VERSION}")
+set(NATIVE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
+
+# reset them so they will be detected again now
+set(CMAKE_SYSTEM)
+set(CMAKE_SYSTEM_NAME)
+set(CMAKE_SYSTEM_VERSION)
+set(CMAKE_SYSTEM_PROCESSOR)
+set(CMAKE_HOST_SYSTEM)
+set(CMAKE_HOST_SYSTEM_NAME)
+set(CMAKE_HOST_SYSTEM_VERSION)
+set(CMAKE_HOST_SYSTEM_PROCESSOR)
+
+
 ############################################################
 
 # now define a toolchain file and check that everything is 
@@ -42,6 +81,21 @@ if(NOT "${_INCLUDED_TOOLCHAIN_FILE}" STREQUAL "${MY_SOURCE_DIR}/DummyToolchain.c
    message(FATAL_ERROR "wrong toolchain file loaded: \"${_INCLUDED_TOOLCHAIN_FILE}\", expected: \"${MY_SOURCE_DIR}/DummyToolchain.cmake\"")
 endif(NOT "${_INCLUDED_TOOLCHAIN_FILE}" STREQUAL "${MY_SOURCE_DIR}/DummyToolchain.cmake")
 
+
+# check that CMAKE_HOST_SYSTEM_XXX and _SYSTEM_xxx detected above are identical
+if(NOT "${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "${NATIVE_SYSTEM_NAME}")
+   message(FATAL_ERROR "CMAKE_HOST_SYSTEM_NAME and NATIVE_SYSTEM_NAME not identical: \"${CMAKE_HOST_SYSTEM_NAME}\" vs. \"${NATIVE_SYSTEM_NAME}\"")
+endif(NOT "${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "${NATIVE_SYSTEM_NAME}")
+if(NOT "${CMAKE_HOST_SYSTEM}" STREQUAL "${NATIVE_SYSTEM}")
+   message(FATAL_ERROR "CMAKE_HOST_SYSTEM and NATIVE_SYSTEM not identical: \"${CMAKE_HOST_SYSTEM}\" vs. \"${NATIVE_SYSTEM}\"")
+endif(NOT "${CMAKE_HOST_SYSTEM}" STREQUAL "${NATIVE_SYSTEM}")
+if(NOT "${CMAKE_HOST_SYSTEM_VERSION}" STREQUAL "${NATIVE_SYSTEM_VERSION}")
+   message(FATAL_ERROR "CMAKE_HOST_SYSTEM_VERSION and NATIVE_SYSTEM_VERSION not identical: \"${CMAKE_HOST_SYSTEM_VERSION}\" vs. \"${NATIVE_SYSTEM_VERSION}\"")
+endif(NOT "${CMAKE_HOST_SYSTEM_VERSION}" STREQUAL "${NATIVE_SYSTEM_VERSION}")
+if(NOT "${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "${NATIVE_SYSTEM_PROCESSOR}")
+   message(FATAL_ERROR "CMAKE_HOST_SYSTEM_PROCESSOR and NATIVE_SYSTEM_PROCESSOR not identical: \"${CMAKE_HOST_SYSTEM_PROCESSOR}\" vs. \"${NATIVE_SYSTEM_PROCESSOR}\"")
+endif(NOT "${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "${NATIVE_SYSTEM_PROCESSOR}")
+
 #############################################################
 
 # check the results from DetermineCCompiler