contrib/llvm/tools/clang/include/clang/Tooling/CommonOptionsParser.h

   1 //===- CommonOptionsParser.h - common options for clang tools -*- C++ -*-=====//
   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 implements the CommonOptionsParser class used to parse common
  11 //  command-line options for clang tools, so that they can be run as separate
  12 //  command-line applications with a consistent common interface for handling
  13 //  compilation database and input files.
  14 //
  15 //  It provides a common subset of command-line options, common algorithm
  16 //  for locating a compilation database and source files, and help messages
  17 //  for the basic command-line interface.
  18 //
  19 //  It creates a CompilationDatabase and reads common command-line options.
  20 //
  21 //  This class uses the Clang Tooling infrastructure, see
  22 //    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
  23 //  for details on setting it up with LLVM source tree.
  24 //
  25 //===----------------------------------------------------------------------===//
  26
  27 #ifndef LLVM_CLANG_TOOLING_COMMONOPTIONSPARSER_H
  28 #define LLVM_CLANG_TOOLING_COMMONOPTIONSPARSER_H
  29
  30 #include "clang/Tooling/ArgumentsAdjusters.h"
  31 #include "clang/Tooling/CompilationDatabase.h"
  32 #include "llvm/Support/CommandLine.h"
  33 #include "llvm/Support/Error.h"
  34
  35 namespace clang {
  36 namespace tooling {
  37 /// A parser for options common to all command-line Clang tools.
  38 ///
  39 /// Parses a common subset of command-line arguments, locates and loads a
  40 /// compilation commands database and runs a tool with user-specified action. It
  41 /// also contains a help message for the common command-line options.
  42 ///
  43 /// An example of usage:
  44 /// \code
  45 /// #include "clang/Frontend/FrontendActions.h"
  46 /// #include "clang/Tooling/CommonOptionsParser.h"
  47 /// #include "clang/Tooling/Tooling.h"
  48 /// #include "llvm/Support/CommandLine.h"
  49 ///
  50 /// using namespace clang::tooling;
  51 /// using namespace llvm;
  52 ///
  53 /// static cl::OptionCategory MyToolCategory("My tool options");
  54 /// static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
  55 /// static cl::extrahelp MoreHelp("\nMore help text...\n");
  56 /// static cl::opt<bool> YourOwnOption(...);
  57 /// ...
  58 ///
  59 /// int main(int argc, const char **argv) {
  60 ///   CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
  61 ///   ClangTool Tool(OptionsParser.getCompilations(),
  62 ///                  OptionsParser.getSourcePathList());
  63 ///   return Tool.run(newFrontendActionFactory<SyntaxOnlyAction>().get());
  64 /// }
  65 /// \endcode
  66 class CommonOptionsParser {
  67 public:
  68   /// Parses command-line, initializes a compilation database.
  69   ///
  70   /// This constructor can change argc and argv contents, e.g. consume
  71   /// command-line options used for creating FixedCompilationDatabase.
  72   ///
  73   /// All options not belonging to \p Category become hidden.
  74   ///
  75   /// This constructor exits program in case of error.
  76   CommonOptionsParser(int &argc, const char **argv,
  77                       llvm::cl::OptionCategory &Category,
  78                       const char *Overview = nullptr)
  79       : CommonOptionsParser(argc, argv, Category, llvm::cl::OneOrMore,
  80                             Overview) {}
  81
  82   /// Parses command-line, initializes a compilation database.
  83   ///
  84   /// This constructor can change argc and argv contents, e.g. consume
  85   /// command-line options used for creating FixedCompilationDatabase.
  86   ///
  87   /// All options not belonging to \p Category become hidden.
  88   ///
  89   /// It also allows calls to set the required number of positional parameters.
  90   CommonOptionsParser(int &argc, const char **argv,
  91                       llvm::cl::OptionCategory &Category,
  92                       llvm::cl::NumOccurrencesFlag OccurrencesFlag,
  93                       const char *Overview = nullptr);
  94
  95   /// A factory method that is similar to the above constructor, except
  96   /// this returns an error instead exiting the program on error.
  97   static llvm::Expected<CommonOptionsParser>
  98   create(int &argc, const char **argv, llvm::cl::OptionCategory &Category,
  99          llvm::cl::NumOccurrencesFlag OccurrencesFlag,
 100          const char *Overview = nullptr);
 101
 102   /// Returns a reference to the loaded compilations database.
 103   CompilationDatabase &getCompilations() {
 104     return *Compilations;
 105   }
 106
 107   /// Returns a list of source file paths to process.
 108   const std::vector<std::string> &getSourcePathList() const {
 109     return SourcePathList;
 110   }
 111
 112   /// Returns the argument adjuster calculated from "--extra-arg" and
 113   //"--extra-arg-before" options.
 114   ArgumentsAdjuster getArgumentsAdjuster() { return Adjuster; }
 115
 116   static const char *const HelpMessage;
 117
 118 private:
 119   CommonOptionsParser() = default;
 120
 121   llvm::Error init(int &argc, const char **argv,
 122                    llvm::cl::OptionCategory &Category,
 123                    llvm::cl::NumOccurrencesFlag OccurrencesFlag,
 124                    const char *Overview);
 125
 126   std::unique_ptr<CompilationDatabase> Compilations;
 127   std::vector<std::string> SourcePathList;
 128   ArgumentsAdjuster Adjuster;
 129 };
 130
 131 class ArgumentsAdjustingCompilations : public CompilationDatabase {
 132 public:
 133   ArgumentsAdjustingCompilations(
 134       std::unique_ptr<CompilationDatabase> Compilations)
 135       : Compilations(std::move(Compilations)) {}
 136
 137   void appendArgumentsAdjuster(ArgumentsAdjuster Adjuster);
 138
 139   std::vector<CompileCommand>
 140   getCompileCommands(StringRef FilePath) const override;
 141
 142   std::vector<std::string> getAllFiles() const override;
 143
 144   std::vector<CompileCommand> getAllCompileCommands() const override;
 145
 146 private:
 147   std::unique_ptr<CompilationDatabase> Compilations;
 148   std::vector<ArgumentsAdjuster> Adjusters;
 149
 150   std::vector<CompileCommand>
 151   adjustCommands(std::vector<CompileCommand> Commands) const;
 152 };
 153
 154 }  // namespace tooling
 155 }  // namespace clang
 156
 157 #endif  // LLVM_TOOLS_CLANG_INCLUDE_CLANG_TOOLING_COMMONOPTIONSPARSER_H