contrib/llvm/tools/clang/lib/Tooling/JSONCompilationDatabase.cpp

   1 //===--- JSONCompilationDatabase.cpp - ------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file contains the implementation of the JSONCompilationDatabase.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Tooling/JSONCompilationDatabase.h"
  15 #include "clang/Tooling/CompilationDatabase.h"
  16 #include "clang/Tooling/CompilationDatabasePluginRegistry.h"
  17 #include "clang/Tooling/Tooling.h"
  18 #include "llvm/ADT/SmallString.h"
  19 #include "llvm/Support/Allocator.h"
  20 #include "llvm/Support/CommandLine.h"
  21 #include "llvm/Support/Path.h"
  22 #include "llvm/Support/StringSaver.h"
  23 #include <system_error>
  24
  25 namespace clang {
  26 namespace tooling {
  27
  28 namespace {
  29
  30 /// \brief A parser for escaped strings of command line arguments.
  31 ///
  32 /// Assumes \-escaping for quoted arguments (see the documentation of
  33 /// unescapeCommandLine(...)).
  34 class CommandLineArgumentParser {
  35  public:
  36   CommandLineArgumentParser(StringRef CommandLine)
  37       : Input(CommandLine), Position(Input.begin()-1) {}
  38
  39   std::vector<std::string> parse() {
  40     bool HasMoreInput = true;
  41     while (HasMoreInput && nextNonWhitespace()) {
  42       std::string Argument;
  43       HasMoreInput = parseStringInto(Argument);
  44       CommandLine.push_back(Argument);
  45     }
  46     return CommandLine;
  47   }
  48
  49  private:
  50   // All private methods return true if there is more input available.
  51
  52   bool parseStringInto(std::string &String) {
  53     do {
  54       if (*Position == '"') {
  55         if (!parseDoubleQuotedStringInto(String)) return false;
  56       } else if (*Position == '\'') {
  57         if (!parseSingleQuotedStringInto(String)) return false;
  58       } else {
  59         if (!parseFreeStringInto(String)) return false;
  60       }
  61     } while (*Position != ' ');
  62     return true;
  63   }
  64
  65   bool parseDoubleQuotedStringInto(std::string &String) {
  66     if (!next()) return false;
  67     while (*Position != '"') {
  68       if (!skipEscapeCharacter()) return false;
  69       String.push_back(*Position);
  70       if (!next()) return false;
  71     }
  72     return next();
  73   }
  74
  75   bool parseSingleQuotedStringInto(std::string &String) {
  76     if (!next()) return false;
  77     while (*Position != '\'') {
  78       String.push_back(*Position);
  79       if (!next()) return false;
  80     }
  81     return next();
  82   }
  83
  84   bool parseFreeStringInto(std::string &String) {
  85     do {
  86       if (!skipEscapeCharacter()) return false;
  87       String.push_back(*Position);
  88       if (!next()) return false;
  89     } while (*Position != ' ' && *Position != '"' && *Position != '\'');
  90     return true;
  91   }
  92
  93   bool skipEscapeCharacter() {
  94     if (*Position == '\\') {
  95       return next();
  96     }
  97     return true;
  98   }
  99
 100   bool nextNonWhitespace() {
 101     do {
 102       if (!next()) return false;
 103     } while (*Position == ' ');
 104     return true;
 105   }
 106
 107   bool next() {
 108     ++Position;
 109     return Position != Input.end();
 110   }
 111
 112   const StringRef Input;
 113   StringRef::iterator Position;
 114   std::vector<std::string> CommandLine;
 115 };
 116
 117 std::vector<std::string> unescapeCommandLine(JSONCommandLineSyntax Syntax,
 118                                              StringRef EscapedCommandLine) {
 119   if (Syntax == JSONCommandLineSyntax::AutoDetect) {
 120     Syntax = JSONCommandLineSyntax::Gnu;
 121     llvm::Triple Triple(llvm::sys::getProcessTriple());
 122     if (Triple.getOS() == llvm::Triple::OSType::Win32) {
 123       // Assume Windows command line parsing on Win32 unless the triple
 124       // explicitly tells us otherwise.
 125       if (!Triple.hasEnvironment() ||
 126           Triple.getEnvironment() == llvm::Triple::EnvironmentType::MSVC)
 127         Syntax = JSONCommandLineSyntax::Windows;
 128     }
 129   }
 130
 131   if (Syntax == JSONCommandLineSyntax::Windows) {
 132     llvm::BumpPtrAllocator Alloc;
 133     llvm::StringSaver Saver(Alloc);
 134     llvm::SmallVector<const char *, 64> T;
 135     llvm::cl::TokenizeWindowsCommandLine(EscapedCommandLine, Saver, T);
 136     std::vector<std::string> Result(T.begin(), T.end());
 137     return Result;
 138   }
 139   assert(Syntax == JSONCommandLineSyntax::Gnu);
 140   CommandLineArgumentParser parser(EscapedCommandLine);
 141   return parser.parse();
 142 }
 143
 144 class JSONCompilationDatabasePlugin : public CompilationDatabasePlugin {
 145   std::unique_ptr<CompilationDatabase>
 146   loadFromDirectory(StringRef Directory, std::string &ErrorMessage) override {
 147     SmallString<1024> JSONDatabasePath(Directory);
 148     llvm::sys::path::append(JSONDatabasePath, "compile_commands.json");
 149     std::unique_ptr<CompilationDatabase> Database(
 150         JSONCompilationDatabase::loadFromFile(
 151             JSONDatabasePath, ErrorMessage, JSONCommandLineSyntax::AutoDetect));
 152     if (!Database)
 153       return nullptr;
 154     return Database;
 155   }
 156 };
 157
 158 } // end namespace
 159
 160 // Register the JSONCompilationDatabasePlugin with the
 161 // CompilationDatabasePluginRegistry using this statically initialized variable.
 162 static CompilationDatabasePluginRegistry::Add<JSONCompilationDatabasePlugin>
 163 X("json-compilation-database", "Reads JSON formatted compilation databases");
 164
 165 // This anchor is used to force the linker to link in the generated object file
 166 // and thus register the JSONCompilationDatabasePlugin.
 167 volatile int JSONAnchorSource = 0;
 168
 169 std::unique_ptr<JSONCompilationDatabase>
 170 JSONCompilationDatabase::loadFromFile(StringRef FilePath,
 171                                       std::string &ErrorMessage,
 172                                       JSONCommandLineSyntax Syntax) {
 173   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> DatabaseBuffer =
 174       llvm::MemoryBuffer::getFile(FilePath);
 175   if (std::error_code Result = DatabaseBuffer.getError()) {
 176     ErrorMessage = "Error while opening JSON database: " + Result.message();
 177     return nullptr;
 178   }
 179   std::unique_ptr<JSONCompilationDatabase> Database(
 180       new JSONCompilationDatabase(std::move(*DatabaseBuffer), Syntax));
 181   if (!Database->parse(ErrorMessage))
 182     return nullptr;
 183   return Database;
 184 }
 185
 186 std::unique_ptr<JSONCompilationDatabase>
 187 JSONCompilationDatabase::loadFromBuffer(StringRef DatabaseString,
 188                                         std::string &ErrorMessage,
 189                                         JSONCommandLineSyntax Syntax) {
 190   std::unique_ptr<llvm::MemoryBuffer> DatabaseBuffer(
 191       llvm::MemoryBuffer::getMemBuffer(DatabaseString));
 192   std::unique_ptr<JSONCompilationDatabase> Database(
 193       new JSONCompilationDatabase(std::move(DatabaseBuffer), Syntax));
 194   if (!Database->parse(ErrorMessage))
 195     return nullptr;
 196   return Database;
 197 }
 198
 199 std::vector<CompileCommand>
 200 JSONCompilationDatabase::getCompileCommands(StringRef FilePath) const {
 201   SmallString<128> NativeFilePath;
 202   llvm::sys::path::native(FilePath, NativeFilePath);
 203
 204   std::string Error;
 205   llvm::raw_string_ostream ES(Error);
 206   StringRef Match = MatchTrie.findEquivalent(NativeFilePath, ES);
 207   if (Match.empty())
 208     return std::vector<CompileCommand>();
 209   llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator
 210     CommandsRefI = IndexByFile.find(Match);
 211   if (CommandsRefI == IndexByFile.end())
 212     return std::vector<CompileCommand>();
 213   std::vector<CompileCommand> Commands;
 214   getCommands(CommandsRefI->getValue(), Commands);
 215   return Commands;
 216 }
 217
 218 std::vector<std::string>
 219 JSONCompilationDatabase::getAllFiles() const {
 220   std::vector<std::string> Result;
 221
 222   llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator
 223     CommandsRefI = IndexByFile.begin();
 224   const llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator
 225     CommandsRefEnd = IndexByFile.end();
 226   for (; CommandsRefI != CommandsRefEnd; ++CommandsRefI) {
 227     Result.push_back(CommandsRefI->first().str());
 228   }
 229
 230   return Result;
 231 }
 232
 233 std::vector<CompileCommand>
 234 JSONCompilationDatabase::getAllCompileCommands() const {
 235   std::vector<CompileCommand> Commands;
 236   getCommands(AllCommands, Commands);
 237   return Commands;
 238 }
 239
 240 static std::vector<std::string>
 241 nodeToCommandLine(JSONCommandLineSyntax Syntax,
 242                   const std::vector<llvm::yaml::ScalarNode *> &Nodes) {
 243   SmallString<1024> Storage;
 244   if (Nodes.size() == 1) {
 245     return unescapeCommandLine(Syntax, Nodes[0]->getValue(Storage));
 246   }
 247   std::vector<std::string> Arguments;
 248   for (auto *Node : Nodes) {
 249     Arguments.push_back(Node->getValue(Storage));
 250   }
 251   return Arguments;
 252 }
 253
 254 void JSONCompilationDatabase::getCommands(
 255     ArrayRef<CompileCommandRef> CommandsRef,
 256     std::vector<CompileCommand> &Commands) const {
 257   for (int I = 0, E = CommandsRef.size(); I != E; ++I) {
 258     SmallString<8> DirectoryStorage;
 259     SmallString<32> FilenameStorage;
 260     SmallString<32> OutputStorage;
 261     auto Output = std::get<3>(CommandsRef[I]);
 262     Commands.emplace_back(
 263         std::get<0>(CommandsRef[I])->getValue(DirectoryStorage),
 264         std::get<1>(CommandsRef[I])->getValue(FilenameStorage),
 265         nodeToCommandLine(Syntax, std::get<2>(CommandsRef[I])),
 266         Output ? Output->getValue(OutputStorage) : "");
 267   }
 268 }
 269
 270 bool JSONCompilationDatabase::parse(std::string &ErrorMessage) {
 271   llvm::yaml::document_iterator I = YAMLStream.begin();
 272   if (I == YAMLStream.end()) {
 273     ErrorMessage = "Error while parsing YAML.";
 274     return false;
 275   }
 276   llvm::yaml::Node *Root = I->getRoot();
 277   if (!Root) {
 278     ErrorMessage = "Error while parsing YAML.";
 279     return false;
 280   }
 281   llvm::yaml::SequenceNode *Array = dyn_cast<llvm::yaml::SequenceNode>(Root);
 282   if (!Array) {
 283     ErrorMessage = "Expected array.";
 284     return false;
 285   }
 286   for (auto& NextObject : *Array) {
 287     llvm::yaml::MappingNode *Object = dyn_cast<llvm::yaml::MappingNode>(&NextObject);
 288     if (!Object) {
 289       ErrorMessage = "Expected object.";
 290       return false;
 291     }
 292     llvm::yaml::ScalarNode *Directory = nullptr;
 293     llvm::Optional<std::vector<llvm::yaml::ScalarNode *>> Command;
 294     llvm::yaml::ScalarNode *File = nullptr;
 295     llvm::yaml::ScalarNode *Output = nullptr;
 296     for (auto& NextKeyValue : *Object) {
 297       llvm::yaml::ScalarNode *KeyString =
 298           dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
 299       if (!KeyString) {
 300         ErrorMessage = "Expected strings as key.";
 301         return false;
 302       }
 303       SmallString<10> KeyStorage;
 304       StringRef KeyValue = KeyString->getValue(KeyStorage);
 305       llvm::yaml::Node *Value = NextKeyValue.getValue();
 306       if (!Value) {
 307         ErrorMessage = "Expected value.";
 308         return false;
 309       }
 310       llvm::yaml::ScalarNode *ValueString =
 311           dyn_cast<llvm::yaml::ScalarNode>(Value);
 312       llvm::yaml::SequenceNode *SequenceString =
 313           dyn_cast<llvm::yaml::SequenceNode>(Value);
 314       if (KeyValue == "arguments" && !SequenceString) {
 315         ErrorMessage = "Expected sequence as value.";
 316         return false;
 317       } else if (KeyValue != "arguments" && !ValueString) {
 318         ErrorMessage = "Expected string as value.";
 319         return false;
 320       }
 321       if (KeyValue == "directory") {
 322         Directory = ValueString;
 323       } else if (KeyValue == "arguments") {
 324         Command = std::vector<llvm::yaml::ScalarNode *>();
 325         for (auto &Argument : *SequenceString) {
 326           auto Scalar = dyn_cast<llvm::yaml::ScalarNode>(&Argument);
 327           if (!Scalar) {
 328             ErrorMessage = "Only strings are allowed in 'arguments'.";
 329             return false;
 330           }
 331           Command->push_back(Scalar);
 332         }
 333       } else if (KeyValue == "command") {
 334         if (!Command)
 335           Command = std::vector<llvm::yaml::ScalarNode *>(1, ValueString);
 336       } else if (KeyValue == "file") {
 337         File = ValueString;
 338       } else if (KeyValue == "output") {
 339         Output = ValueString;
 340       } else {
 341         ErrorMessage = ("Unknown key: \"" +
 342                         KeyString->getRawValue() + "\"").str();
 343         return false;
 344       }
 345     }
 346     if (!File) {
 347       ErrorMessage = "Missing key: \"file\".";
 348       return false;
 349     }
 350     if (!Command) {
 351       ErrorMessage = "Missing key: \"command\" or \"arguments\".";
 352       return false;
 353     }
 354     if (!Directory) {
 355       ErrorMessage = "Missing key: \"directory\".";
 356       return false;
 357     }
 358     SmallString<8> FileStorage;
 359     StringRef FileName = File->getValue(FileStorage);
 360     SmallString<128> NativeFilePath;
 361     if (llvm::sys::path::is_relative(FileName)) {
 362       SmallString<8> DirectoryStorage;
 363       SmallString<128> AbsolutePath(
 364           Directory->getValue(DirectoryStorage));
 365       llvm::sys::path::append(AbsolutePath, FileName);
 366       llvm::sys::path::native(AbsolutePath, NativeFilePath);
 367     } else {
 368       llvm::sys::path::native(FileName, NativeFilePath);
 369     }
 370     auto Cmd = CompileCommandRef(Directory, File, *Command, Output);
 371     IndexByFile[NativeFilePath].push_back(Cmd);
 372     AllCommands.push_back(Cmd);
 373     MatchTrie.insert(NativeFilePath);
 374   }
 375   return true;
 376 }
 377
 378 } // end namespace tooling
 379 } // end namespace clang