1 # Distributed under the OSI-approved BSD 3-Clause License. See accompanying
2 # file Copyright.txt or https://cmake.org/licensing for details.
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
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}")
14 # Make sure user-specified compiler flags are used.
15 if(CMAKE_${lang}_FLAGS)
16 set(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS})
18 set(CMAKE_${lang}_COMPILER_ID_FLAGS $ENV{${flagvar}})
20 string(REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}")
22 # Compute the directory in which to run the test.
23 set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang})
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}
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)
37 foreach(file ${COMPILER_${lang}_PRODUCED_FILES})
38 CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}")
40 if(CMAKE_${lang}_COMPILER_ID)
44 if(CMAKE_${lang}_COMPILER_ID)
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)
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}")
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")
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)
76 COMMAND "${CMAKE_${lang}_COMPILER}"
78 OUTPUT_VARIABLE output ERROR_VARIABLE output
79 RESULT_VARIABLE result
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}")
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)
92 COMMAND "${CMAKE_${lang}_COMPILER}"
94 OUTPUT_VARIABLE output ERROR_VARIABLE output
95 RESULT_VARIABLE result
98 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
99 "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" -version\n"
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")
111 if (COMPILER_QNXNTO AND CMAKE_${lang}_COMPILER_ID STREQUAL "GNU")
113 COMMAND "${CMAKE_${lang}_COMPILER}"
115 OUTPUT_VARIABLE output ERROR_VARIABLE output
116 RESULT_VARIABLE result
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.
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")
131 if(CMAKE_GENERATOR STREQUAL "Ninja" AND MSVC_${lang}_ARCHITECTURE_ID)
132 foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "")
133 CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX(${lang} "${userflags}")
136 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "")
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")
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")
153 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU")
156 set(_variant " with ${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}-like command-line")
158 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU")
161 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "")
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}")
171 if(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xIAR")
172 set(_archid " ${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}")
176 message(STATUS "The ${lang} compiler identification is "
177 "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}${_variant}")
182 message(STATUS "The ${lang} compiler identification is unknown")
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)
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}"
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)
207 include(CMakeCompilerIdDetection)
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)
215 compiler_id_detection(CMAKE_${lang}_COMPILER_ID_CONTENT ${lang}
218 PLATFORM_DEFAULT_COMPILER
222 string(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY)
223 file(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}")
226 #-----------------------------------------------------------------------------
227 # Function to build the compiler id source file and look for output
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}")
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}
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)?)?|[Cc][Ll][Aa][Nn][Gg][Cc][Ll])$")
250 set(id_cl_var "ClangClExecutable")
251 elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "v[0-9]+_clang_.*")
256 if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
259 if(lang STREQUAL CXX)
261 set(id_clang clang++)
266 elseif(lang STREQUAL Fortran)
270 elseif(lang STREQUAL CSharp)
274 elseif(NOT "${vs_version}" VERSION_LESS 10)
278 set(id_version ${vs_version}.00)
282 if(CMAKE_VS_PLATFORM_TOOLSET)
283 if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
284 set(id_toolset "<NdkToolchainVersion>${CMAKE_VS_PLATFORM_TOOLSET}</NdkToolchainVersion>")
286 set(id_toolset "<PlatformToolset>${CMAKE_VS_PLATFORM_TOOLSET}</PlatformToolset>")
287 if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "Intel")
290 if(CMAKE_VS_PLATFORM_TOOLSET_VERSION)
292 if(CMAKE_VS_PLATFORM_TOOLSET_VERSION VERSION_GREATER_EQUAL "14.20")
293 if(EXISTS "${CMAKE_GENERATOR_INSTANCE}/VC/Auxiliary/Build.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}/Microsoft.VCToolsVersion.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}.props")
297 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\" />")
303 set(id_toolset_version_props "")
305 if(CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE)
306 set(id_PreferredToolArchitecture "<PreferredToolArchitecture>${CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE}</PreferredToolArchitecture>")
308 set(id_PreferredToolArchitecture "")
310 if(CMAKE_SYSTEM_NAME STREQUAL "WindowsPhone")
311 set(id_system "<ApplicationType>Windows Phone</ApplicationType>")
312 elseif(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
313 set(id_system "<ApplicationType>Windows Store</ApplicationType>")
317 if(id_system AND CMAKE_SYSTEM_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
318 set(id_system_version "<ApplicationTypeRevision>${CMAKE_MATCH_1}</ApplicationTypeRevision>")
320 set(id_system_version "")
322 if(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION)
323 set(id_WindowsTargetPlatformVersion "<WindowsTargetPlatformVersion>${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}</WindowsTargetPlatformVersion>")
325 if(CMAKE_VS_PLATFORM_TOOLSET_VCTARGETS_CUSTOM_DIR)
326 set(id_ToolsetVCTargetsDir "<VCTargetsPath>${CMAKE_VS_PLATFORM_TOOLSET_VCTARGETS_CUSTOM_DIR}</VCTargetsPath>")
328 set(id_CustomGlobals "")
329 foreach(pair IN LISTS CMAKE_VS_GLOBALS)
330 if("${pair}" MATCHES "([^=]+)=(.*)$")
331 string(APPEND id_CustomGlobals "<${CMAKE_MATCH_1}>${CMAKE_MATCH_2}</${CMAKE_MATCH_1}>\n ")
334 if(id_platform STREQUAL ARM64)
335 set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARM64Support>true</WindowsSDKDesktopARM64Support>")
336 elseif(id_platform STREQUAL ARM)
337 set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>")
339 set(id_WindowsSDKDesktopARMSupport "")
341 if(CMAKE_VS_WINCE_VERSION)
342 set(id_entrypoint "mainACRTStartup")
343 if("${vs_version}" VERSION_LESS 9)
351 set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
353 set(id_compile "ClCompile")
355 set(id_PostBuildEvent_Command "echo CMAKE_${lang}_COMPILER=$(${id_cl_var})")
357 set(id_PostBuildEvent_Command "for %%i in (${id_cl}) do %40echo CMAKE_${lang}_COMPILER=%%~$PATH:i")
359 set(id_Import_props "")
360 set(id_Import_targets "")
361 set(id_ItemDefinitionGroup_entry "")
362 set(id_Link_AdditionalDependencies "")
363 if(lang STREQUAL CUDA)
364 if(NOT CMAKE_VS_PLATFORM_TOOLSET_CUDA)
365 message(FATAL_ERROR "No CUDA toolset found.")
367 set(cuda_tools "CUDA ${CMAKE_VS_PLATFORM_TOOLSET_CUDA}")
368 set(id_compile "CudaCompile")
369 set(id_ItemDefinitionGroup_entry "<CudaCompile><AdditionalOptions>%(AdditionalOptions)-v</AdditionalOptions></CudaCompile>")
370 set(id_PostBuildEvent_Command [[echo CMAKE_CUDA_COMPILER=$(CudaToolkitBinDir)\nvcc.exe]])
371 if(CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR)
372 set(id_CudaToolkitCustomDir "<CudaToolkitCustomDir>${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}nvcc</CudaToolkitCustomDir>")
373 string(CONCAT id_Import_props "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}\\CUDAVisualStudioIntegration\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.props\" />")
374 string(CONCAT id_Import_targets "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}\\CUDAVisualStudioIntegration\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.targets\" />")
376 string(CONCAT id_Import_props [[<Import Project="$(VCTargetsPath)\BuildCustomizations\]] "${cuda_tools}" [[.props" />]])
377 string(CONCAT id_Import_targets [[<Import Project="$(VCTargetsPath)\BuildCustomizations\]] "${cuda_tools}" [[.targets" />]])
379 if(CMAKE_VS_PLATFORM_NAME STREQUAL x64)
380 set(id_ItemDefinitionGroup_entry "<CudaCompile><TargetMachinePlatform>64</TargetMachinePlatform><AdditionalOptions>%(AdditionalOptions)-v</AdditionalOptions></CudaCompile>")
382 set(id_Link_AdditionalDependencies "<AdditionalDependencies>cudart.lib</AdditionalDependencies>")
384 configure_file(${CMAKE_ROOT}/Modules/CompilerId/VS-${v}.${ext}.in
385 ${id_dir}/CompilerId${lang}.${ext} @ONLY)
386 if(CMAKE_VS_MSBUILD_COMMAND AND NOT lang STREQUAL "Fortran")
387 set(command "${CMAKE_VS_MSBUILD_COMMAND}" "CompilerId${lang}.${ext}"
388 "/p:Configuration=Debug" "/p:Platform=${id_platform}" "/p:VisualStudioVersion=${vs_version}.0"
390 elseif(CMAKE_VS_DEVENV_COMMAND)
391 set(command "${CMAKE_VS_DEVENV_COMMAND}" "CompilerId${lang}.${ext}" "/build" "Debug")
398 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
399 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
400 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
401 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
404 set(CMAKE_${lang}_COMPILER_ID_RESULT 1)
405 set(CMAKE_${lang}_COMPILER_ID_OUTPUT "VS environment not known to support ${lang}")
407 # Match the compiler location line printed out.
408 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "CMAKE_${lang}_COMPILER=([^%\r\n]+)[\r\n]")
409 # Strip VS diagnostic output from the end of the line.
410 string(REGEX REPLACE " \\(TaskId:[0-9]*\\)$" "" _comp "${CMAKE_MATCH_1}")
411 if(EXISTS "${_comp}")
412 file(TO_CMAKE_PATH "${_comp}" _comp)
413 set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE)
416 elseif("${CMAKE_GENERATOR}" MATCHES "Xcode")
417 set(id_lang "${lang}")
418 set(id_type ${CMAKE_${lang}_COMPILER_XCODE_TYPE})
419 set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
421 if(CMAKE_XCODE_PLATFORM_TOOLSET)
422 set(id_toolset "GCC_VERSION = ${CMAKE_XCODE_PLATFORM_TOOLSET};")
426 if("${lang}" STREQUAL "Swift")
427 if(CMAKE_Swift_LANGUAGE_VERSION)
428 set(id_lang_version "SWIFT_VERSION = ${CMAKE_Swift_LANGUAGE_VERSION};")
429 elseif(XCODE_VERSION VERSION_GREATER_EQUAL 10.2)
430 set(id_lang_version "SWIFT_VERSION = 4.0;")
431 elseif(XCODE_VERSION VERSION_GREATER_EQUAL 8.3)
432 set(id_lang_version "SWIFT_VERSION = 3.0;")
434 set(id_lang_version "SWIFT_VERSION = 2.3;")
437 set(id_lang_version "")
439 if(CMAKE_OSX_DEPLOYMENT_TARGET)
440 set(id_deployment_target
441 "MACOSX_DEPLOYMENT_TARGET = \"${CMAKE_OSX_DEPLOYMENT_TARGET}\";")
443 set(id_deployment_target "")
445 set(id_product_type "com.apple.product-type.tool")
446 if(CMAKE_OSX_SYSROOT)
447 set(id_sdkroot "SDKROOT = \"${CMAKE_OSX_SYSROOT}\";")
448 if(CMAKE_OSX_SYSROOT MATCHES "(^|/)[Ii][Pp][Hh][Oo][Nn][Ee]" OR
449 CMAKE_OSX_SYSROOT MATCHES "(^|/)[Aa][Pp][Pp][Ll][Ee][Tt][Vv]")
450 set(id_product_type "com.apple.product-type.bundle.unit-test")
451 elseif(CMAKE_OSX_SYSROOT MATCHES "(^|/)[Ww][Aa][Tt][Cc][Hh]")
452 set(id_product_type "com.apple.product-type.framework")
457 set(id_clang_cxx_library "")
458 set(stdlib_regex "(^| )(-stdlib=)([^ ]+)( |$)")
459 string(REGEX MATCHALL "${stdlib_regex}" all_stdlib_matches "${CMAKE_CXX_FLAGS}")
460 if(all_stdlib_matches)
461 list(GET all_stdlib_matches "-1" last_stdlib_match)
462 if(last_stdlib_match MATCHES "${stdlib_regex}")
463 set(id_clang_cxx_library "CLANG_CXX_LIBRARY = \"${CMAKE_MATCH_3}\";")
466 configure_file(${CMAKE_ROOT}/Modules/CompilerId/Xcode-3.pbxproj.in
467 ${id_dir}/CompilerId${lang}.xcodeproj/project.pbxproj @ONLY)
468 unset(_ENV_MACOSX_DEPLOYMENT_TARGET)
469 if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
470 set(_ENV_MACOSX_DEPLOYMENT_TARGET "$ENV{MACOSX_DEPLOYMENT_TARGET}")
471 set(ENV{MACOSX_DEPLOYMENT_TARGET} "")
473 execute_process(COMMAND xcodebuild
474 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
475 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
476 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
477 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
479 if(DEFINED _ENV_MACOSX_DEPLOYMENT_TARGET)
480 set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_ENV_MACOSX_DEPLOYMENT_TARGET}")
483 if(DEFINED CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_REGEX)
484 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "${CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_REGEX}")
485 set(_comp "${CMAKE_MATCH_${CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_INDEX}}")
486 if(EXISTS "${_comp}")
487 set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE)
491 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "ARCHS=([^%\r\n]+)[\r\n]")
492 set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_MATCH_1}")
493 separate_arguments(CMAKE_${lang}_XCODE_ARCHS)
494 set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_${lang}_XCODE_ARCHS}" PARENT_SCOPE)
496 elseif("${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI")
497 set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
499 if (GHS_PRIMARY_TARGET)
500 set(ghs_primary_target "${GHS_PRIMARY_TARGET}")
502 set(ghs_primary_target "${CMAKE_GENERATOR_PLATFORM}_${GHS_TARGET_PLATFORM}.tgt")
504 if ("${GHS_TARGET_PLATFORM}" MATCHES "integrity")
505 set(bsp_name "macro GHS_BSP=${GHS_BSP_NAME}")
506 set(os_dir "macro GHS_OS=${GHS_OS_DIR}")
508 set(command "${CMAKE_MAKE_PROGRAM}" "-commands" "-top" "GHS_default.gpj")
509 configure_file(${CMAKE_ROOT}/Modules/CompilerId/GHS_default.gpj.in
510 ${id_dir}/GHS_default.gpj @ONLY)
511 configure_file(${CMAKE_ROOT}/Modules/CompilerId/GHS_lib.gpj.in
512 ${id_dir}/GHS_lib.gpj @ONLY)
513 execute_process(COMMAND ${command}
514 WORKING_DIRECTORY ${id_dir}
515 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
516 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
517 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
519 # Match the compiler location line printed out.
520 set(ghs_toolpath "${CMAKE_MAKE_PROGRAM}")
522 string(REPLACE "/gbuild" "/" ghs_toolpath ${ghs_toolpath})
524 string(REPLACE "/gbuild.exe" "/" ghs_toolpath ${ghs_toolpath})
525 string(REPLACE / "\\\\" ghs_toolpath ${ghs_toolpath})
527 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "(${ghs_toolpath}[^ ]*)")
529 set(_comp "${CMAKE_MATCH_1}")
531 set(_comp "${CMAKE_MATCH_1}.exe")
533 if(EXISTS "${_comp}")
534 file(TO_CMAKE_PATH "${_comp}" _comp)
535 set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE)
540 COMMAND "${CMAKE_${lang}_COMPILER}"
541 ${CMAKE_${lang}_COMPILER_ID_ARG1}
544 ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS}
546 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
547 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
548 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
549 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
551 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "exec: [^\n]*\\((/[^,\n]*/cpp),CMakeFortranCompilerId.F")
552 set(_cpp "${CMAKE_MATCH_1}")
554 set(CMAKE_${lang}_COMPILER_ID_CPP "${_cpp}" PARENT_SCOPE)
559 # Check the result of compilation.
560 if(CMAKE_${lang}_COMPILER_ID_RESULT
561 # Intel Fortran warns and ignores preprocessor lines without /fpp
562 OR CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "Bad # preprocessor line"
564 # Compilation failed.
566 "Compiling the ${lang} compiler identification source file \"${src}\" failed.
567 ${COMPILER_DESCRIPTION}
569 ${CMAKE_${lang}_COMPILER_ID_RESULT}
570 ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
573 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}")
574 #if(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
575 # message(FATAL_ERROR "${MSG}")
578 # No output files should be inspected.
579 set(COMPILER_${lang}_PRODUCED_FILES)
580 set(COMPILER_${lang}_PRODUCED_OUTPUT)
582 # Compilation succeeded.
583 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
584 "Compiling the ${lang} compiler identification source file \"${src}\" succeeded.
585 ${COMPILER_DESCRIPTION}
587 ${CMAKE_${lang}_COMPILER_ID_RESULT}
588 ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
592 # Find the executable produced by the compiler, try all files in the
594 string(REGEX REPLACE "([][])" "[\\1]" _glob_id_dir "${CMAKE_${lang}_COMPILER_ID_DIR}")
596 RELATIVE ${CMAKE_${lang}_COMPILER_ID_DIR}
601 # com.apple.package-type.bundle.unit-test
602 ${_glob_id_dir}/*.xctest/*
604 # com.apple.product-type.framework
605 ${_glob_id_dir}/*.framework/*
607 list(REMOVE_ITEM files "${src}")
608 set(COMPILER_${lang}_PRODUCED_FILES "")
609 foreach(file ${files})
610 if(NOT IS_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}/${file})
611 list(APPEND COMPILER_${lang}_PRODUCED_FILES ${file})
612 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
613 "Compilation of the ${lang} compiler identification source \""
614 "${src}\" produced \"${file}\"\n\n")
618 if(NOT COMPILER_${lang}_PRODUCED_FILES)
619 # No executable was found.
620 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
621 "Compilation of the ${lang} compiler identification source \""
622 "${src}\" did not produce an executable in \""
623 "${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n")
626 set(COMPILER_${lang}_PRODUCED_OUTPUT "${CMAKE_${lang}_COMPILER_ID_OUTPUT}")
629 # Return the files produced by the compilation.
630 set(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
631 set(COMPILER_${lang}_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE)
635 #-----------------------------------------------------------------------------
636 # Function to extract the compiler id from compiler output.
637 function(CMAKE_DETERMINE_COMPILER_ID_MATCH_VENDOR lang output)
638 foreach(vendor ${CMAKE_${lang}_COMPILER_ID_MATCH_VENDORS})
639 if(output MATCHES "${CMAKE_${lang}_COMPILER_ID_MATCH_VENDOR_REGEX_${vendor}}")
640 set(CMAKE_${lang}_COMPILER_ID "${vendor}")
643 set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
646 #-----------------------------------------------------------------------------
647 # Function to extract the compiler id from an executable.
648 function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
649 # Look for a compiler id if not yet known.
650 if(NOT CMAKE_${lang}_COMPILER_ID)
651 # Read the compiler identification string from the executable file.
653 set(COMPILER_VERSION)
654 set(COMPILER_VERSION_MAJOR 0)
655 set(COMPILER_VERSION_MINOR 0)
656 set(COMPILER_VERSION_PATCH 0)
657 set(COMPILER_VERSION_TWEAK 0)
658 set(COMPILER_VERSION_INTERNAL "")
659 set(HAVE_COMPILER_VERSION_MAJOR 0)
660 set(HAVE_COMPILER_VERSION_MINOR 0)
661 set(HAVE_COMPILER_VERSION_PATCH 0)
662 set(HAVE_COMPILER_VERSION_TWEAK 0)
663 set(COMPILER_WRAPPER)
665 set(DIGIT_VALUE_2 10)
666 set(DIGIT_VALUE_3 100)
667 set(DIGIT_VALUE_4 1000)
668 set(DIGIT_VALUE_5 10000)
669 set(DIGIT_VALUE_6 100000)
670 set(DIGIT_VALUE_7 1000000)
671 set(DIGIT_VALUE_8 10000000)
675 set(SIMULATE_VERSION)
676 foreach(encoding "" "ENCODING;UTF-16LE" "ENCODING;UTF-16BE")
677 file(STRINGS "${file}" CMAKE_${lang}_COMPILER_ID_STRINGS
678 LIMIT_COUNT 38 ${encoding}
679 REGEX ".?I.?N.?F.?O.?:.?[A-Za-z0-9_]+\\[[^]]*\\]")
680 if(NOT CMAKE_${lang}_COMPILER_ID_STRINGS STREQUAL "")
684 set(COMPILER_ID_TWICE)
685 # With the IAR Compiler, some strings are found twice, first time as incomplete
686 # list like "?<Constant "INFO:compiler[IAR]">". Remove the incomplete copies.
687 list(FILTER CMAKE_${lang}_COMPILER_ID_STRINGS EXCLUDE REGEX "\\?<Constant \\\"")
688 # In C# binaries, some strings are found more than once.
689 list(REMOVE_DUPLICATES CMAKE_${lang}_COMPILER_ID_STRINGS)
690 foreach(info ${CMAKE_${lang}_COMPILER_ID_STRINGS})
691 # The IAR-AVR compiler uses a binary format that places a '6'
692 # character (0x34) before each character in the string. Strip
693 # out these characters without removing any legitamate characters.
694 if("${info}" MATCHES "(.)I.N.F.O.:.")
695 string(REGEX REPLACE "${CMAKE_MATCH_1}(.)" "\\1" info "${info}")
697 if("${info}" MATCHES "INFO:compiler\\[([^]\"]*)\\]")
699 set(COMPILER_ID_TWICE 1)
701 set(COMPILER_ID "${CMAKE_MATCH_1}")
703 if("${info}" MATCHES "INFO:platform\\[([^]\"]*)\\]")
704 set(PLATFORM_ID "${CMAKE_MATCH_1}")
706 if("${info}" MATCHES "INFO:arch\\[([^]\"]*)\\]")
707 set(ARCHITECTURE_ID "${CMAKE_MATCH_1}")
709 if("${info}" MATCHES "INFO:compiler_version\\[([^]\"]*)\\]")
710 string(REGEX REPLACE "^0+([0-9]+)" "\\1" COMPILER_VERSION "${CMAKE_MATCH_1}")
711 string(REGEX REPLACE "\\.0+([0-9])" ".\\1" COMPILER_VERSION "${COMPILER_VERSION}")
713 if("${info}" MATCHES "INFO:compiler_version_internal\\[([^]\"]*)\\]")
714 string(REGEX REPLACE "^0+([0-9])" "\\1" COMPILER_VERSION_INTERNAL "${CMAKE_MATCH_1}")
715 string(REGEX REPLACE "\\.0+([0-9])" ".\\1" COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}")
717 foreach(comp MAJOR MINOR PATCH TWEAK)
718 foreach(digit 1 2 3 4 5 6 7 8 9)
719 if("${info}" MATCHES "INFO:compiler_version_${comp}_digit_${digit}\\[([0-9])\\]")
720 set(value ${CMAKE_MATCH_1})
721 math(EXPR COMPILER_VERSION_${comp} "${COMPILER_VERSION_${comp}} + ${value} * ${DIGIT_VALUE_${digit}}")
722 set(HAVE_COMPILER_VERSION_${comp} 1)
726 if("${info}" MATCHES "INFO:compiler_wrapper\\[([^]\"]*)\\]")
727 set(COMPILER_WRAPPER "${CMAKE_MATCH_1}")
729 if("${info}" MATCHES "INFO:simulate\\[([^]\"]*)\\]")
730 set(SIMULATE_ID "${CMAKE_MATCH_1}")
732 if("${info}" MATCHES "INFO:simulate_version\\[([^]\"]*)\\]")
733 string(REGEX REPLACE "^0+([0-9])" "\\1" SIMULATE_VERSION "${CMAKE_MATCH_1}")
734 string(REGEX REPLACE "\\.0+([0-9])" ".\\1" SIMULATE_VERSION "${SIMULATE_VERSION}")
736 if("${info}" MATCHES "INFO:qnxnto\\[\\]")
737 set(COMPILER_QNXNTO 1)
739 if("${info}" MATCHES "INFO:dialect_default\\[([^]\"]*)\\]")
740 set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_MATCH_1}")
744 # Construct compiler version from components if needed.
745 if(NOT DEFINED COMPILER_VERSION AND HAVE_COMPILER_VERSION_MAJOR)
746 set(COMPILER_VERSION "${COMPILER_VERSION_MAJOR}")
747 if(HAVE_COMPILER_VERSION_MINOR)
748 string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_MINOR}")
749 if(HAVE_COMPILER_VERSION_PATCH)
750 string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_PATCH}")
751 if(HAVE_COMPILER_VERSION_TWEAK)
752 string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_TWEAK}")
758 # Detect the exact architecture from the PE header.
760 # The offset to the PE signature is stored at 0x3c.
761 file(READ ${file} peoffsethex LIMIT 1 OFFSET 60 HEX)
762 if(NOT peoffsethex STREQUAL "")
763 string(SUBSTRING "${peoffsethex}" 0 1 peoffsethex1)
764 string(SUBSTRING "${peoffsethex}" 1 1 peoffsethex2)
765 set(peoffsetexpression "${peoffsethex1} * 16 + ${peoffsethex2}")
766 string(REPLACE "a" "10" peoffsetexpression "${peoffsetexpression}")
767 string(REPLACE "b" "11" peoffsetexpression "${peoffsetexpression}")
768 string(REPLACE "c" "12" peoffsetexpression "${peoffsetexpression}")
769 string(REPLACE "d" "13" peoffsetexpression "${peoffsetexpression}")
770 string(REPLACE "e" "14" peoffsetexpression "${peoffsetexpression}")
771 string(REPLACE "f" "15" peoffsetexpression "${peoffsetexpression}")
772 math(EXPR peoffset "${peoffsetexpression}")
774 file(READ ${file} peheader LIMIT 6 OFFSET ${peoffset} HEX)
775 if(peheader STREQUAL "50450000a201")
776 set(ARCHITECTURE_ID "SH3")
777 elseif(peheader STREQUAL "50450000a301")
778 set(ARCHITECTURE_ID "SH3DSP")
779 elseif(peheader STREQUAL "50450000a601")
780 set(ARCHITECTURE_ID "SH4")
781 elseif(peheader STREQUAL "50450000a801")
782 set(ARCHITECTURE_ID "SH5")
787 # Check if a valid compiler and platform were found.
788 if(COMPILER_ID AND NOT COMPILER_ID_TWICE)
789 set(CMAKE_${lang}_COMPILER_ID "${COMPILER_ID}")
790 set(CMAKE_${lang}_PLATFORM_ID "${PLATFORM_ID}")
791 set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
792 set(MSVC_${lang}_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
793 set(CMAKE_${lang}_COMPILER_VERSION "${COMPILER_VERSION}")
794 set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}")
795 set(CMAKE_${lang}_SIMULATE_ID "${SIMULATE_ID}")
796 set(CMAKE_${lang}_SIMULATE_VERSION "${SIMULATE_VERSION}")
799 # Check the compiler identification string.
800 if(CMAKE_${lang}_COMPILER_ID)
801 # The compiler identification was found.
802 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
803 "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \""
806 # The compiler identification could not be found.
807 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
808 "The ${lang} compiler identification could not be found in \""
813 # try to figure out the executable format: ELF, COFF, Mach-O
814 if(NOT CMAKE_EXECUTABLE_FORMAT)
815 file(READ ${file} CMAKE_EXECUTABLE_MAGIC LIMIT 4 HEX)
817 # ELF files start with 0x7f"ELF"
818 if("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
819 set(CMAKE_EXECUTABLE_FORMAT "ELF" CACHE INTERNAL "Executable file format")
822 # # COFF (.exe) files start with "MZ"
823 # if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
824 # set(CMAKE_EXECUTABLE_FORMAT "COFF" CACHE STRING "Executable file format")
827 # Mach-O files start with MH_MAGIC or MH_CIGAM
828 if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface|cefaedfe|feedfacf|cffaedfe")
829 set(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
833 if(NOT DEFINED CMAKE_EXECUTABLE_FORMAT)
834 set(CMAKE_EXECUTABLE_FORMAT)
836 # Return the information extracted.
837 set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
838 set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
839 set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}" PARENT_SCOPE)
840 set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
842 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE)
843 set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${CMAKE_${lang}_COMPILER_VERSION_INTERNAL}" PARENT_SCOPE)
844 set(CMAKE_${lang}_COMPILER_WRAPPER "${COMPILER_WRAPPER}" PARENT_SCOPE)
845 set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE)
846 set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE)
847 set(CMAKE_EXECUTABLE_FORMAT "${CMAKE_EXECUTABLE_FORMAT}" PARENT_SCOPE)
848 set(COMPILER_QNXNTO "${COMPILER_QNXNTO}" PARENT_SCOPE)
849 set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE)
852 #-----------------------------------------------------------------------------
853 # Function to query the compiler vendor.
854 # This uses a table with entries of the form
855 # list(APPEND CMAKE_${lang}_COMPILER_ID_VENDORS ${vendor})
856 # set(CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor} -some-vendor-flag)
857 # set(CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor} "Some Vendor Output")
858 # We try running the compiler with the flag for each vendor and
859 # matching its regular expression in the output.
860 function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang userflags)
862 if(NOT CMAKE_${lang}_COMPILER_ID_DIR)
863 # We get here when this function is called not from within CMAKE_DETERMINE_COMPILER_ID()
864 # This is done e.g. for detecting the compiler ID for assemblers.
865 # Compute the directory in which to run the test and Create a clean working directory.
866 set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang})
867 file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
868 file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
872 foreach(vendor ${CMAKE_${lang}_COMPILER_ID_VENDORS})
873 set(flags ${CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor}})
874 set(regex ${CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor}})
876 COMMAND "${CMAKE_${lang}_COMPILER}"
877 ${CMAKE_${lang}_COMPILER_ID_ARG1}
880 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}
881 OUTPUT_VARIABLE output ERROR_VARIABLE output
882 RESULT_VARIABLE result
886 if("${output}" MATCHES "${regex}")
887 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
888 "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
889 "matched \"${regex}\":\n${output}")
890 set(CMAKE_${lang}_COMPILER_ID "${vendor}" PARENT_SCOPE)
891 set(CMAKE_${lang}_COMPILER_ID_OUTPUT "${output}" PARENT_SCOPE)
894 if("${result}" MATCHES "timeout")
895 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
896 "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
897 "terminated after 10 s due to timeout.")
899 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
900 "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" "
901 "did not match \"${regex}\":\n${output}")
907 function(CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX lang userflags)
908 # Run this MSVC-compatible compiler to detect what the /showIncludes
909 # option displays. We can use a C source even with the C++ compiler
910 # because MSVC-compatible compilers handle both and show the same output.
911 set(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes)
912 file(WRITE ${showdir}/foo.h "\n")
913 file(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n")
915 COMMAND "${CMAKE_${lang}_COMPILER}"
916 ${CMAKE_${lang}_COMPILER_ID_ARG1}
918 /nologo /showIncludes /c main.c
919 WORKING_DIRECTORY ${showdir}
923 ENCODING AUTO # cl prints in current code page
925 if(res EQUAL 0 AND "${out}" MATCHES "(^|\n)([^:\n]*:[^:\n]*:[ \t]*)")
926 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_MATCH_2}" PARENT_SCOPE)
928 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "" PARENT_SCOPE)