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

   1 //===-- FrontendAction.h - Generic Frontend Action Interface ----*- 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 /// \file
  11 /// \brief Defines the clang::FrontendAction interface and various convenience
  12 /// abstract classes (clang::ASTFrontendAction, clang::PluginASTAction,
  13 /// clang::PreprocessorFrontendAction, and clang::WrapperFrontendAction)
  14 /// derived from it.
  15 ///
  16 //===----------------------------------------------------------------------===//
  17
  18 #ifndef LLVM_CLANG_FRONTEND_FRONTENDACTION_H
  19 #define LLVM_CLANG_FRONTEND_FRONTENDACTION_H
  20
  21 #include "clang/Basic/LLVM.h"
  22 #include "clang/Basic/LangOptions.h"
  23 #include "clang/Frontend/FrontendOptions.h"
  24 #include "llvm/ADT/OwningPtr.h"
  25 #include "llvm/ADT/StringRef.h"
  26 #include <string>
  27 #include <vector>
  28
  29 namespace clang {
  30 class ASTConsumer;
  31 class ASTMergeAction;
  32 class ASTUnit;
  33 class CompilerInstance;
  34
  35 /// Abstract base class for actions which can be performed by the frontend.
  36 class FrontendAction {
  37   FrontendInputFile CurrentInput;
  38   OwningPtr<ASTUnit> CurrentASTUnit;
  39   CompilerInstance *Instance;
  40   friend class ASTMergeAction;
  41   friend class WrapperFrontendAction;
  42
  43 private:
  44   ASTConsumer* CreateWrappedASTConsumer(CompilerInstance &CI,
  45                                         StringRef InFile);
  46
  47 protected:
  48   /// @name Implementation Action Interface
  49   /// @{
  50
  51   /// \brief Create the AST consumer object for this action, if supported.
  52   ///
  53   /// This routine is called as part of BeginSourceFile(), which will
  54   /// fail if the AST consumer cannot be created. This will not be called if the
  55   /// action has indicated that it only uses the preprocessor.
  56   ///
  57   /// \param CI - The current compiler instance, provided as a convenience, see
  58   /// getCompilerInstance().
  59   ///
  60   /// \param InFile - The current input file, provided as a convenience, see
  61   /// getCurrentFile().
  62   ///
  63   /// \return The new AST consumer, or null on failure.
  64   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
  65                                          StringRef InFile) = 0;
  66
  67   /// \brief Callback before starting processing a single input, giving the
  68   /// opportunity to modify the CompilerInvocation or do some other action
  69   /// before BeginSourceFileAction is called.
  70   ///
  71   /// \return True on success; on failure BeginSourceFileAction(),
  72   /// ExecuteAction() and EndSourceFileAction() will not be called.
  73   virtual bool BeginInvocation(CompilerInstance &CI) { return true; }
  74
  75   /// \brief Callback at the start of processing a single input.
  76   ///
  77   /// \return True on success; on failure ExecutionAction() and
  78   /// EndSourceFileAction() will not be called.
  79   virtual bool BeginSourceFileAction(CompilerInstance &CI,
  80                                      StringRef Filename) {
  81     return true;
  82   }
  83
  84   /// \brief Callback to run the program action, using the initialized
  85   /// compiler instance.
  86   ///
  87   /// This is guaranteed to only be called between BeginSourceFileAction()
  88   /// and EndSourceFileAction().
  89   virtual void ExecuteAction() = 0;
  90
  91   /// \brief Callback at the end of processing a single input.
  92   ///
  93   /// This is guaranteed to only be called following a successful call to
  94   /// BeginSourceFileAction (and BeginSourceFile).
  95   virtual void EndSourceFileAction() {}
  96
  97   /// @}
  98
  99 public:
 100   FrontendAction();
 101   virtual ~FrontendAction();
 102
 103   /// @name Compiler Instance Access
 104   /// @{
 105
 106   CompilerInstance &getCompilerInstance() const {
 107     assert(Instance && "Compiler instance not registered!");
 108     return *Instance;
 109   }
 110
 111   void setCompilerInstance(CompilerInstance *Value) { Instance = Value; }
 112
 113   /// @}
 114   /// @name Current File Information
 115   /// @{
 116
 117   bool isCurrentFileAST() const {
 118     assert(!CurrentInput.isEmpty() && "No current file!");
 119     return CurrentASTUnit != 0;
 120   }
 121
 122   const FrontendInputFile &getCurrentInput() const {
 123     return CurrentInput;
 124   }
 125
 126   const StringRef getCurrentFile() const {
 127     assert(!CurrentInput.isEmpty() && "No current file!");
 128     return CurrentInput.getFile();
 129   }
 130
 131   InputKind getCurrentFileKind() const {
 132     assert(!CurrentInput.isEmpty() && "No current file!");
 133     return CurrentInput.getKind();
 134   }
 135
 136   ASTUnit &getCurrentASTUnit() const {
 137     assert(CurrentASTUnit && "No current AST unit!");
 138     return *CurrentASTUnit;
 139   }
 140
 141   ASTUnit *takeCurrentASTUnit() {
 142     return CurrentASTUnit.take();
 143   }
 144
 145   void setCurrentInput(const FrontendInputFile &CurrentInput, ASTUnit *AST = 0);
 146
 147   /// @}
 148   /// @name Supported Modes
 149   /// @{
 150
 151   /// \brief Does this action only use the preprocessor?
 152   ///
 153   /// If so no AST context will be created and this action will be invalid
 154   /// with AST file inputs.
 155   virtual bool usesPreprocessorOnly() const = 0;
 156
 157   /// \brief For AST-based actions, the kind of translation unit we're handling.
 158   virtual TranslationUnitKind getTranslationUnitKind() { return TU_Complete; }
 159
 160   /// \brief Does this action support use with PCH?
 161   virtual bool hasPCHSupport() const { return !usesPreprocessorOnly(); }
 162
 163   /// \brief Does this action support use with AST files?
 164   virtual bool hasASTFileSupport() const { return !usesPreprocessorOnly(); }
 165
 166   /// \brief Does this action support use with IR files?
 167   virtual bool hasIRSupport() const { return false; }
 168
 169   /// \brief Does this action support use with code completion?
 170   virtual bool hasCodeCompletionSupport() const { return false; }
 171
 172   /// @}
 173   /// @name Public Action Interface
 174   /// @{
 175
 176   /// \brief Prepare the action for processing the input file \p Input.
 177   ///
 178   /// This is run after the options and frontend have been initialized,
 179   /// but prior to executing any per-file processing.
 180   ///
 181   /// \param CI - The compiler instance this action is being run from. The
 182   /// action may store and use this object up until the matching EndSourceFile
 183   /// action.
 184   ///
 185   /// \param Input - The input filename and kind. Some input kinds are handled
 186   /// specially, for example AST inputs, since the AST file itself contains
 187   /// several objects which would normally be owned by the
 188   /// CompilerInstance. When processing AST input files, these objects should
 189   /// generally not be initialized in the CompilerInstance -- they will
 190   /// automatically be shared with the AST file in between
 191   /// BeginSourceFile() and EndSourceFile().
 192   ///
 193   /// \return True on success; on failure the compilation of this file should
 194   /// be aborted and neither Execute() nor EndSourceFile() should be called.
 195   bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input);
 196
 197   /// \brief Set the source manager's main input file, and run the action.
 198   bool Execute();
 199
 200   /// \brief Perform any per-file post processing, deallocate per-file
 201   /// objects, and run statistics and output file cleanup code.
 202   void EndSourceFile();
 203
 204   /// @}
 205 };
 206
 207 /// \brief Abstract base class to use for AST consumer-based frontend actions.
 208 class ASTFrontendAction : public FrontendAction {
 209 protected:
 210   /// \brief Implement the ExecuteAction interface by running Sema on
 211   /// the already-initialized AST consumer.
 212   ///
 213   /// This will also take care of instantiating a code completion consumer if
 214   /// the user requested it and the action supports it.
 215   virtual void ExecuteAction();
 216
 217 public:
 218   virtual bool usesPreprocessorOnly() const { return false; }
 219 };
 220
 221 class PluginASTAction : public ASTFrontendAction {
 222   virtual void anchor();
 223 protected:
 224   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
 225                                          StringRef InFile) = 0;
 226
 227 public:
 228   /// \brief Parse the given plugin command line arguments.
 229   ///
 230   /// \param CI - The compiler instance, for use in reporting diagnostics.
 231   /// \return True if the parsing succeeded; otherwise the plugin will be
 232   /// destroyed and no action run. The plugin is responsible for using the
 233   /// CompilerInstance's Diagnostic object to report errors.
 234   virtual bool ParseArgs(const CompilerInstance &CI,
 235                          const std::vector<std::string> &arg) = 0;
 236 };
 237
 238 /// \brief Abstract base class to use for preprocessor-based frontend actions.
 239 class PreprocessorFrontendAction : public FrontendAction {
 240 protected:
 241   /// \brief Provide a default implementation which returns aborts;
 242   /// this method should never be called by FrontendAction clients.
 243   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
 244                                          StringRef InFile);
 245
 246 public:
 247   virtual bool usesPreprocessorOnly() const { return true; }
 248 };
 249
 250 /// \brief A frontend action which simply wraps some other runtime-specified
 251 /// frontend action.
 252 ///
 253 /// Deriving from this class allows an action to inject custom logic around
 254 /// some existing action's behavior. It implements every virtual method in
 255 /// the FrontendAction interface by forwarding to the wrapped action.
 256 class WrapperFrontendAction : public FrontendAction {
 257   OwningPtr<FrontendAction> WrappedAction;
 258
 259 protected:
 260   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
 261                                          StringRef InFile);
 262   virtual bool BeginInvocation(CompilerInstance &CI);
 263   virtual bool BeginSourceFileAction(CompilerInstance &CI,
 264                                      StringRef Filename);
 265   virtual void ExecuteAction();
 266   virtual void EndSourceFileAction();
 267
 268 public:
 269   /// Construct a WrapperFrontendAction from an existing action, taking
 270   /// ownership of it.
 271   WrapperFrontendAction(FrontendAction *WrappedAction);
 272
 273   virtual bool usesPreprocessorOnly() const;
 274   virtual TranslationUnitKind getTranslationUnitKind();
 275   virtual bool hasPCHSupport() const;
 276   virtual bool hasASTFileSupport() const;
 277   virtual bool hasIRSupport() const;
 278   virtual bool hasCodeCompletionSupport() const;
 279 };
 280
 281 }  // end namespace clang
 282
 283 #endif