cmake/Modules/CMakeParseImplicitIncludeInfo.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"
      OR "${CMAKE_${lang}_COMPILER_ID}" STREQUAL "XLClang")
     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]2?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()