[libclang] CompilationDatabase naming and comment fixes

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@159682 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 60 insertions, 58 deletions

diff --git a/bindings/python/clang/cindex.py b/bindings/python/clang/cindex.py
index 23c1edeb44..1a471cd6c8 100644
--- a/bindings/python/clang/cindex.py
+++ b/bindings/python/clang/cindex.py
@@ -2578,39 +2578,39 @@ _clang_getCompletionPriority.argtypes = [c_void_p]
 _clang_getCompletionPriority.restype = c_int
 
 # Compilation Database
-CompilationDatabase_fromDirectory = lib.clang_tooling_CompilationDatabase_fromDirectory
+CompilationDatabase_fromDirectory = lib.clang_CompilationDatabase_fromDirectory
 CompilationDatabase_fromDirectory.argtypes = [c_char_p, POINTER(c_uint)]
 CompilationDatabase_fromDirectory.restype = c_object_p
 CompilationDatabase_fromDirectory.errcheck = CompilationDatabase.from_result
 
-CompilationDatabase_dispose = lib.clang_tooling_CompilationDatabase_dispose
+CompilationDatabase_dispose = lib.clang_CompilationDatabase_dispose
 CompilationDatabase_dispose.argtypes = [c_object_p]
 
-CompilationDatabase_getCompileCommands = lib.clang_tooling_CompilationDatabase_getCompileCommands
+CompilationDatabase_getCompileCommands = lib.clang_CompilationDatabase_getCompileCommands
 CompilationDatabase_getCompileCommands.argtypes = [c_object_p, c_char_p]
 CompilationDatabase_getCompileCommands.restype = c_object_p
 CompilationDatabase_getCompileCommands.errcheck = CompileCommands.from_result
 
-CompileCommands_dispose = lib.clang_tooling_CompileCommands_dispose
+CompileCommands_dispose = lib.clang_CompileCommands_dispose
 CompileCommands_dispose.argtypes = [c_object_p]
 
-CompileCommands_getSize = lib.clang_tooling_CompileCommands_getSize
+CompileCommands_getSize = lib.clang_CompileCommands_getSize
 CompileCommands_getSize.argtypes = [c_object_p]
 CompileCommands_getSize.restype = c_uint
 
-CompileCommands_getCommand = lib.clang_tooling_CompileCommands_getCommand
+CompileCommands_getCommand = lib.clang_CompileCommands_getCommand
 CompileCommands_getCommand.argtypes = [c_object_p, c_uint]
 CompileCommands_getCommand.restype = c_object_p
 
-CompileCommand_getDirectory = lib.clang_tooling_CompileCommand_getDirectory
+CompileCommand_getDirectory = lib.clang_CompileCommand_getDirectory
 CompileCommand_getDirectory.argtypes = [c_object_p]
 CompileCommand_getDirectory.restype = _CXString
 
-CompileCommand_getNumArgs = lib.clang_tooling_CompileCommand_getNumArgs
+CompileCommand_getNumArgs = lib.clang_CompileCommand_getNumArgs
 CompileCommand_getNumArgs.argtypes = [c_object_p]
 CompileCommand_getNumArgs.restype = c_uint
 
-CompileCommand_getArg = lib.clang_tooling_CompileCommand_getArg
+CompileCommand_getArg = lib.clang_CompileCommand_getArg
 CompileCommand_getArg.argtypes = [c_object_p, c_uint]
 CompileCommand_getArg.restype = _CXString
 
diff --git a/include/clang-c/CXCompilationDatabase.h b/include/clang-c/CXCompilationDatabase.h
index e4da6273d8..d11133cf93 100644
--- a/include/clang-c/CXCompilationDatabase.h
+++ b/include/clang-c/CXCompilationDatabase.h
@@ -29,9 +29,11 @@ extern "C" {
  */
 
 /**
- * \brief Represents clang::tooling::CompilationDatabase
+ * A compilation database holds all information used to compile files in a
+ * project. For each file in the database, it can be queried for the working
+ * directory or the command line used for the compiler invocation.
  *
- * Must be freed by \c clang_tooling_CompilationDatabase_dispose
+ * Must be freed by \c clang_CompilationDatabase_dispose
  */
 typedef void * CXCompilationDatabase;
 
@@ -42,7 +44,7 @@ typedef void * CXCompilationDatabase;
  * return several commands, as the file may have been compiled with
  * different options in different places of the project. This choice of compile
  * commands is wrapped in this opaque data structure. It must be freed by
- * \c clang_tooling_CompileCommands_dispose.
+ * \c clang_CompileCommands_dispose.
  */
 typedef void * CXCompileCommands;
 
@@ -69,59 +71,60 @@ typedef enum  {
 
 /**
  * \brief Creates a compilation database from the database found in directory
- * buildDir. It must be freed by \c clang_tooling_CompilationDatabase_dispose.
+ * buildDir. For example, CMake can output a compile_commands.json which can
+ * be used to build the database.
+ *
+ * It must be freed by \c clang_CompilationDatabase_dispose.
  */
 CINDEX_LINKAGE CXCompilationDatabase
-clang_tooling_CompilationDatabase_fromDirectory(
-  const char *BuildDir,
-  CXCompilationDatabase_Error *ErrorCode);
+clang_CompilationDatabase_fromDirectory(const char *BuildDir,
+                                        CXCompilationDatabase_Error *ErrorCode);
 
 /**
  * \brief Free the given compilation database
  */
 CINDEX_LINKAGE void
-clang_tooling_CompilationDatabase_dispose(CXCompilationDatabase);
+clang_CompilationDatabase_dispose(CXCompilationDatabase);
 
 /**
  * \brief Find the compile commands used for a file. The compile commands
- * must be freed by \c clang_tooling_CompileCommands_dispose.
+ * must be freed by \c clang_CompileCommands_dispose.
  */
 CINDEX_LINKAGE CXCompileCommands
-clang_tooling_CompilationDatabase_getCompileCommands(
-  CXCompilationDatabase,
-  const char *CompleteFileName);
+clang_CompilationDatabase_getCompileCommands(CXCompilationDatabase,
+                                             const char *CompleteFileName);
 
 /**
  * \brief Free the given CompileCommands
  */
-CINDEX_LINKAGE void clang_tooling_CompileCommands_dispose(CXCompileCommands);
+CINDEX_LINKAGE void clang_CompileCommands_dispose(CXCompileCommands);
 
 /**
  * \brief Get the number of CompileCommand we have for a file
  */
 CINDEX_LINKAGE unsigned
-clang_tooling_CompileCommands_getSize(CXCompileCommands);
+clang_CompileCommands_getSize(CXCompileCommands);
 
 /**
  * \brief Get the I'th CompileCommand for a file
  *
- * Note : 0 <= i < clang_tooling_CompileCommands_getSize(CXCompileCommands)
+ * Note : 0 <= i < clang_CompileCommands_getSize(CXCompileCommands)
  */
 CINDEX_LINKAGE CXCompileCommand
-clang_tooling_CompileCommands_getCommand(CXCompileCommands, unsigned I);
+clang_CompileCommands_getCommand(CXCompileCommands, unsigned I);
 
 /**
  * \brief Get the working directory where the CompileCommand was executed from
  */
 CINDEX_LINKAGE CXString
-clang_tooling_CompileCommand_getDirectory(CXCompileCommand);
+clang_CompileCommand_getDirectory(CXCompileCommand);
 
 /**
  * \brief Get the number of arguments in the compiler invocation.
  *
  */
 CINDEX_LINKAGE unsigned
-clang_tooling_CompileCommand_getNumArgs(CXCompileCommand);
+clang_CompileCommand_getNumArgs(CXCompileCommand);
 
 /**
  * \brief Get the I'th argument value in the compiler invocations
@@ -130,7 +133,7 @@ clang_tooling_CompileCommand_getNumArgs(CXCompileCommand);
  *  - argument 0 is the compiler executable
  */
 CINDEX_LINKAGE CXString
-clang_tooling_CompileCommand_getArg(CXCompileCommand, unsigned I);
+clang_CompileCommand_getArg(CXCompileCommand, unsigned I);
 
 /**
  * @}
diff --git a/tools/c-index-test/c-index-test.c b/tools/c-index-test/c-index-test.c
index 79a3c573b9..e16be7d185 100644
--- a/tools/c-index-test/c-index-test.c
+++ b/tools/c-index-test/c-index-test.c
@@ -2415,7 +2415,7 @@ perform_test_compilation_db(const char *database, int argc, const char **argv) {
   memcpy(tmp, database, len+1);
   buildDir = dirname(tmp);
 
-  db = clang_tooling_CompilationDatabase_fromDirectory(buildDir, &ec);
+  db = clang_CompilationDatabase_fromDirectory(buildDir, &ec);
 
   if (db) {
 
@@ -2427,7 +2427,7 @@ perform_test_compilation_db(const char *database, int argc, const char **argv) {
 
     for (i=0; i<argc && errorCode==0; ) {
       if (strcmp(argv[i],"lookup")==0){
-        CCmds = clang_tooling_CompilationDatabase_getCompileCommands(db, argv[i+1]);
+        CCmds = clang_CompilationDatabase_getCompileCommands(db, argv[i+1]);
 
         if (!CCmds) {
           printf("file %s not found in compilation db\n", argv[i+1]);
@@ -2435,7 +2435,7 @@ perform_test_compilation_db(const char *database, int argc, const char **argv) {
           break;
         }
 
-        numCmds = clang_tooling_CompileCommands_getSize(CCmds);
+        numCmds = clang_CompileCommands_getSize(CCmds);
 
         if (numCmds==0) {
           fprintf(stderr, "should not get an empty compileCommand set for file"
@@ -2445,29 +2445,29 @@ perform_test_compilation_db(const char *database, int argc, const char **argv) {
         }
 
         for (j=0; j<numCmds; ++j) {
-          CCmd = clang_tooling_CompileCommands_getCommand(CCmds, j);
+          CCmd = clang_CompileCommands_getCommand(CCmds, j);
 
-          wd = clang_tooling_CompileCommand_getDirectory(CCmd);
+          wd = clang_CompileCommand_getDirectory(CCmd);
           printf("workdir:'%s'", clang_getCString(wd));
           clang_disposeString(wd);
 
           printf(" cmdline:'");
-          numArgs = clang_tooling_CompileCommand_getNumArgs(CCmd);
+          numArgs = clang_CompileCommand_getNumArgs(CCmd);
           for (a=0; a<numArgs; ++a) {
             if (a) printf(" ");
-            arg = clang_tooling_CompileCommand_getArg(CCmd, a);
+            arg = clang_CompileCommand_getArg(CCmd, a);
             printf("%s", clang_getCString(arg));
             clang_disposeString(arg);
           }
           printf("'\n");
         }
 
-        clang_tooling_CompileCommands_dispose(CCmds);
+        clang_CompileCommands_dispose(CCmds);
 
         i += 2;
       }
     }
-    clang_tooling_CompilationDatabase_dispose(db);
+    clang_CompilationDatabase_dispose(db);
   } else {
     printf("database loading failed with error code %d.\n", ec);
     errorCode = -1;
diff --git a/tools/libclang/CXCompilationDatabase.cpp b/tools/libclang/CXCompilationDatabase.cpp
index a537c9d6f9..7bd319ac29 100644
--- a/tools/libclang/CXCompilationDatabase.cpp
+++ b/tools/libclang/CXCompilationDatabase.cpp
@@ -10,9 +10,8 @@ extern "C" {
 
 // FIXME: do something more usefull with the error message
 CXCompilationDatabase
-clang_tooling_CompilationDatabase_fromDirectory(
-  const char *BuildDir,
-  CXCompilationDatabase_Error *ErrorCode)
+clang_CompilationDatabase_fromDirectory(const char *BuildDir,
+                                        CXCompilationDatabase_Error *ErrorCode)
 {
   std::string ErrorMsg;
   CXCompilationDatabase_Error Err = CXCompilationDatabase_NoError;
@@ -32,7 +31,7 @@ clang_tooling_CompilationDatabase_fromDirectory(
 }
 
 void
-clang_tooling_CompilationDatabase_dispose(CXCompilationDatabase CDb)
+clang_CompilationDatabase_dispose(CXCompilationDatabase CDb)
 {
   delete static_cast<CompilationDatabase *>(CDb);
 }
@@ -47,8 +46,8 @@ struct AllocatedCXCompileCommands
 };
 
 CXCompileCommands
-clang_tooling_CompilationDatabase_getCompileCommands(CXCompilationDatabase CDb,
-                                 const char *CompleteFileName)
+clang_CompilationDatabase_getCompileCommands(CXCompilationDatabase CDb,
+                                             const char *CompleteFileName)
 {
   if (CompilationDatabase *db = static_cast<CompilationDatabase *>(CDb)) {
     const std::vector<CompileCommand>
@@ -61,13 +60,13 @@ clang_tooling_CompilationDatabase_getCompileCommands(CXCompilationDatabase CDb,
 }
 
 void
-clang_tooling_CompileCommands_dispose(CXCompileCommands Cmds)
+clang_CompileCommands_dispose(CXCompileCommands Cmds)
 {
   delete static_cast<AllocatedCXCompileCommands *>(Cmds);
 }
 
 unsigned
-clang_tooling_CompileCommands_getSize(CXCompileCommands Cmds)
+clang_CompileCommands_getSize(CXCompileCommands Cmds)
 {
   if (!Cmds)
     return 0;
@@ -79,7 +78,7 @@ clang_tooling_CompileCommands_getSize(CXCompileCommands Cmds)
 }
 
 CXCompileCommand
-clang_tooling_CompileCommands_getCommand(CXCompileCommands Cmds, unsigned I)
+clang_CompileCommands_getCommand(CXCompileCommands Cmds, unsigned I)
 {
   if (!Cmds)
     return 0;
@@ -94,7 +93,7 @@ clang_tooling_CompileCommands_getCommand(CXCompileCommands Cmds, unsigned I)
 }
 
 CXString
-clang_tooling_CompileCommand_getDirectory(CXCompileCommand CCmd)
+clang_CompileCommand_getDirectory(CXCompileCommand CCmd)
 {
   if (!CCmd)
     return createCXString((const char*)NULL);
@@ -104,7 +103,7 @@ clang_tooling_CompileCommand_getDirectory(CXCompileCommand CCmd)
 }
 
 unsigned
-clang_tooling_CompileCommand_getNumArgs(CXCompileCommand CCmd)
+clang_CompileCommand_getNumArgs(CXCompileCommand CCmd)
 {
   if (!CCmd)
     return 0;
@@ -113,7 +112,7 @@ clang_tooling_CompileCommand_getNumArgs(CXCompileCommand CCmd)
 }
 
 CXString
-clang_tooling_CompileCommand_getArg(CXCompileCommand CCmd, unsigned Arg)
+clang_CompileCommand_getArg(CXCompileCommand CCmd, unsigned Arg)
 {
   if (!CCmd)
     return createCXString((const char*)NULL);
diff --git a/tools/libclang/libclang.exports b/tools/libclang/libclang.exports
index 3775ce1476..14ded197e7 100644
--- a/tools/libclang/libclang.exports
+++ b/tools/libclang/libclang.exports
@@ -206,14 +206,14 @@ clang_saveTranslationUnit
 clang_sortCodeCompletionResults
 clang_toggleCrashRecovery
 clang_tokenize
-clang_tooling_CompilationDatabase_fromDirectory
-clang_tooling_CompilationDatabase_dispose
-clang_tooling_CompilationDatabase_getCompileCommands
-clang_tooling_CompileCommands_dispose
-clang_tooling_CompileCommands_getSize
-clang_tooling_CompileCommands_getCommand
-clang_tooling_CompileCommand_getDirectory
-clang_tooling_CompileCommand_getNumArgs
-clang_tooling_CompileCommand_getArg
+clang_CompilationDatabase_fromDirectory
+clang_CompilationDatabase_dispose
+clang_CompilationDatabase_getCompileCommands
+clang_CompileCommands_dispose
+clang_CompileCommands_getSize
+clang_CompileCommands_getCommand
+clang_CompileCommand_getDirectory
+clang_CompileCommand_getNumArgs
+clang_CompileCommand_getArg
 clang_visitChildren
 clang_visitChildrenWithBlock