Line data    Source code

       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/CompilationDatabase.h"
      31             : #include "llvm/Support/CommandLine.h"
      32             : 
      33             : namespace clang {
      34             : namespace tooling {
      35             : /// \brief A parser for options common to all command-line Clang tools.
      36             : ///
      37             : /// Parses a common subset of command-line arguments, locates and loads a
      38             : /// compilation commands database and runs a tool with user-specified action. It
      39             : /// also contains a help message for the common command-line options.
      40             : ///
      41             : /// An example of usage:
      42             : /// \code
      43             : /// #include "clang/Frontend/FrontendActions.h"
      44             : /// #include "clang/Tooling/CommonOptionsParser.h"
      45             : /// #include "llvm/Support/CommandLine.h"
      46             : ///
      47             : /// using namespace clang::tooling;
      48             : /// using namespace llvm;
      49             : ///
      50             : /// static cl::OptionCategory MyToolCategory("My tool options");
      51             : /// static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
      52             : /// static cl::extrahelp MoreHelp("\nMore help text...");
      53             : /// static cl::opt<bool> YourOwnOption(...);
      54             : /// ...
      55             : ///
      56             : /// int main(int argc, const char **argv) {
      57             : ///   CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
      58             : ///   ClangTool Tool(OptionsParser.getCompilations(),
      59             : ///                  OptionsParser.getSourcePathListi());
      60             : ///   return Tool.run(newFrontendActionFactory<clang::SyntaxOnlyAction>());
      61             : /// }
      62             : /// \endcode
      63          16 : class CommonOptionsParser {
      64             : public:
      65             :   /// \brief Parses command-line, initializes a compilation database.
      66             :   ///
      67             :   /// This constructor can change argc and argv contents, e.g. consume
      68             :   /// command-line options used for creating FixedCompilationDatabase.
      69             :   ///
      70             :   /// All options not belonging to \p Category become hidden.
      71             :   ///
      72             :   /// This constructor exits program in case of error.
      73             :   CommonOptionsParser(int &argc, const char **argv,
      74             :                       llvm::cl::OptionCategory &Category,
      75             :                       const char *Overview = nullptr);
      76             : 
      77             :   /// Returns a reference to the loaded compilations database.
      78             :   CompilationDatabase &getCompilations() {
      79          12 :     return *Compilations;
      80             :   }
      81             : 
      82             :   /// Returns a list of source file paths to process.
      83             :   std::vector<std::string> getSourcePathList() {
      84          12 :     return SourcePathList;
      85             :   }
      86             : 
      87             :   static const char *const HelpMessage;
      88             : 
      89             : private:
      90             :   std::unique_ptr<CompilationDatabase> Compilations;
      91             :   std::vector<std::string> SourcePathList;
      92             :   std::vector<std::string> ExtraArgsBefore;
      93             :   std::vector<std::string> ExtraArgsAfter;
      94             : };
      95             : 
      96             : }  // namespace tooling
      97             : }  // namespace clang
      98             : 
      99             : #endif  // LLVM_TOOLS_CLANG_INCLUDE_CLANG_TOOLING_COMMONOPTIONSPARSER_H