Uploaded Test files

venv/Lib/site-packages/cmake/data/share/cmake-3.18/Modules/CMakeParseImplicitIncludeInfo.cmake

@@ -0,0 +1,247 @@
+# 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()