Home | History | Annotate | Line # | Download | only in libclang 
      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 }
    168