mirror of
https://github.com/reactos/CMake.git
synced 2024-12-14 23:29:57 +00:00
ef8f237686
Add implicit include parser for PGI compiler ID. PGI verbose output
for CXX differs from C and Fortran, so CXX is broken out into its own
case. The C and Fortran compilers take "-YI,path" and "-Mnostdinc" to
change or disable the builtin include path. The last arg on the command
line appears to override previous args (e.g. "-YI,path1 -YI,path2" will
set the path to "path2" ... the previous "-YI,path1" gets undone).
The CXX compiler verbose output reports with "-I" rather than "-stdinc"
for the built in path. In addition with CXX "-Mnostdinc" does not
completely zero the include path (e.g. "#include <stdio.h>" still works
with "-Mnostdinc"... "-I/usr/include" still shows up in the verbose output).
Minor adjustments to get the SunPro parser to handle Fortran as well.
Fixes for Cray compiler support (Modules/Compiler/Cray-{C,CXX}.cmake):
The *_COMPILE_OPTION flags contain options like "-h c99,gnu" ...
these options need to be in double quotes (they are currently not).
Otherwise, cmake treats them as lists and tries to run the compiler
with "-h;c99,gnu" and fails when it is "Detecting C compile features"...
Also, the Cray-CXX.cmake contains "__compiler_cray(C)" instead of
"__compiler_cray(CXX)" -- this error prevents the correct VERBOSE
flags for CXX from being defined which prevents the implicit include
parser from running.
Add additional test cases for PGI and SunPro Fortran to the
Tests/RunCMake/ParseImplicitIncludeInfo area.
226 lines
8.1 KiB
CMake
226 lines
8.1 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()
|
|
|
|
# Log results.
|
|
if(state STREQUAL done)
|
|
string(APPEND log " implicit include dirs: [${implicit_dirs_tmp}]\n")
|
|
else()
|
|
string(APPEND log " warn: unable to parse implicit include dirs!\n")
|
|
endif()
|
|
|
|
# Return results.
|
|
set(${dir_var} "${implicit_dirs_tmp}" PARENT_SCOPE)
|
|
set(${log_var} "${log}" PARENT_SCOPE)
|
|
set(${state_var} "${state}" PARENT_SCOPE)
|
|
|
|
endfunction()
|