Modules/CMakeDetermineCompilerId.cmake

   1 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2 # file Copyright.txt or https://cmake.org/licensing for details.
   3
   4
   5 # Function to compile a source file to identify the compiler.  This is
   6 # used internally by CMake and should not be included by user code.
   7 # If successful, sets CMAKE_<lang>_COMPILER_ID and CMAKE_<lang>_PLATFORM_ID
   8
   9 function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
  10   # Make sure the compiler arguments are clean.
  11   string(STRIP "${CMAKE_${lang}_COMPILER_ARG1}" CMAKE_${lang}_COMPILER_ID_ARG1)
  12   string(REGEX REPLACE " +" ";" CMAKE_${lang}_COMPILER_ID_ARG1 "${CMAKE_${lang}_COMPILER_ID_ARG1}")
  13
  14   # Make sure user-specified compiler flags are used.
  15   if(CMAKE_${lang}_FLAGS)
  16     set(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS})
  17   else()
  18     set(CMAKE_${lang}_COMPILER_ID_FLAGS $ENV{${flagvar}})
  19   endif()
  20   string(REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}")
  21
  22   # Compute the directory in which to run the test.
  23   set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang})
  24
  25   # Try building with no extra flags and then try each set
  26   # of helper flags.  Stop when the compiler is identified.
  27   foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "")
  28     foreach(testflags ${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS_FIRST}
  29                       ""
  30                       ${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS})
  31       separate_arguments(testflags UNIX_COMMAND "${testflags}")
  32       CMAKE_DETERMINE_COMPILER_ID_BUILD("${lang}" "${testflags}" "${userflags}" "${src}")
  33       CMAKE_DETERMINE_COMPILER_ID_MATCH_VENDOR("${lang}" "${COMPILER_${lang}_PRODUCED_OUTPUT}")
  34       if(CMAKE_${lang}_COMPILER_ID)
  35         break()
  36       endif()
  37       foreach(file ${COMPILER_${lang}_PRODUCED_FILES})
  38         CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}")
  39       endforeach()
  40       if(CMAKE_${lang}_COMPILER_ID)
  41         break()
  42       endif()
  43     endforeach()
  44     if(CMAKE_${lang}_COMPILER_ID)
  45       break()
  46     endif()
  47   endforeach()
  48
  49   # Check if compiler id detection gave us the compiler tool.
  50   if(CMAKE_${lang}_COMPILER_ID_TOOL)
  51     set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER_ID_TOOL}")
  52     set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER_ID_TOOL}" PARENT_SCOPE)
  53   elseif(NOT CMAKE_${lang}_COMPILER)
  54     set(CMAKE_${lang}_COMPILER "CMAKE_${lang}_COMPILER-NOTFOUND" PARENT_SCOPE)
  55   endif()
  56
  57   # If the compiler is still unknown, try to query its vendor.
  58   if(CMAKE_${lang}_COMPILER AND NOT CMAKE_${lang}_COMPILER_ID)
  59     foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "")
  60       CMAKE_DETERMINE_COMPILER_ID_VENDOR(${lang} "${userflags}")
  61     endforeach()
  62   endif()
  63
  64   # If the compiler is still unknown, fallback to GHS
  65   if(NOT CMAKE_${lang}_COMPILER_ID  AND "${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI")
  66     set(CMAKE_${lang}_COMPILER_ID GHS)
  67     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
  68         "The ${lang} compiler identification is falling back to GHS.\n\n")
  69   endif()
  70
  71   # CUDA < 7.5 is missing version macros
  72   if(lang STREQUAL "CUDA"
  73      AND CMAKE_${lang}_COMPILER_ID STREQUAL "NVIDIA"
  74      AND NOT CMAKE_${lang}_COMPILER_VERSION)
  75     execute_process(
  76       COMMAND "${CMAKE_${lang}_COMPILER}"
  77       --version
  78       OUTPUT_VARIABLE output ERROR_VARIABLE output
  79       RESULT_VARIABLE result
  80       TIMEOUT 10
  81     )
  82     if(output MATCHES [=[ V([0-9]+)\.([0-9]+)\.([0-9]+)]=])
  83       set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
  84     endif()
  85   endif()
  86
  87   # For Swift we need to explicitly query the version.
  88   if(lang STREQUAL "Swift"
  89      AND CMAKE_${lang}_COMPILER
  90      AND NOT CMAKE_${lang}_COMPILER_VERSION)
  91     execute_process(
  92       COMMAND "${CMAKE_${lang}_COMPILER}"
  93       -version
  94       OUTPUT_VARIABLE output ERROR_VARIABLE output
  95       RESULT_VARIABLE result
  96       TIMEOUT 10
  97     )
  98     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
  99       "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" -version\n"
 100       "${output}\n"
 101       )
 102
 103     if(output MATCHES [[Swift version ([0-9]+\.[0-9]+(\.[0-9]+)?)]])
 104       set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_MATCH_1}")
 105       if(NOT CMAKE_${lang}_COMPILER_ID)
 106         set(CMAKE_Swift_COMPILER_ID "Apple")
 107       endif()
 108     endif()
 109   endif()
 110
 111   if (COMPILER_QNXNTO AND CMAKE_${lang}_COMPILER_ID STREQUAL "GNU")
 112     execute_process(
 113       COMMAND "${CMAKE_${lang}_COMPILER}"
 114       -V
 115       OUTPUT_VARIABLE output ERROR_VARIABLE output
 116       RESULT_VARIABLE result
 117       TIMEOUT 10
 118       )
 119     if (output MATCHES "targets available")
 120       set(CMAKE_${lang}_COMPILER_ID QCC)
 121       # http://community.qnx.com/sf/discussion/do/listPosts/projects.community/discussion.qnx_momentics_community_support.topc3555?_pagenum=2
 122       # The qcc driver does not itself have a version.
 123     endif()
 124   endif()
 125
 126   # if the format is unknown after all files have been checked, put "Unknown" in the cache
 127   if(NOT CMAKE_EXECUTABLE_FORMAT)
 128     set(CMAKE_EXECUTABLE_FORMAT "Unknown" CACHE INTERNAL "Executable file format")
 129   endif()
 130
 131   if(CMAKE_GENERATOR MATCHES "^Ninja" AND MSVC_${lang}_ARCHITECTURE_ID)
 132     foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "")
 133       CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX(${lang} "${userflags}")
 134     endforeach()
 135   else()
 136     set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "")
 137   endif()
 138
 139   set(_variant "")
 140   if("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xClang")
 141     if("x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
 142       if(CMAKE_GENERATOR MATCHES "Visual Studio")
 143         set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC")
 144       else()
 145         # Test whether an MSVC-like command-line option works.
 146         execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -?
 147           RESULT_VARIABLE _clang_result
 148           OUTPUT_VARIABLE _clang_stdout
 149           ERROR_VARIABLE _clang_stderr)
 150         if(_clang_result EQUAL 0)
 151           set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC")
 152         else()
 153           set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU")
 154         endif()
 155       endif()
 156       set(_variant " with ${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}-like command-line")
 157     else()
 158       set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU")
 159     endif()
 160   else()
 161     set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "")
 162   endif()
 163
 164   # Display the final identification result.
 165   if(CMAKE_${lang}_COMPILER_ID)
 166     if(CMAKE_${lang}_COMPILER_VERSION)
 167       set(_version " ${CMAKE_${lang}_COMPILER_VERSION}")
 168     else()
 169       set(_version "")
 170     endif()
 171     if(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xIAR")
 172       set(_archid " ${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}")
 173     else()
 174       set(_archid "")
 175     endif()
 176     message(STATUS "The ${lang} compiler identification is "
 177       "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}${_variant}")
 178     unset(_archid)
 179     unset(_version)
 180     unset(_variant)
 181   else()
 182     message(STATUS "The ${lang} compiler identification is unknown")
 183   endif()
 184
 185   if(lang STREQUAL "Fortran" AND CMAKE_${lang}_COMPILER_ID STREQUAL "XL")
 186     set(CMAKE_${lang}_XL_CPP "${CMAKE_${lang}_COMPILER_ID_CPP}" PARENT_SCOPE)
 187   endif()
 188
 189   set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
 190   set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
 191   set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}" PARENT_SCOPE)
 192   set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
 193     PARENT_SCOPE)
 194   set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_${lang}_XCODE_ARCHS}" PARENT_SCOPE)
 195   set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX}" PARENT_SCOPE)
 196   set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}" PARENT_SCOPE)
 197   set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE)
 198   set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${CMAKE_${lang}_COMPILER_VERSION_INTERNAL}" PARENT_SCOPE)
 199   set(CMAKE_${lang}_COMPILER_WRAPPER "${CMAKE_${lang}_COMPILER_WRAPPER}" PARENT_SCOPE)
 200   set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE)
 201   set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE)
 202   set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE)
 203   set(CMAKE_${lang}_COMPILER_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE)
 204   set(CMAKE_${lang}_COMPILER_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
 205 endfunction()
 206
 207 include(CMakeCompilerIdDetection)
 208
 209 #-----------------------------------------------------------------------------
 210 # Function to write the compiler id source file.
 211 function(CMAKE_DETERMINE_COMPILER_ID_WRITE lang src)
 212   find_file(src_in ${src}.in PATHS ${CMAKE_ROOT}/Modules ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
 213   file(READ ${src_in} ID_CONTENT_IN)
 214
 215   compiler_id_detection(CMAKE_${lang}_COMPILER_ID_CONTENT ${lang}
 216     ID_STRING
 217     VERSION_STRINGS
 218     PLATFORM_DEFAULT_COMPILER
 219   )
 220
 221   unset(src_in CACHE)
 222   string(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY)
 223   file(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}")
 224 endfunction()
 225
 226 #-----------------------------------------------------------------------------
 227 # Function to build the compiler id source file and look for output
 228 # files.
 229 function(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags userflags src)
 230   # Create a clean working directory.
 231   file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
 232   file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
 233   file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}/tmp)
 234   CMAKE_DETERMINE_COMPILER_ID_WRITE("${lang}" "${src}")
 235
 236   # Construct a description of this test case.
 237   set(COMPILER_DESCRIPTION
 238     "Compiler: ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_ARG1}
 239 Build flags: ${userflags}
 240 Id flags: ${testflags} ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS}
 241 ")
 242
 243   # Compile the compiler identification source.
 244   if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([0-9]+)")
 245     set(vs_version ${CMAKE_MATCH_1})
 246     set(id_platform ${CMAKE_VS_PLATFORM_NAME})
 247     set(id_lang "${lang}")
 248     set(id_PostBuildEvent_Command "")
 249     if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "^[Ll][Ll][Vv][Mm](_v[0-9]+(_xp)?)?$")
 250       set(id_cl_var "ClangClExecutable")
 251     elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "^[Cc][Ll][Aa][Nn][Gg][Cc][Ll]$")
 252       set(id_cl "$(CLToolExe)")
 253     elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "v[0-9]+_clang_.*")
 254       set(id_cl clang.exe)
 255     else()
 256       set(id_cl cl.exe)
 257     endif()
 258     if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
 259       set(v NsightTegra)
 260       set(ext vcxproj)
 261       if(lang STREQUAL CXX)
 262         set(id_gcc g++)
 263         set(id_clang clang++)
 264       else()
 265         set(id_gcc gcc)
 266         set(id_clang clang)
 267       endif()
 268     elseif(lang STREQUAL Fortran)
 269       set(v Intel)
 270       set(ext vfproj)
 271       set(id_cl ifort.exe)
 272     elseif(lang STREQUAL CSharp)
 273       set(v 10)
 274       set(ext csproj)
 275       set(id_cl csc.exe)
 276     elseif(NOT "${vs_version}" VERSION_LESS 10)
 277       set(v 10)
 278       set(ext vcxproj)
 279     else()
 280       set(id_version ${vs_version}.00)
 281       set(v 7)
 282       set(ext vcproj)
 283     endif()
 284     if(CMAKE_VS_PLATFORM_TOOLSET)
 285       if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
 286         set(id_toolset "<NdkToolchainVersion>${CMAKE_VS_PLATFORM_TOOLSET}</NdkToolchainVersion>")
 287       else()
 288         set(id_toolset "<PlatformToolset>${CMAKE_VS_PLATFORM_TOOLSET}</PlatformToolset>")
 289         if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "Intel")
 290           set(id_cl icl.exe)
 291         endif()
 292         if(CMAKE_VS_PLATFORM_TOOLSET_VERSION)
 293           set(id_sep "\\")
 294           if(CMAKE_VS_PLATFORM_TOOLSET_VERSION VERSION_GREATER_EQUAL "14.20")
 295             if(EXISTS "${CMAKE_GENERATOR_INSTANCE}/VC/Auxiliary/Build.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}/Microsoft.VCToolsVersion.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}.props")
 296               set(id_sep ".")
 297             endif()
 298           endif()
 299           set(id_toolset_version_props "<Import Project=\"${CMAKE_GENERATOR_INSTANCE}\\VC\\Auxiliary\\Build${id_sep}${CMAKE_VS_PLATFORM_TOOLSET_VERSION}\\Microsoft.VCToolsVersion.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}.props\" />")
 300           unset(id_sep)
 301         endif()
 302       endif()
 303     else()
 304       set(id_toolset "")
 305       set(id_toolset_version_props "")
 306     endif()
 307     if(CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE)
 308       set(id_PreferredToolArchitecture "<PreferredToolArchitecture>${CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE}</PreferredToolArchitecture>")
 309     else()
 310       set(id_PreferredToolArchitecture "")
 311     endif()
 312     if(CMAKE_SYSTEM_NAME STREQUAL "WindowsPhone")
 313       set(id_system "<ApplicationType>Windows Phone</ApplicationType>")
 314     elseif(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
 315       set(id_system "<ApplicationType>Windows Store</ApplicationType>")
 316     else()
 317       set(id_system "")
 318     endif()
 319     if(id_system AND CMAKE_SYSTEM_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
 320       set(id_system_version "<ApplicationTypeRevision>${CMAKE_MATCH_1}</ApplicationTypeRevision>")
 321     else()
 322       set(id_system_version "")
 323     endif()
 324     if(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION)
 325       set(id_WindowsTargetPlatformVersion "<WindowsTargetPlatformVersion>${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}</WindowsTargetPlatformVersion>")
 326     endif()
 327     if(CMAKE_VS_PLATFORM_TOOLSET_VCTARGETS_CUSTOM_DIR)
 328       set(id_ToolsetVCTargetsDir "<VCTargetsPath>${CMAKE_VS_PLATFORM_TOOLSET_VCTARGETS_CUSTOM_DIR}</VCTargetsPath>")
 329     endif()
 330     set(id_CustomGlobals "")
 331     foreach(pair IN LISTS CMAKE_VS_GLOBALS)
 332       if("${pair}" MATCHES "([^=]+)=(.*)$")
 333         string(APPEND id_CustomGlobals "<${CMAKE_MATCH_1}>${CMAKE_MATCH_2}</${CMAKE_MATCH_1}>\n    ")
 334       endif()
 335     endforeach()
 336     if(id_platform STREQUAL ARM64)
 337       set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARM64Support>true</WindowsSDKDesktopARM64Support>")
 338     elseif(id_platform STREQUAL ARM)
 339       set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>")
 340     else()
 341       set(id_WindowsSDKDesktopARMSupport "")
 342     endif()
 343     if(CMAKE_VS_WINCE_VERSION)
 344       set(id_entrypoint "mainACRTStartup")
 345       if("${vs_version}" VERSION_LESS 9)
 346         set(id_subsystem 9)
 347       else()
 348         set(id_subsystem 8)
 349       endif()
 350     else()
 351       set(id_subsystem 1)
 352     endif()
 353     set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
 354     set(id_src "${src}")
 355     set(id_compile "ClCompile")
 356     if(id_cl_var)
 357       set(id_PostBuildEvent_Command "echo CMAKE_${lang}_COMPILER=$(${id_cl_var})")
 358     else()
 359       set(id_PostBuildEvent_Command "for %%i in (${id_cl}) do %40echo CMAKE_${lang}_COMPILER=%%~$PATH:i")
 360     endif()
 361     set(id_Import_props "")
 362     set(id_Import_targets "")
 363     set(id_ItemDefinitionGroup_entry "")
 364     set(id_Link_AdditionalDependencies "")
 365     if(lang STREQUAL CUDA)
 366       if(NOT CMAKE_VS_PLATFORM_TOOLSET_CUDA)
 367         message(FATAL_ERROR "No CUDA toolset found.")
 368       endif()
 369       set(cuda_tools "CUDA ${CMAKE_VS_PLATFORM_TOOLSET_CUDA}")
 370       set(id_compile "CudaCompile")
 371       set(id_ItemDefinitionGroup_entry "<CudaCompile><AdditionalOptions>%(AdditionalOptions)-v</AdditionalOptions></CudaCompile>")
 372       set(id_PostBuildEvent_Command [[echo CMAKE_CUDA_COMPILER=$(CudaToolkitBinDir)\nvcc.exe]])
 373       if(CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR)
 374         set(id_CudaToolkitCustomDir "<CudaToolkitCustomDir>${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}nvcc</CudaToolkitCustomDir>")
 375         string(CONCAT id_Import_props "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}\\CUDAVisualStudioIntegration\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.props\" />")
 376         string(CONCAT id_Import_targets "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}\\CUDAVisualStudioIntegration\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.targets\" />")
 377       else()
 378         string(CONCAT id_Import_props [[<Import Project="$(VCTargetsPath)\BuildCustomizations\]] "${cuda_tools}" [[.props" />]])
 379         string(CONCAT id_Import_targets [[<Import Project="$(VCTargetsPath)\BuildCustomizations\]] "${cuda_tools}" [[.targets" />]])
 380       endif()
 381       if(CMAKE_VS_PLATFORM_NAME STREQUAL x64)
 382         set(id_ItemDefinitionGroup_entry "<CudaCompile><TargetMachinePlatform>64</TargetMachinePlatform><AdditionalOptions>%(AdditionalOptions)-v</AdditionalOptions></CudaCompile>")
 383       endif()
 384       set(id_Link_AdditionalDependencies "<AdditionalDependencies>cudart.lib</AdditionalDependencies>")
 385     endif()
 386     configure_file(${CMAKE_ROOT}/Modules/CompilerId/VS-${v}.${ext}.in
 387       ${id_dir}/CompilerId${lang}.${ext} @ONLY)
 388     if(CMAKE_VS_MSBUILD_COMMAND AND NOT lang STREQUAL "Fortran")
 389       set(command "${CMAKE_VS_MSBUILD_COMMAND}" "CompilerId${lang}.${ext}"
 390         "/p:Configuration=Debug" "/p:Platform=${id_platform}" "/p:VisualStudioVersion=${vs_version}.0"
 391         )
 392     elseif(CMAKE_VS_DEVENV_COMMAND)
 393       set(command "${CMAKE_VS_DEVENV_COMMAND}" "CompilerId${lang}.${ext}" "/build" "Debug")
 394     else()
 395       set(command "")
 396     endif()
 397     if(command)
 398       execute_process(
 399         COMMAND ${command}
 400         WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
 401         OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 402         ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 403         RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
 404         )
 405     else()
 406       set(CMAKE_${lang}_COMPILER_ID_RESULT 1)
 407       set(CMAKE_${lang}_COMPILER_ID_OUTPUT "VS environment not known to support ${lang}")
 408     endif()
 409     # Match the compiler location line printed out.
 410     if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "CMAKE_${lang}_COMPILER=([^%\r\n]+)[\r\n]")
 411       # Strip VS diagnostic output from the end of the line.
 412       string(REGEX REPLACE " \\(TaskId:[0-9]*\\)$" "" _comp "${CMAKE_MATCH_1}")
 413       if(EXISTS "${_comp}")
 414         file(TO_CMAKE_PATH "${_comp}" _comp)
 415         set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE)
 416       endif()
 417     endif()
 418   elseif("${CMAKE_GENERATOR}" MATCHES "Xcode")
 419     set(id_lang "${lang}")
 420     set(id_type ${CMAKE_${lang}_COMPILER_XCODE_TYPE})
 421     set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
 422     set(id_src "${src}")
 423     if(CMAKE_XCODE_PLATFORM_TOOLSET)
 424       set(id_toolset "GCC_VERSION = ${CMAKE_XCODE_PLATFORM_TOOLSET};")
 425     else()
 426       set(id_toolset "")
 427     endif()
 428     if("${lang}" STREQUAL "Swift")
 429       if(CMAKE_Swift_LANGUAGE_VERSION)
 430         set(id_lang_version "SWIFT_VERSION = ${CMAKE_Swift_LANGUAGE_VERSION};")
 431       elseif(XCODE_VERSION VERSION_GREATER_EQUAL 10.2)
 432         set(id_lang_version "SWIFT_VERSION = 4.0;")
 433       elseif(XCODE_VERSION VERSION_GREATER_EQUAL 8.3)
 434         set(id_lang_version "SWIFT_VERSION = 3.0;")
 435       else()
 436         set(id_lang_version "SWIFT_VERSION = 2.3;")
 437       endif()
 438     else()
 439       set(id_lang_version "")
 440     endif()
 441     if(CMAKE_OSX_DEPLOYMENT_TARGET)
 442       set(id_deployment_target
 443         "MACOSX_DEPLOYMENT_TARGET = \"${CMAKE_OSX_DEPLOYMENT_TARGET}\";")
 444     else()
 445       set(id_deployment_target "")
 446     endif()
 447     set(id_product_type "com.apple.product-type.tool")
 448     if(CMAKE_OSX_SYSROOT)
 449       set(id_sdkroot "SDKROOT = \"${CMAKE_OSX_SYSROOT}\";")
 450       if(CMAKE_OSX_SYSROOT MATCHES "(^|/)[Ii][Pp][Hh][Oo][Nn][Ee]" OR
 451         CMAKE_OSX_SYSROOT MATCHES "(^|/)[Aa][Pp][Pp][Ll][Ee][Tt][Vv]")
 452         set(id_product_type "com.apple.product-type.bundle.unit-test")
 453       elseif(CMAKE_OSX_SYSROOT MATCHES "(^|/)[Ww][Aa][Tt][Cc][Hh]")
 454         set(id_product_type "com.apple.product-type.framework")
 455       endif()
 456     else()
 457       set(id_sdkroot "")
 458     endif()
 459     set(id_clang_cxx_library "")
 460     set(stdlib_regex "(^| )(-stdlib=)([^ ]+)( |$)")
 461     string(REGEX MATCHALL "${stdlib_regex}" all_stdlib_matches "${CMAKE_CXX_FLAGS}")
 462     if(all_stdlib_matches)
 463       list(GET all_stdlib_matches "-1" last_stdlib_match)
 464       if(last_stdlib_match MATCHES "${stdlib_regex}")
 465         set(id_clang_cxx_library "CLANG_CXX_LIBRARY = \"${CMAKE_MATCH_3}\";")
 466       endif()
 467     endif()
 468     configure_file(${CMAKE_ROOT}/Modules/CompilerId/Xcode-3.pbxproj.in
 469       ${id_dir}/CompilerId${lang}.xcodeproj/project.pbxproj @ONLY)
 470     unset(_ENV_MACOSX_DEPLOYMENT_TARGET)
 471     if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
 472       set(_ENV_MACOSX_DEPLOYMENT_TARGET "$ENV{MACOSX_DEPLOYMENT_TARGET}")
 473       set(ENV{MACOSX_DEPLOYMENT_TARGET} "")
 474     endif()
 475     execute_process(COMMAND xcodebuild
 476       WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
 477       OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 478       ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 479       RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
 480       )
 481     if(DEFINED _ENV_MACOSX_DEPLOYMENT_TARGET)
 482       set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_ENV_MACOSX_DEPLOYMENT_TARGET}")
 483     endif()
 484
 485     if(DEFINED CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_REGEX)
 486       if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "${CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_REGEX}")
 487         set(_comp "${CMAKE_MATCH_${CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_INDEX}}")
 488         if(EXISTS "${_comp}")
 489           set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE)
 490         endif()
 491       endif()
 492     endif()
 493     if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "ARCHS=([^%\r\n]+)[\r\n]")
 494       set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_MATCH_1}")
 495       separate_arguments(CMAKE_${lang}_XCODE_ARCHS)
 496       set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_${lang}_XCODE_ARCHS}" PARENT_SCOPE)
 497     endif()
 498   elseif("${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI")
 499     set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
 500     set(id_src "${src}")
 501     if (GHS_PRIMARY_TARGET)
 502       set(ghs_primary_target "${GHS_PRIMARY_TARGET}")
 503     else()
 504       set(ghs_primary_target "${CMAKE_GENERATOR_PLATFORM}_${GHS_TARGET_PLATFORM}.tgt")
 505     endif()
 506     if ("${GHS_TARGET_PLATFORM}" MATCHES "integrity")
 507         set(bsp_name "macro GHS_BSP=${GHS_BSP_NAME}")
 508         set(os_dir "macro GHS_OS=${GHS_OS_DIR}")
 509     endif()
 510     set(command "${CMAKE_MAKE_PROGRAM}" "-commands" "-top" "GHS_default.gpj")
 511     configure_file(${CMAKE_ROOT}/Modules/CompilerId/GHS_default.gpj.in
 512       ${id_dir}/GHS_default.gpj @ONLY)
 513     configure_file(${CMAKE_ROOT}/Modules/CompilerId/GHS_lib.gpj.in
 514       ${id_dir}/GHS_lib.gpj @ONLY)
 515     execute_process(COMMAND ${command}
 516       WORKING_DIRECTORY ${id_dir}
 517       OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 518       ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 519       RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
 520       )
 521     # Match the compiler location line printed out.
 522     set(ghs_toolpath "${CMAKE_MAKE_PROGRAM}")
 523     if(CMAKE_HOST_UNIX)
 524       string(REPLACE "/gbuild" "/" ghs_toolpath ${ghs_toolpath})
 525     else()
 526       string(REPLACE "/gbuild.exe" "/" ghs_toolpath ${ghs_toolpath})
 527       string(REPLACE / "\\\\" ghs_toolpath ${ghs_toolpath})
 528     endif()
 529     if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "(${ghs_toolpath}[^ ]*)")
 530       if(CMAKE_HOST_UNIX)
 531         set(_comp "${CMAKE_MATCH_1}")
 532       else()
 533         set(_comp "${CMAKE_MATCH_1}.exe")
 534       endif()
 535       if(EXISTS "${_comp}")
 536         file(TO_CMAKE_PATH "${_comp}" _comp)
 537         set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE)
 538       endif()
 539     endif()
 540   else()
 541     execute_process(
 542       COMMAND "${CMAKE_${lang}_COMPILER}"
 543               ${CMAKE_${lang}_COMPILER_ID_ARG1}
 544               ${userflags}
 545               ${testflags}
 546               ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS}
 547               "${src}"
 548       WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
 549       OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 550       ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
 551       RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
 552       )
 553     if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "exec: [^\n]*\\((/[^,\n]*/cpp),CMakeFortranCompilerId.F")
 554       set(_cpp "${CMAKE_MATCH_1}")
 555       if(EXISTS "${_cpp}")
 556         set(CMAKE_${lang}_COMPILER_ID_CPP "${_cpp}" PARENT_SCOPE)
 557       endif()
 558     endif()
 559   endif()
 560
 561   # Check the result of compilation.
 562   if(CMAKE_${lang}_COMPILER_ID_RESULT
 563      # Intel Fortran warns and ignores preprocessor lines without /fpp
 564      OR CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "Bad # preprocessor line"
 565      )
 566     # Compilation failed.
 567     set(MSG
 568       "Compiling the ${lang} compiler identification source file \"${src}\" failed.
 569 ${COMPILER_DESCRIPTION}
 570 The output was:
 571 ${CMAKE_${lang}_COMPILER_ID_RESULT}
 572 ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
 573
 574 ")
 575     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}")
 576     #if(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
 577     #  message(FATAL_ERROR "${MSG}")
 578     #endif()
 579
 580     # No output files should be inspected.
 581     set(COMPILER_${lang}_PRODUCED_FILES)
 582     set(COMPILER_${lang}_PRODUCED_OUTPUT)
 583   else()
 584     # Compilation succeeded.
 585     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 586       "Compiling the ${lang} compiler identification source file \"${src}\" succeeded.
 587 ${COMPILER_DESCRIPTION}
 588 The output was:
 589 ${CMAKE_${lang}_COMPILER_ID_RESULT}
 590 ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
 591
 592 ")
 593
 594     # Find the executable produced by the compiler, try all files in the
 595     # binary dir.
 596     string(REGEX REPLACE "([][])" "[\\1]" _glob_id_dir "${CMAKE_${lang}_COMPILER_ID_DIR}")
 597     file(GLOB files
 598       RELATIVE ${CMAKE_${lang}_COMPILER_ID_DIR}
 599
 600       # normal case
 601       ${_glob_id_dir}/*
 602
 603       # com.apple.package-type.bundle.unit-test
 604       ${_glob_id_dir}/*.xctest/*
 605
 606       # com.apple.product-type.framework
 607       ${_glob_id_dir}/*.framework/*
 608       )
 609     list(REMOVE_ITEM files "${src}")
 610     set(COMPILER_${lang}_PRODUCED_FILES "")
 611     foreach(file ${files})
 612       if(NOT IS_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}/${file})
 613         list(APPEND COMPILER_${lang}_PRODUCED_FILES ${file})
 614         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 615           "Compilation of the ${lang} compiler identification source \""
 616           "${src}\" produced \"${file}\"\n\n")
 617       endif()
 618     endforeach()
 619
 620     if(NOT COMPILER_${lang}_PRODUCED_FILES)
 621       # No executable was found.
 622       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 623         "Compilation of the ${lang} compiler identification source \""
 624         "${src}\" did not produce an executable in \""
 625         "${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n")
 626     endif()
 627
 628     set(COMPILER_${lang}_PRODUCED_OUTPUT "${CMAKE_${lang}_COMPILER_ID_OUTPUT}")
 629   endif()
 630
 631   # Return the files produced by the compilation.
 632   set(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
 633   set(COMPILER_${lang}_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE)
 634
 635 endfunction()
 636
 637 #-----------------------------------------------------------------------------
 638 # Function to extract the compiler id from compiler output.
 639 function(CMAKE_DETERMINE_COMPILER_ID_MATCH_VENDOR lang output)
 640   foreach(vendor ${CMAKE_${lang}_COMPILER_ID_MATCH_VENDORS})
 641     if(output MATCHES "${CMAKE_${lang}_COMPILER_ID_MATCH_VENDOR_REGEX_${vendor}}")
 642       set(CMAKE_${lang}_COMPILER_ID "${vendor}")
 643     endif()
 644   endforeach()
 645   set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
 646 endfunction()
 647
 648 #-----------------------------------------------------------------------------
 649 # Function to extract the compiler id from an executable.
 650 function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
 651   # Look for a compiler id if not yet known.
 652   if(NOT CMAKE_${lang}_COMPILER_ID)
 653     # Read the compiler identification string from the executable file.
 654     set(COMPILER_ID)
 655     set(COMPILER_VERSION)
 656     set(COMPILER_VERSION_MAJOR 0)
 657     set(COMPILER_VERSION_MINOR 0)
 658     set(COMPILER_VERSION_PATCH 0)
 659     set(COMPILER_VERSION_TWEAK 0)
 660     set(COMPILER_VERSION_INTERNAL "")
 661     set(HAVE_COMPILER_VERSION_MAJOR 0)
 662     set(HAVE_COMPILER_VERSION_MINOR 0)
 663     set(HAVE_COMPILER_VERSION_PATCH 0)
 664     set(HAVE_COMPILER_VERSION_TWEAK 0)
 665     set(COMPILER_WRAPPER)
 666     set(DIGIT_VALUE_1 1)
 667     set(DIGIT_VALUE_2 10)
 668     set(DIGIT_VALUE_3 100)
 669     set(DIGIT_VALUE_4 1000)
 670     set(DIGIT_VALUE_5 10000)
 671     set(DIGIT_VALUE_6 100000)
 672     set(DIGIT_VALUE_7 1000000)
 673     set(DIGIT_VALUE_8 10000000)
 674     set(PLATFORM_ID)
 675     set(ARCHITECTURE_ID)
 676     set(SIMULATE_ID)
 677     set(SIMULATE_VERSION)
 678     foreach(encoding "" "ENCODING;UTF-16LE" "ENCODING;UTF-16BE")
 679       file(STRINGS "${file}" CMAKE_${lang}_COMPILER_ID_STRINGS
 680         LIMIT_COUNT 38 ${encoding}
 681         REGEX ".?I.?N.?F.?O.?:.?[A-Za-z0-9_]+\\[[^]]*\\]")
 682       if(NOT CMAKE_${lang}_COMPILER_ID_STRINGS STREQUAL "")
 683         break()
 684       endif()
 685     endforeach()
 686     set(COMPILER_ID_TWICE)
 687     # With the IAR Compiler, some strings are found twice, first time as incomplete
 688     # list like "?<Constant "INFO:compiler[IAR]">".  Remove the incomplete copies.
 689     list(FILTER CMAKE_${lang}_COMPILER_ID_STRINGS EXCLUDE REGEX "\\?<Constant \\\"")
 690     # In C# binaries, some strings are found more than once.
 691     list(REMOVE_DUPLICATES CMAKE_${lang}_COMPILER_ID_STRINGS)
 692     foreach(info ${CMAKE_${lang}_COMPILER_ID_STRINGS})
 693       # The IAR-AVR compiler uses a binary format that places a '6'
 694       # character (0x34) before each character in the string.  Strip
 695       # out these characters without removing any legitamate characters.
 696       if("${info}" MATCHES "(.)I.N.F.O.:.")
 697         string(REGEX REPLACE "${CMAKE_MATCH_1}(.)" "\\1" info "${info}")
 698       endif()
 699       if("${info}" MATCHES "INFO:compiler\\[([^]\"]*)\\]")
 700         if(COMPILER_ID)
 701           set(COMPILER_ID_TWICE 1)
 702         endif()
 703         set(COMPILER_ID "${CMAKE_MATCH_1}")
 704       endif()
 705       if("${info}" MATCHES "INFO:platform\\[([^]\"]*)\\]")
 706         set(PLATFORM_ID "${CMAKE_MATCH_1}")
 707       endif()
 708       if("${info}" MATCHES "INFO:arch\\[([^]\"]*)\\]")
 709         set(ARCHITECTURE_ID "${CMAKE_MATCH_1}")
 710       endif()
 711       if("${info}" MATCHES "INFO:compiler_version\\[([^]\"]*)\\]")
 712         string(REGEX REPLACE "^0+([0-9]+)" "\\1" COMPILER_VERSION "${CMAKE_MATCH_1}")
 713         string(REGEX REPLACE "\\.0+([0-9])" ".\\1" COMPILER_VERSION "${COMPILER_VERSION}")
 714       endif()
 715       if("${info}" MATCHES "INFO:compiler_version_internal\\[([^]\"]*)\\]")
 716         string(REGEX REPLACE "^0+([0-9])" "\\1" COMPILER_VERSION_INTERNAL "${CMAKE_MATCH_1}")
 717         string(REGEX REPLACE "\\.0+([0-9])" ".\\1" COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}")
 718       endif()
 719       foreach(comp MAJOR MINOR PATCH TWEAK)
 720         foreach(digit 1 2 3 4 5 6 7 8 9)
 721           if("${info}" MATCHES "INFO:compiler_version_${comp}_digit_${digit}\\[([0-9])\\]")
 722             set(value ${CMAKE_MATCH_1})
 723             math(EXPR COMPILER_VERSION_${comp} "${COMPILER_VERSION_${comp}} + ${value} * ${DIGIT_VALUE_${digit}}")
 724             set(HAVE_COMPILER_VERSION_${comp} 1)
 725           endif()
 726         endforeach()
 727       endforeach()
 728       if("${info}" MATCHES "INFO:compiler_wrapper\\[([^]\"]*)\\]")
 729         set(COMPILER_WRAPPER "${CMAKE_MATCH_1}")
 730       endif()
 731       if("${info}" MATCHES "INFO:simulate\\[([^]\"]*)\\]")
 732         set(SIMULATE_ID "${CMAKE_MATCH_1}")
 733       endif()
 734       if("${info}" MATCHES "INFO:simulate_version\\[([^]\"]*)\\]")
 735         string(REGEX REPLACE "^0+([0-9])" "\\1" SIMULATE_VERSION "${CMAKE_MATCH_1}")
 736         string(REGEX REPLACE "\\.0+([0-9])" ".\\1" SIMULATE_VERSION "${SIMULATE_VERSION}")
 737       endif()
 738       if("${info}" MATCHES "INFO:qnxnto\\[\\]")
 739         set(COMPILER_QNXNTO 1)
 740       endif()
 741       if("${info}" MATCHES "INFO:dialect_default\\[([^]\"]*)\\]")
 742         set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_MATCH_1}")
 743       endif()
 744     endforeach()
 745
 746     # Construct compiler version from components if needed.
 747     if(NOT DEFINED COMPILER_VERSION AND HAVE_COMPILER_VERSION_MAJOR)
 748       set(COMPILER_VERSION "${COMPILER_VERSION_MAJOR}")
 749       if(HAVE_COMPILER_VERSION_MINOR)
 750         string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_MINOR}")
 751         if(HAVE_COMPILER_VERSION_PATCH)
 752           string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_PATCH}")
 753           if(HAVE_COMPILER_VERSION_TWEAK)
 754             string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_TWEAK}")
 755           endif()
 756         endif()
 757       endif()
 758     endif()
 759
 760     # Detect the exact architecture from the PE header.
 761     if(WIN32)
 762       # The offset to the PE signature is stored at 0x3c.
 763       file(READ ${file} peoffsethex LIMIT 1 OFFSET 60 HEX)
 764       if(NOT peoffsethex STREQUAL "")
 765         string(SUBSTRING "${peoffsethex}" 0 1 peoffsethex1)
 766         string(SUBSTRING "${peoffsethex}" 1 1 peoffsethex2)
 767         set(peoffsetexpression "${peoffsethex1} * 16 + ${peoffsethex2}")
 768         string(REPLACE "a" "10" peoffsetexpression "${peoffsetexpression}")
 769         string(REPLACE "b" "11" peoffsetexpression "${peoffsetexpression}")
 770         string(REPLACE "c" "12" peoffsetexpression "${peoffsetexpression}")
 771         string(REPLACE "d" "13" peoffsetexpression "${peoffsetexpression}")
 772         string(REPLACE "e" "14" peoffsetexpression "${peoffsetexpression}")
 773         string(REPLACE "f" "15" peoffsetexpression "${peoffsetexpression}")
 774         math(EXPR peoffset "${peoffsetexpression}")
 775
 776         file(READ ${file} peheader LIMIT 6 OFFSET ${peoffset} HEX)
 777         if(peheader STREQUAL "50450000a201")
 778           set(ARCHITECTURE_ID "SH3")
 779         elseif(peheader STREQUAL "50450000a301")
 780           set(ARCHITECTURE_ID "SH3DSP")
 781         elseif(peheader STREQUAL "50450000a601")
 782           set(ARCHITECTURE_ID "SH4")
 783         elseif(peheader STREQUAL "50450000a801")
 784           set(ARCHITECTURE_ID "SH5")
 785         endif()
 786       endif()
 787     endif()
 788
 789     # Check if a valid compiler and platform were found.
 790     if(COMPILER_ID AND NOT COMPILER_ID_TWICE)
 791       set(CMAKE_${lang}_COMPILER_ID "${COMPILER_ID}")
 792       set(CMAKE_${lang}_PLATFORM_ID "${PLATFORM_ID}")
 793       set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
 794       set(MSVC_${lang}_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
 795       set(CMAKE_${lang}_COMPILER_VERSION "${COMPILER_VERSION}")
 796       set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}")
 797       set(CMAKE_${lang}_SIMULATE_ID "${SIMULATE_ID}")
 798       set(CMAKE_${lang}_SIMULATE_VERSION "${SIMULATE_VERSION}")
 799     endif()
 800
 801     # Check the compiler identification string.
 802     if(CMAKE_${lang}_COMPILER_ID)
 803       # The compiler identification was found.
 804       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 805         "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \""
 806         "${file}\"\n\n")
 807     else()
 808       # The compiler identification could not be found.
 809       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 810         "The ${lang} compiler identification could not be found in \""
 811         "${file}\"\n\n")
 812     endif()
 813   endif()
 814
 815   # try to figure out the executable format: ELF, COFF, Mach-O
 816   if(NOT CMAKE_EXECUTABLE_FORMAT)
 817     file(READ ${file} CMAKE_EXECUTABLE_MAGIC LIMIT 4 HEX)
 818
 819     # ELF files start with 0x7f"ELF"
 820     if("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
 821       set(CMAKE_EXECUTABLE_FORMAT "ELF" CACHE INTERNAL "Executable file format")
 822     endif()
 823
 824 #    # COFF (.exe) files start with "MZ"
 825 #    if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
 826 #      set(CMAKE_EXECUTABLE_FORMAT "COFF" CACHE STRING "Executable file format")
 827 #    endif()
 828 #
 829     # Mach-O files start with MH_MAGIC or MH_CIGAM
 830     if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface|cefaedfe|feedfacf|cffaedfe")
 831       set(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
 832     endif()
 833
 834   endif()
 835   if(NOT DEFINED CMAKE_EXECUTABLE_FORMAT)
 836     set(CMAKE_EXECUTABLE_FORMAT)
 837   endif()
 838   # Return the information extracted.
 839   set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
 840   set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
 841   set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}" PARENT_SCOPE)
 842   set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
 843     PARENT_SCOPE)
 844   set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE)
 845   set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${CMAKE_${lang}_COMPILER_VERSION_INTERNAL}" PARENT_SCOPE)
 846   set(CMAKE_${lang}_COMPILER_WRAPPER "${COMPILER_WRAPPER}" PARENT_SCOPE)
 847   set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE)
 848   set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE)
 849   set(CMAKE_EXECUTABLE_FORMAT "${CMAKE_EXECUTABLE_FORMAT}" PARENT_SCOPE)
 850   set(COMPILER_QNXNTO "${COMPILER_QNXNTO}" PARENT_SCOPE)
 851   set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE)
 852 endfunction()
 853
 854 #-----------------------------------------------------------------------------
 855 # Function to query the compiler vendor.
 856 # This uses a table with entries of the form
 857 #   list(APPEND CMAKE_${lang}_COMPILER_ID_VENDORS ${vendor})
 858 #   set(CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor} -some-vendor-flag)
 859 #   set(CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor} "Some Vendor Output")
 860 # We try running the compiler with the flag for each vendor and
 861 # matching its regular expression in the output.
 862 function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang userflags)
 863
 864   if(NOT CMAKE_${lang}_COMPILER_ID_DIR)
 865     # We get here when this function is called not from within CMAKE_DETERMINE_COMPILER_ID()
 866     # This is done e.g. for detecting the compiler ID for assemblers.
 867     # Compute the directory in which to run the test and Create a clean working directory.
 868     set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang})
 869     file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
 870     file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
 871   endif()
 872
 873
 874   foreach(vendor ${CMAKE_${lang}_COMPILER_ID_VENDORS})
 875     set(flags ${CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor}})
 876     set(regex ${CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor}})
 877     execute_process(
 878       COMMAND "${CMAKE_${lang}_COMPILER}"
 879       ${CMAKE_${lang}_COMPILER_ID_ARG1}
 880       ${userflags}
 881       ${flags}
 882       WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
 883       OUTPUT_VARIABLE output ERROR_VARIABLE output
 884       RESULT_VARIABLE result
 885       TIMEOUT 10
 886       )
 887
 888     if("${output}" MATCHES "${regex}")
 889       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 890         "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
 891         "matched \"${regex}\":\n${output}")
 892       set(CMAKE_${lang}_COMPILER_ID "${vendor}" PARENT_SCOPE)
 893       set(CMAKE_${lang}_COMPILER_ID_OUTPUT "${output}" PARENT_SCOPE)
 894       break()
 895     else()
 896       if("${result}" MATCHES  "timeout")
 897         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 898           "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
 899           "terminated after 10 s due to timeout.")
 900       else()
 901         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 902           "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
 903           "did not match \"${regex}\":\n${output}")
 904        endif()
 905     endif()
 906   endforeach()
 907 endfunction()
 908
 909 function(CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX lang userflags)
 910   # Run this MSVC-compatible compiler to detect what the /showIncludes
 911   # option displays.  We can use a C source even with the C++ compiler
 912   # because MSVC-compatible compilers handle both and show the same output.
 913   set(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes)
 914   file(WRITE ${showdir}/foo.h "\n")
 915   file(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n")
 916   execute_process(
 917     COMMAND "${CMAKE_${lang}_COMPILER}"
 918             ${CMAKE_${lang}_COMPILER_ID_ARG1}
 919             ${userflags}
 920             /nologo /showIncludes /c main.c
 921     WORKING_DIRECTORY ${showdir}
 922     OUTPUT_VARIABLE out
 923     ERROR_VARIABLE err
 924     RESULT_VARIABLE res
 925     ENCODING AUTO # cl prints in current code page
 926     )
 927   if(res EQUAL 0 AND "${out}" MATCHES "(^|\n)([^:\n]*:[^:\n]*:[ \t]*)")
 928     set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_MATCH_2}" PARENT_SCOPE)
 929   else()
 930     set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "" PARENT_SCOPE)
 931   endif()
 932 endfunction()