clang/tools/libclang/CXCompilationDatabase.cpp

   1 #include "clang-c/CXCompilationDatabase.h"
   2 #include "CXString.h"
   3 #include "clang/Tooling/CompilationDatabase.h"
   4 #include <cstdio>
   5
   6 using namespace clang;
   7 using namespace clang::tooling;
   8
   9 // FIXME: do something more useful with the error message
  10 CXCompilationDatabase
  11 clang_CompilationDatabase_fromDirectory(const char *BuildDir,
  12                                         CXCompilationDatabase_Error *ErrorCode)
  13 {
  14   std::string ErrorMsg;
  15   CXCompilationDatabase_Error Err = CXCompilationDatabase_NoError;
  16
  17   std::unique_ptr<CompilationDatabase> db =
  18       CompilationDatabase::loadFromDirectory(BuildDir, ErrorMsg);
  19
  20   if (!db) {
  21     fprintf(stderr, "LIBCLANG TOOLING ERROR: %s\n", ErrorMsg.c_str());
  22     Err = CXCompilationDatabase_CanNotLoadDatabase;
  23   }
  24
  25   if (ErrorCode)
  26     *ErrorCode = Err;
  27
  28   return db.release();
  29 }
  30
  31 void
  32 clang_CompilationDatabase_dispose(CXCompilationDatabase CDb)
  33 {
  34   delete static_cast<CompilationDatabase *>(CDb);
  35 }
  36
  37 struct AllocatedCXCompileCommands
  38 {
  39   std::vector<CompileCommand> CCmd;
  40
  41   AllocatedCXCompileCommands(std::vector<CompileCommand> Cmd)
  42       : CCmd(std::move(Cmd)) {}
  43 };
  44
  45 CXCompileCommands
  46 clang_CompilationDatabase_getCompileCommands(CXCompilationDatabase CDb,
  47                                              const char *CompleteFileName)
  48 {
  49   if (CompilationDatabase *db = static_cast<CompilationDatabase *>(CDb)) {
  50     std::vector<CompileCommand> CCmd(db->getCompileCommands(CompleteFileName));
  51     if (!CCmd.empty())
  52       return new AllocatedCXCompileCommands(std::move(CCmd));
  53   }
  54
  55   return nullptr;
  56 }
  57
  58 CXCompileCommands
  59 clang_CompilationDatabase_getAllCompileCommands(CXCompilationDatabase CDb) {
  60   if (CompilationDatabase *db = static_cast<CompilationDatabase *>(CDb)) {
  61     std::vector<CompileCommand> CCmd(db->getAllCompileCommands());
  62     if (!CCmd.empty())
  63       return new AllocatedCXCompileCommands(std::move(CCmd));
  64   }
  65
  66   return nullptr;
  67 }
  68
  69 void
  70 clang_CompileCommands_dispose(CXCompileCommands Cmds)
  71 {
  72   delete static_cast<AllocatedCXCompileCommands *>(Cmds);
  73 }
  74
  75 unsigned
  76 clang_CompileCommands_getSize(CXCompileCommands Cmds)
  77 {
  78   if (!Cmds)
  79     return 0;
  80
  81   AllocatedCXCompileCommands *ACC =
  82     static_cast<AllocatedCXCompileCommands *>(Cmds);
  83
  84   return ACC->CCmd.size();
  85 }
  86
  87 CXCompileCommand
  88 clang_CompileCommands_getCommand(CXCompileCommands Cmds, unsigned I)
  89 {
  90   if (!Cmds)
  91     return nullptr;
  92
  93   AllocatedCXCompileCommands *ACC =
  94     static_cast<AllocatedCXCompileCommands *>(Cmds);
  95
  96   if (I >= ACC->CCmd.size())
  97     return nullptr;
  98
  99   return &ACC->CCmd[I];
 100 }
 101
 102 CXString
 103 clang_CompileCommand_getDirectory(CXCompileCommand CCmd)
 104 {
 105   if (!CCmd)
 106     return cxstring::createNull();
 107
 108   CompileCommand *cmd = static_cast<CompileCommand *>(CCmd);
 109   return cxstring::createRef(cmd->Directory.c_str());
 110 }
 111
 112 CXString
 113 clang_CompileCommand_getFilename(CXCompileCommand CCmd)
 114 {
 115   if (!CCmd)
 116     return cxstring::createNull();
 117
 118   CompileCommand *cmd = static_cast<CompileCommand *>(CCmd);
 119   return cxstring::createRef(cmd->Filename.c_str());
 120 }
 121
 122 unsigned
 123 clang_CompileCommand_getNumArgs(CXCompileCommand CCmd)
 124 {
 125   if (!CCmd)
 126     return 0;
 127
 128   return static_cast<CompileCommand *>(CCmd)->CommandLine.size();
 129 }
 130
 131 CXString
 132 clang_CompileCommand_getArg(CXCompileCommand CCmd, unsigned Arg)
 133 {
 134   if (!CCmd)
 135     return cxstring::createNull();
 136
 137   CompileCommand *Cmd = static_cast<CompileCommand *>(CCmd);
 138
 139   if (Arg >= Cmd->CommandLine.size())
 140     return cxstring::createNull();
 141
 142   return cxstring::createRef(Cmd->CommandLine[Arg].c_str());
 143 }
 144
 145 unsigned
 146 clang_CompileCommand_getNumMappedSources(CXCompileCommand CCmd)
 147 {
 148   // Left here for backward compatibility. No mapped sources exists in the C++
 149   // backend anymore.
 150   return 0;
 151 }
 152
 153 CXString
 154 clang_CompileCommand_getMappedSourcePath(CXCompileCommand CCmd, unsigned I)
 155 {
 156   // Left here for backward compatibility. No mapped sources exists in the C++
 157   // backend anymore.
 158   return cxstring::createNull();
 159 }
 160
 161 CXString
 162 clang_CompileCommand_getMappedSourceContent(CXCompileCommand CCmd, unsigned I)
 163 {
 164   // Left here for backward compatibility. No mapped sources exists in the C++
 165   // backend anymore.
 166   return cxstring::createNull();
 167 }