Add support for GetIncludePaths

include/clang/Interpreter/CppInterOp.h

@@ -444,6 +444,9 @@ namespace Cpp {
   /// Returns the resource-dir path (for headers).
   const char* GetResourceDir();
 
+  /// Get Include Paths
+  void GetIncludePath(const char* dir, std::vector<std::string>& includePaths);
+
   /// Secondary search path for headers, if not found using the
   /// GetResourceDir() function.
   void AddIncludePath(const char *dir);

lib/Interpreter/CppInterOp.cpp

@@ -2530,6 +2530,10 @@ namespace Cpp {
     getInterp().AddIncludePath(dir);
   }
 
+  void GetIncludePath(const char* dir, std::vector<std::string>& Paths) {
+    getInterp().GetIncludePath(dir, Paths);
+  }
+
   namespace {
 
   class clangSilent {

lib/Interpreter/CppInterOpInterpreter.h

@@ -383,6 +383,28 @@ class Interpreter {
     return AddIncludePaths(PathsStr, nullptr);
   }
 
+  ///\brief Returns multiple include paths separated by a delimter.
+  ///
+  ///\param[in] includePaths - Store Path(s)
+  ///\param[in] PathsStr - Path(s)
+  ///\param[in] Delim - Delimiter to separate paths or NULL if a single path
+  ///
+  void GetIncludePaths(std::vector<std::string>& includePaths,
+                       llvm::StringRef PathsStr, const char* Delim = ":") {
+    const clang::CompilerInstance* CI = getCompilerInstance();
+    auto& HOpts =
+        const_cast<clang::HeaderSearchOptions&>(CI->getHeaderSearchOpts());
+
+    Cpp::utils::GetIncludePaths(includePaths, PathsStr, HOpts, Delim);
+  }
+
+  ///\brief Returns a single include path (-I).
+  ///
+  void GetIncludePath(llvm::StringRef PathsStr,
+                      std::vector<std::string>& includePaths) {
+    return GetIncludePaths(includePaths, PathsStr, nullptr);
+  }
+
   CompilationResult loadLibrary(const std::string& filename, bool lookup) {
     DynamicLibraryManager* DLM = getDynamicLibraryManager();
     std::string canonicalLib;

lib/Interpreter/Paths.cpp

@@ -449,5 +449,32 @@
 #undef  DEBUG_TYPE
 }
 
+void GetIncludePaths(
+    std::vector<std::string>& includePaths, llvm::StringRef PathStr,
+    clang::HeaderSearchOptions& HOpts,
+    const char* Delim /* = Cpp::utils::platform::kEnvDelim */) {
+#define DEBUG_TYPE "GetIncludePaths"
+  const int val = 10;
+  llvm::SmallVector<llvm::StringRef, val> Paths;
+  if ((Delim != nullptr) && (*Delim != 0))
+    SplitPaths(PathStr, Paths, kAllowNonExistant, Delim, HOpts.Verbose);
+  else
+    Paths.push_back(PathStr);
+
+  // Avoid duplicates
+  for (llvm::StringRef Path : Paths) {
+    bool Exists = false;
+    for (const clang::HeaderSearchOptions::Entry& E : HOpts.UserEntries) {
+      if ((E.Path == Path))
+        Exists = true;
+      break;
+    }
+    if (!Exists) {
+      includePaths.push_back((std::string)Path);
+    }
+  }
+#undef DEBUG_TYPE
+}
+
 } // namespace utils
 } // namespace Cpp

lib/Interpreter/Paths.h

@@ -158,6 +158,19 @@ void CopyIncludePaths(const clang::HeaderSearchOptions& Opts,
 ///
 void DumpIncludePaths(const clang::HeaderSearchOptions& Opts,
                       llvm::raw_ostream& Out, bool WithSystem, bool WithFlags);
+
+///\brief Get multiple include paths separated by a delimter into the
+/// given HeaderSearchOptions. This helps us to store the include paths in
+/// a vector, includePaths.
+///
+///\param[in] includePaths - Store the include paths
+///\param[in] PathStr - Path(s)
+///\param[in] HOpts - HeaderSearchOptions to add paths into
+///\param[in] Delim - Delimiter to separate paths or NULL if a single path
+///
+void GetIncludePaths(std::vector<std::string>& includePaths,
+                     llvm::StringRef PathStr, clang::HeaderSearchOptions& HOpts,
+                     const char* Delim = Cpp::utils::platform::kEnvDelim);
 } // namespace utils
 } // namespace Cpp
 

unittests/CppInterOp/InterpreterTest.cpp

@@ -84,3 +84,11 @@ TEST(InterpreterTest, CreateInterpreter) {
   EXPECT_TRUE(Cpp::GetNamed("cpp17"));
   EXPECT_FALSE(Cpp::GetNamed("cppUnknown"));
 }
+
+TEST(InterpreterTest, GetIncludePath) {
+    std::vector <std::string> includePaths {};
+    const char* dir = Cpp::GetResourceDir();
+    Cpp::AddIncludePath(dir);
+    Cpp::GetIncludePath(dir, includePaths);
+    EXPECT_TRUE(includePaths.size() > 0);
+}