contrib/llvm/tools/clang/include/clang/Frontend/FrontendActions.h

   1 //===-- FrontendActions.h - Useful Frontend Actions -------------*- 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 #ifndef LLVM_CLANG_FRONTEND_FRONTENDACTIONS_H
  11 #define LLVM_CLANG_FRONTEND_FRONTENDACTIONS_H
  12
  13 #include "clang/Frontend/FrontendAction.h"
  14 #include <string>
  15 #include <vector>
  16
  17 namespace clang {
  18
  19 class Module;
  20 class FileEntry;
  21
  22 //===----------------------------------------------------------------------===//
  23 // Custom Consumer Actions
  24 //===----------------------------------------------------------------------===//
  25
  26 class InitOnlyAction : public FrontendAction {
  27   void ExecuteAction() override;
  28
  29   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  30                                                  StringRef InFile) override;
  31
  32 public:
  33   // Don't claim to only use the preprocessor, we want to follow the AST path,
  34   // but do nothing.
  35   bool usesPreprocessorOnly() const override { return false; }
  36 };
  37
  38 //===----------------------------------------------------------------------===//
  39 // AST Consumer Actions
  40 //===----------------------------------------------------------------------===//
  41
  42 class ASTPrintAction : public ASTFrontendAction {
  43 protected:
  44   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  45                                                  StringRef InFile) override;
  46 };
  47
  48 class ASTDumpAction : public ASTFrontendAction {
  49 protected:
  50   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  51                                                  StringRef InFile) override;
  52 };
  53
  54 class ASTDeclListAction : public ASTFrontendAction {
  55 protected:
  56   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  57                                                  StringRef InFile) override;
  58 };
  59
  60 class ASTViewAction : public ASTFrontendAction {
  61 protected:
  62   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  63                                                  StringRef InFile) override;
  64 };
  65
  66 class DeclContextPrintAction : public ASTFrontendAction {
  67 protected:
  68   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  69                                                  StringRef InFile) override;
  70 };
  71
  72 class GeneratePCHAction : public ASTFrontendAction {
  73 protected:
  74   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  75                                                  StringRef InFile) override;
  76
  77   TranslationUnitKind getTranslationUnitKind() override {
  78     return TU_Prefix;
  79   }
  80
  81   bool hasASTFileSupport() const override { return false; }
  82
  83 public:
  84   /// \brief Compute the AST consumer arguments that will be used to
  85   /// create the PCHGenerator instance returned by CreateASTConsumer.
  86   ///
  87   /// \returns true if an error occurred, false otherwise.
  88   static std::unique_ptr<raw_pwrite_stream>
  89   ComputeASTConsumerArguments(CompilerInstance &CI, StringRef InFile,
  90                               std::string &Sysroot, std::string &OutputFile);
  91 };
  92
  93 class GenerateModuleAction : public ASTFrontendAction {
  94   clang::Module *Module;
  95   const FileEntry *ModuleMapForUniquing;
  96   bool IsSystem;
  97
  98 protected:
  99   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 100                                                  StringRef InFile) override;
 101
 102   TranslationUnitKind getTranslationUnitKind() override {
 103     return TU_Module;
 104   }
 105
 106   bool hasASTFileSupport() const override { return false; }
 107
 108 public:
 109   GenerateModuleAction(const FileEntry *ModuleMap = nullptr,
 110                        bool IsSystem = false)
 111     : ASTFrontendAction(), ModuleMapForUniquing(ModuleMap), IsSystem(IsSystem)
 112   { }
 113
 114   bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override;
 115
 116   /// \brief Compute the AST consumer arguments that will be used to
 117   /// create the PCHGenerator instance returned by CreateASTConsumer.
 118   ///
 119   /// \returns true if an error occurred, false otherwise.
 120   std::unique_ptr<raw_pwrite_stream>
 121   ComputeASTConsumerArguments(CompilerInstance &CI, StringRef InFile,
 122                               std::string &Sysroot, std::string &OutputFile);
 123 };
 124
 125 class SyntaxOnlyAction : public ASTFrontendAction {
 126 protected:
 127   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 128                                                  StringRef InFile) override;
 129
 130 public:
 131   ~SyntaxOnlyAction() override;
 132   bool hasCodeCompletionSupport() const override { return true; }
 133 };
 134
 135 /// \brief Dump information about the given module file, to be used for
 136 /// basic debugging and discovery.
 137 class DumpModuleInfoAction : public ASTFrontendAction {
 138 protected:
 139   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 140                                                  StringRef InFile) override;
 141   void ExecuteAction() override;
 142
 143 public:
 144   bool hasPCHSupport() const override { return false; }
 145   bool hasASTFileSupport() const override { return true; }
 146   bool hasIRSupport() const override { return false; }
 147   bool hasCodeCompletionSupport() const override { return false; }
 148 };
 149
 150 class VerifyPCHAction : public ASTFrontendAction {
 151 protected:
 152   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 153                                                  StringRef InFile) override;
 154
 155   void ExecuteAction() override;
 156
 157 public:
 158   bool hasCodeCompletionSupport() const override { return false; }
 159 };
 160
 161 /**
 162  * \brief Frontend action adaptor that merges ASTs together.
 163  *
 164  * This action takes an existing AST file and "merges" it into the AST
 165  * context, producing a merged context. This action is an action
 166  * adaptor, which forwards most of its calls to another action that
 167  * will consume the merged context.
 168  */
 169 class ASTMergeAction : public FrontendAction {
 170   /// \brief The action that the merge action adapts.
 171   std::unique_ptr<FrontendAction> AdaptedAction;
 172
 173   /// \brief The set of AST files to merge.
 174   std::vector<std::string> ASTFiles;
 175
 176 protected:
 177   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 178                                                  StringRef InFile) override;
 179
 180   bool BeginSourceFileAction(CompilerInstance &CI,
 181                              StringRef Filename) override;
 182
 183   void ExecuteAction() override;
 184   void EndSourceFileAction() override;
 185
 186 public:
 187   ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
 188                  ArrayRef<std::string> ASTFiles);
 189   ~ASTMergeAction() override;
 190
 191   bool usesPreprocessorOnly() const override;
 192   TranslationUnitKind getTranslationUnitKind() override;
 193   bool hasPCHSupport() const override;
 194   bool hasASTFileSupport() const override;
 195   bool hasCodeCompletionSupport() const override;
 196 };
 197
 198 class PrintPreambleAction : public FrontendAction {
 199 protected:
 200   void ExecuteAction() override;
 201   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
 202                                                  StringRef) override {
 203     return nullptr;
 204   }
 205
 206   bool usesPreprocessorOnly() const override { return true; }
 207 };
 208
 209 //===----------------------------------------------------------------------===//
 210 // Preprocessor Actions
 211 //===----------------------------------------------------------------------===//
 212
 213 class DumpRawTokensAction : public PreprocessorFrontendAction {
 214 protected:
 215   void ExecuteAction() override;
 216 };
 217
 218 class DumpTokensAction : public PreprocessorFrontendAction {
 219 protected:
 220   void ExecuteAction() override;
 221 };
 222
 223 class GeneratePTHAction : public PreprocessorFrontendAction {
 224 protected:
 225   void ExecuteAction() override;
 226 };
 227
 228 class PreprocessOnlyAction : public PreprocessorFrontendAction {
 229 protected:
 230   void ExecuteAction() override;
 231 };
 232
 233 class PrintPreprocessedAction : public PreprocessorFrontendAction {
 234 protected:
 235   void ExecuteAction() override;
 236
 237   bool hasPCHSupport() const override { return true; }
 238 };
 239
 240 }  // end namespace clang
 241
 242 #endif