Merge pull request #1 from cppit/master

Pull from cppit/libclangmm

CMakeLists.txt

@@ -2,6 +2,12 @@ cmake_minimum_required (VERSION 2.8.4)
 set(project_name clangmm)
 project(${project_name})
 set(library_installation_path "/usr/local/lib/libclangmm/")
+
+if(APPLE)
+  set(Boost_USE_STATIC_LIBS "YES")
+  set(CMAKE_MACOSX_RPATH 1)
+endif()
+
 enable_testing()
 add_subdirectory(src)
 add_subdirectory(tests)

src/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O3")
 set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_HOME_DIRECTORY}/cmake/Modules/")
@@ -49,4 +49,4 @@ target_link_libraries(${project_name} ${LIBCLANG_LIBRARIES})
 install(TARGETS ${project_name}
   LIBRARY DESTINATION ${library_installation_path})
 install(FILES ${header_files}
-  DESTINATION ${library_installation_path}/include)
+  DESTINATION ${library_installation_path}/include)

src/CodeCompleteResults.cc

@@ -1,5 +1,6 @@
 #include "CodeCompleteResults.h"
 #include "CompletionString.h"
+#include <exception>
 
 clang::CodeCompleteResults::
 CodeCompleteResults(clang::TranslationUnit *tu,
@@ -32,8 +33,8 @@ size() {
 
 clang::CompletionString clang::CodeCompleteResults::
 get(int i) {
-  if (i > size()) {
+  if (i >= size()) {
-    // TODO(zalox) return type
+    throw std::invalid_argument("clang::CodeCompleteResults::get(int i): i>=size()");
   }
   return CompletionString(results_->Results[i].CompletionString);
 }

src/CompilationDatabase.cc

@@ -1,11 +1,12 @@
 #include "CompilationDatabase.h"
+#include <exception>
 
 clang::CompilationDatabase::
 CompilationDatabase(const std::string &project_path) {
   CXCompilationDatabase_Error error;
   db_ = clang_CompilationDatabase_fromDirectory(project_path.c_str(), &error);
   if(error) {
-    // TODO(user) error code...
+    //TODO: compile_commands.json is missing, create it?
   }
 }
 

src/CompileCommands.cc

@@ -4,6 +4,8 @@ clang::CompileCommands::
 CompileCommands(const std::string &filename, CompilationDatabase *db) {
   commands_ =
     clang_CompilationDatabase_getCompileCommands(db->db_, filename.c_str());
+  if(clang_CompileCommands_getSize(commands_)==0)
+    commands_ = clang_CompilationDatabase_getAllCompileCommands(db->db_);
 }
 
 clang::CompileCommands::
@@ -15,7 +17,7 @@ std::vector<clang::CompileCommand> clang::CompileCommands::
 get_commands() {
   unsigned N = clang_CompileCommands_getSize(commands_);
   std::vector<clang::CompileCommand> res;
-  for (auto i = 0; i < N; i++) {
+  for (unsigned i = 0; i < N; i++) {
     res.emplace_back(clang::CompileCommand(i, this));
   }
   return res;

src/CompletionString.cc

@@ -7,17 +7,20 @@ CompletionString(const CXCompletionString &str) {
 
 int clang::CompletionString::
 get_num_chunks() {
-  return clang_getNumCompletionChunks(str_);
+  if (clang_getCompletionAvailability(str_) == CXAvailability_Available)
+    return clang_getNumCompletionChunks(str_);
+  else
+    return 0;
 }
 
 std::vector<clang::CompletionChunk> clang::CompletionString::
 get_chunks() {
   std::vector<clang::CompletionChunk> res;
   if (clang_getCompletionAvailability(str_) == CXAvailability_Available) {
-    for (auto i = 0; i < get_num_chunks(); i++) {
+    for (size_t i = 0; i < get_num_chunks(); i++) {
       res.emplace_back(clang_getCString(clang_getCompletionChunkText(str_, i)),
-                       static_cast<CompletionChunkKind>
+		       static_cast<CompletionChunkKind>
-                       (clang_getCompletionChunkKind(str_, i)));
+		       (clang_getCompletionChunkKind(str_, i)));
     }
   }
   return res;

src/TranslationUnit.cc

@@ -5,7 +5,6 @@ clang::TranslationUnit::
   clang_disposeTranslationUnit(tu_);
 }
 
-
 clang::TranslationUnit& clang::TranslationUnit::
 operator=(const clang::TranslationUnit &tu) {
   tu_ = tu.tu_;
@@ -15,11 +14,15 @@ operator=(const clang::TranslationUnit &tu) {
 clang::TranslationUnit::
 TranslationUnit(Index *index,
                 const std::string &filepath,
-                const std::vector<const char*> &command_line_args) {
+                const std::vector<std::string> &command_line_args) {
+  std::vector<const char*> args;
+  for(auto &a: command_line_args) {
+    args.push_back(a.c_str());
+  }
   tu_ = clang_createTranslationUnitFromSourceFile(index->index_,
                                                   filepath.c_str(),
-                                                  command_line_args.size(),
+                                                  args.size(),
-                                                  command_line_args.data(),
+                                                  args.data(),
                                                   0,
                                                   NULL);
 }
@@ -38,8 +41,9 @@ TranslationUnit(Index *index,
 clang::TranslationUnit::
 TranslationUnit(clang::Index *index,
                 const std::string &filepath,
-                const std::vector<const char*> &command_line_args,
+                const std::vector<std::string> &command_line_args,
-                const std::map<std::string, std::string> &buffers) {
+                const std::map<std::string, std::string> &buffers,
+                unsigned flags) {
   std::vector<CXUnsavedFile> files;
   for (auto &buffer : buffers) {
     CXUnsavedFile file;
@@ -48,19 +52,24 @@ TranslationUnit(clang::Index *index,
     file.Length = buffer.second.size();
     files.push_back(file);
   }
+  std::vector<const char*> args;
+  for(auto &a: command_line_args) {
+    args.push_back(a.c_str());
+  }
   tu_ =
     clang_parseTranslationUnit(index->index_,
                                filepath.c_str(),
-                               command_line_args.data(),
+                               args.data(),
-                               command_line_args.size(),
+                               args.size(),
                                files.data(),
                                files.size(),
-                               clang_defaultEditingTranslationUnitOptions());
+                               flags);
 }
 
 int clang::TranslationUnit::
 ReparseTranslationUnit(const std::string &file_path,
-                       const std::map<std::string, std::string>  &buffers) {
+                       const std::map<std::string, std::string>  &buffers,
+                       unsigned flags) {
   std::vector<CXUnsavedFile> files;
   for (auto &buffer : buffers) {
     CXUnsavedFile file;
@@ -72,5 +81,9 @@ ReparseTranslationUnit(const std::string &file_path,
   return clang_reparseTranslationUnit(tu_,
                                       files.size(),
                                       files.data(),
-                                      clang_defaultReparseOptions(tu_));
+                                      flags);
+}
+
+unsigned clang::TranslationUnit::DefaultFlags() {
+  return CXTranslationUnit_CacheCompletionResults | CXTranslationUnit_PrecompiledPreamble | CXTranslationUnit_Incomplete;
 }

src/TranslationUnit.h

@@ -19,19 +19,21 @@ namespace clang {
   public:
     TranslationUnit(Index *index,
                     const std::string &filepath,
-                    const std::vector<const char*> &command_line_args);
+                    const std::vector<std::string> &command_line_args);
     TranslationUnit(Index *index,
                     const std::string &filepath,
-                    const std::vector<const char*> &command_line_args,
+                    const std::vector<std::string> &command_line_args,
-                    const std::map<std::string, std::string> &buffers);
+                    const std::map<std::string, std::string> &buffers,
+                    unsigned flags=DefaultFlags());
     TranslationUnit(Index *index,
                     const std::string &filepath);
     ~TranslationUnit();
     TranslationUnit& operator=(const TranslationUnit &tu);
     int ReparseTranslationUnit(const std::string &file_path,
                                const std::map<std::string, std::string>
-                               &buffers);
+                               &buffers,
-
+                               unsigned flags=DefaultFlags());
+    static unsigned DefaultFlags();
   private:
     friend Token;
     friend Tokens;

tests/CodeCompleteResults_H_Test.cc

@@ -30,6 +30,12 @@ BOOST_AUTO_TEST_CASE(code_complete_results) {
 
   clang::CodeCompleteResults results(&tu, path, buffers, 4, 5);
 
-  BOOST_CHECK(results.size() == 105);
+  bool substr_found=false;
-  BOOST_CHECK(results.get(0).get_num_chunks() == 5);
+  for(int c=0;c<results.size();c++) {
+    if(results.get(c).get_chunks()[1].chunk()=="substr") {
+      substr_found=true;
+      break;
+    }
+  }
+  BOOST_CHECK(substr_found);
 }