mirror of
https://github.com/Kitware/CMake.git
synced 2026-01-04 04:40:56 -06:00
ef41d49812
In some cases GCC reports *relative* implicit include directories. They are computed adaptively with respect to the current working directory such that the effective implicit include directory is an unchanging absolute path. Teach our implicit include directory extraction to recognize such paths and normalize them. Fixes: #19133
246 lines
9.0 KiB
CMake
246 lines
9.0 KiB
CMake
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
# file Copyright.txt or https://cmake.org/licensing for details.
|
|
|
|
# This is used internally by CMake and should not be included by user code.
|
|
|
|
# helper function that parses implicit include dirs from a single line
|
|
# for compilers that report them that way. on success we return the
|
|
# list of dirs in id_var and set state_var to the 'done' state.
|
|
function(cmake_parse_implicit_include_line line lang id_var log_var state_var)
|
|
# clear variables we append to (avoids possible polution from parent scopes)
|
|
unset(rv)
|
|
set(log "")
|
|
|
|
# Cray compiler (from cray wrapper, via PrgEnv-cray)
|
|
if("${CMAKE_${lang}_COMPILER_ID}" STREQUAL "Cray" AND
|
|
"${line}" MATCHES "^/" AND "${line}" MATCHES "/ccfe |/ftnfe " AND
|
|
"${line}" MATCHES " -isystem| -I")
|
|
string(REGEX MATCHALL " (-I ?|-isystem )([^ ]*)" incs "${line}")
|
|
foreach(inc IN LISTS incs)
|
|
string(REGEX REPLACE " (-I ?|-isystem )([^ ]*)" "\\2" idir "${inc}")
|
|
list(APPEND rv "${idir}")
|
|
endforeach()
|
|
if(rv)
|
|
string(APPEND log " got implicit includes via cray ccfe parser!\n")
|
|
else()
|
|
string(APPEND log " warning: cray ccfe parse failed!\n")
|
|
endif()
|
|
endif()
|
|
|
|
# PGI compiler
|
|
if("${CMAKE_${lang}_COMPILER_ID}" STREQUAL "PGI")
|
|
# pgc++ verbose output differs
|
|
if(("${lang}" STREQUAL "C" OR "${lang}" STREQUAL "Fortran") AND
|
|
"${line}" MATCHES "^/" AND
|
|
"${line}" MATCHES "/pgc |/pgf901 |/pgftnc " AND
|
|
"${line}" MATCHES " -cmdline ")
|
|
# cmdline has unparsed cmdline, remove it
|
|
string(REGEX REPLACE "-cmdline .*" "" line "${line}")
|
|
if("${line}" MATCHES " -nostdinc ")
|
|
set(rv "") # defined, but empty
|
|
else()
|
|
string(REGEX MATCHALL " -stdinc ([^ ]*)" incs "${line}")
|
|
foreach(inc IN LISTS incs)
|
|
string(REGEX REPLACE " -stdinc ([^ ]*)" "\\1" idir "${inc}")
|
|
string(REPLACE ":" ";" idir "${idir}")
|
|
list(APPEND rv ${idir})
|
|
endforeach()
|
|
endif()
|
|
if(DEFINED rv)
|
|
string(APPEND log " got implicit includes via PGI C/F parser!\n")
|
|
else()
|
|
string(APPEND log " warning: PGI C/F parse failed!\n")
|
|
endif()
|
|
elseif("${lang}" STREQUAL "CXX" AND "${line}" MATCHES "^/" AND
|
|
"${line}" MATCHES "/pggpp1 " AND "${line}" MATCHES " -I")
|
|
# oddly, -Mnostdinc does not get rid of system -I's, at least in
|
|
# PGI 18.10.1 ...
|
|
string(REGEX MATCHALL " (-I ?)([^ ]*)" incs "${line}")
|
|
foreach(inc IN LISTS incs)
|
|
string(REGEX REPLACE " (-I ?)([^ ]*)" "\\2" idir "${inc}")
|
|
if(NOT "${idir}" STREQUAL "-") # filter out "-I-"
|
|
list(APPEND rv "${idir}")
|
|
endif()
|
|
endforeach()
|
|
if(DEFINED rv)
|
|
string(APPEND log " got implicit includes via PGI CXX parser!\n")
|
|
else()
|
|
string(APPEND log " warning: PGI CXX parse failed!\n")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# SunPro compiler
|
|
if("${CMAKE_${lang}_COMPILER_ID}" STREQUAL "SunPro" AND
|
|
("${line}" MATCHES "-D__SUNPRO_C" OR "${line}" MATCHES "-D__SUNPRO_F") )
|
|
string(REGEX MATCHALL " (-I ?)([^ ]*)" incs "${line}")
|
|
foreach(inc IN LISTS incs)
|
|
string(REGEX REPLACE " (-I ?)([^ ]*)" "\\2" idir "${inc}")
|
|
if(NOT "${idir}" STREQUAL "-xbuiltin")
|
|
list(APPEND rv "${idir}")
|
|
endif()
|
|
endforeach()
|
|
if(rv)
|
|
if ("${lang}" STREQUAL "C" OR "${lang}" STREQUAL "CXX")
|
|
# /usr/include appears to be hardwired in
|
|
list(APPEND rv "/usr/include")
|
|
endif()
|
|
string(APPEND log " got implicit includes via sunpro parser!\n")
|
|
else()
|
|
string(APPEND log " warning: sunpro parse failed!\n")
|
|
endif()
|
|
endif()
|
|
|
|
# XL compiler
|
|
if("${CMAKE_${lang}_COMPILER_ID}" STREQUAL "XL" AND "${line}" MATCHES "^/"
|
|
AND ( ("${lang}" STREQUAL "Fortran" AND
|
|
"${line}" MATCHES "/xl[fF]entry " AND
|
|
"${line}" MATCHES "OSVAR\\([^ ]+\\)")
|
|
OR
|
|
( ("${lang}" STREQUAL "C" OR "${lang}" STREQUAL "CXX") AND
|
|
"${line}" MATCHES "/xl[cC]entry " AND
|
|
"${line}" MATCHES " -qosvar=")
|
|
) )
|
|
# -qnostdinc cancels other stdinc flags, even if present
|
|
string(FIND "${line}" " -qnostdinc" nostd)
|
|
if(NOT ${nostd} EQUAL -1)
|
|
set(rv "") # defined but empty
|
|
string(APPEND log " got implicit includes via XL parser (nostdinc)\n")
|
|
else()
|
|
if("${lang}" STREQUAL "CXX")
|
|
string(REGEX MATCHALL " -qcpp_stdinc=([^ ]*)" std "${line}")
|
|
string(REGEX MATCHALL " -qgcc_cpp_stdinc=([^ ]*)" gcc_std "${line}")
|
|
else()
|
|
string(REGEX MATCHALL " -qc_stdinc=([^ ]*)" std "${line}")
|
|
string(REGEX MATCHALL " -qgcc_c_stdinc=([^ ]*)" gcc_std "${line}")
|
|
endif()
|
|
set(xlstd ${std} ${gcc_std})
|
|
foreach(inc IN LISTS xlstd)
|
|
string(REGEX REPLACE " -q(cpp|gcc_cpp|c|gcc_c)_stdinc=([^ ]*)" "\\2"
|
|
ipath "${inc}")
|
|
string(REPLACE ":" ";" ipath "${ipath}")
|
|
list(APPEND rv ${ipath})
|
|
endforeach()
|
|
endif()
|
|
# user can add -I flags via CMAKE_{C,CXX}_FLAGS, look for that too
|
|
string(REGEX MATCHALL " (-I ?)([^ ]*)" incs "${line}")
|
|
unset(urv)
|
|
foreach(inc IN LISTS incs)
|
|
string(REGEX REPLACE " (-I ?)([^ ]*)" "\\2" idir "${inc}")
|
|
list(APPEND urv "${idir}")
|
|
endforeach()
|
|
if(urv)
|
|
if ("${rv}" STREQUAL "")
|
|
set(rv ${urv})
|
|
else()
|
|
list(APPEND rv ${urv})
|
|
endif()
|
|
endif()
|
|
|
|
if(DEFINED rv)
|
|
string(APPEND log " got implicit includes via XL parser!\n")
|
|
else()
|
|
string(APPEND log " warning: XL parse failed!\n")
|
|
endif()
|
|
endif()
|
|
|
|
if(log)
|
|
set(${log_var} "${log}" PARENT_SCOPE)
|
|
else()
|
|
unset(${log_var} PARENT_SCOPE)
|
|
endif()
|
|
if(DEFINED rv)
|
|
set(${id_var} "${rv}" PARENT_SCOPE)
|
|
set(${state_var} "done" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# top-level function to parse implicit include directory information
|
|
# from verbose compiler output. sets state_var in parent to 'done' on success.
|
|
function(cmake_parse_implicit_include_info text lang dir_var log_var state_var)
|
|
set(state start) # values: start, loading, done
|
|
|
|
# clear variables we append to (avoids possible polution from parent scopes)
|
|
set(implicit_dirs_tmp)
|
|
set(log "")
|
|
|
|
# go through each line of output...
|
|
string(REGEX REPLACE "\r?\n" ";" output_lines "${text}")
|
|
foreach(line IN LISTS output_lines)
|
|
if(state STREQUAL start)
|
|
string(FIND "${line}" "#include \"...\" search starts here:" rv)
|
|
if(rv GREATER -1)
|
|
set(state loading)
|
|
set(preload 1) # looking for include <...> now
|
|
string(APPEND log " found start of include info\n")
|
|
else()
|
|
cmake_parse_implicit_include_line("${line}" "${lang}" implicit_dirs_tmp
|
|
linelog state)
|
|
if(linelog)
|
|
string(APPEND log ${linelog})
|
|
endif()
|
|
if(state STREQUAL done)
|
|
break()
|
|
endif()
|
|
endif()
|
|
elseif(state STREQUAL loading)
|
|
string(FIND "${line}" "End of search list." rv)
|
|
if(rv GREATER -1)
|
|
set(state done)
|
|
string(APPEND log " end of search list found\n")
|
|
break()
|
|
endif()
|
|
if(preload)
|
|
string(FIND "${line}" "#include <...> search starts here:" rv)
|
|
if(rv GREATER -1)
|
|
set(preload 0)
|
|
string(APPEND log " found start of implicit include info\n")
|
|
endif()
|
|
continue()
|
|
endif()
|
|
if("${line}" MATCHES "^ ")
|
|
string(SUBSTRING "${line}" 1 -1 line) # remove leading space
|
|
endif()
|
|
if ("${line}" MATCHES " \\(framework directory\\)$")
|
|
continue() # frameworks are handled elsewhere, ignore them here
|
|
endif()
|
|
string(REPLACE "\\" "/" path "${line}")
|
|
list(APPEND implicit_dirs_tmp "${path}")
|
|
string(APPEND log " add: [${path}]\n")
|
|
endif()
|
|
endforeach()
|
|
|
|
set(implicit_dirs "")
|
|
foreach(d IN LISTS implicit_dirs_tmp)
|
|
if(IS_ABSOLUTE "${d}")
|
|
get_filename_component(dir "${d}" ABSOLUTE)
|
|
list(APPEND implicit_dirs "${dir}")
|
|
string(APPEND log " collapse include dir [${d}] ==> [${dir}]\n")
|
|
elseif("${d}" MATCHES [[^\.\.[\/]\.\.[\/](.*)$]])
|
|
# This relative path is deep enough to get out of the CMakeFiles/CMakeTmp
|
|
# directory where the ABI check is done. Assume that the compiler has
|
|
# computed this path adaptively based on the current working directory
|
|
# such that the effective result is absolute.
|
|
get_filename_component(dir "${CMAKE_BINARY_DIR}/${CMAKE_MATCH_1}" ABSOLUTE)
|
|
list(APPEND implicit_dirs "${dir}")
|
|
string(APPEND log " collapse relative include dir [${d}] ==> [${dir}]\n")
|
|
else()
|
|
string(APPEND log " skipping relative include dir [${d}]\n")
|
|
endif()
|
|
endforeach()
|
|
list(REMOVE_DUPLICATES implicit_dirs)
|
|
|
|
# Log results.
|
|
if(state STREQUAL done)
|
|
string(APPEND log " implicit include dirs: [${implicit_dirs}]\n")
|
|
else()
|
|
string(APPEND log " warn: unable to parse implicit include dirs!\n")
|
|
endif()
|
|
|
|
# Return results.
|
|
set(${dir_var} "${implicit_dirs}" PARENT_SCOPE)
|
|
set(${log_var} "${log}" PARENT_SCOPE)
|
|
set(${state_var} "${state}" PARENT_SCOPE)
|
|
|
|
endfunction()
|