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