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