EIC code displayed by LXR master/​include/​clang/​Frontend/​FrontendAction.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:36:55

 //===-- FrontendAction.h - Generic Frontend Action Interface ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Defines the clang::FrontendAction interface and various convenience
 /// abstract classes (clang::ASTFrontendAction, clang::PluginASTAction,
 /// clang::PreprocessorFrontendAction, and clang::WrapperFrontendAction)
 /// derived from it.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_FRONTEND_FRONTENDACTION_H
 #define LLVM_CLANG_FRONTEND_FRONTENDACTION_H
 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendOptions.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 class ASTMergeAction;
 class CompilerInstance;
 
 /// Abstract base class for actions which can be performed by the frontend.
 class FrontendAction {
   FrontendInputFile CurrentInput;
   std::unique_ptr<ASTUnit> CurrentASTUnit;
   CompilerInstance *Instance;
   friend class ASTMergeAction;
   friend class WrapperFrontendAction;
 
 private:
   std::unique_ptr<ASTConsumer> CreateWrappedASTConsumer(CompilerInstance &CI,
                                                         StringRef InFile);
 
 protected:
   /// @name Implementation Action Interface
   /// @{
 
   /// Prepare to execute the action on the given CompilerInstance.
   ///
   /// This is called before executing the action on any inputs, and can modify
   /// the configuration as needed (including adjusting the input list).
   virtual bool PrepareToExecuteAction(CompilerInstance &CI) { return true; }
 
   /// Create the AST consumer object for this action, if supported.
   ///
   /// This routine is called as part of BeginSourceFile(), which will
   /// fail if the AST consumer cannot be created. This will not be called if the
   /// action has indicated that it only uses the preprocessor.
   ///
   /// \param CI - The current compiler instance, provided as a convenience, see
   /// getCompilerInstance().
   ///
   /// \param InFile - The current input file, provided as a convenience, see
   /// getCurrentFile().
   ///
   /// \return The new AST consumer, or null on failure.
   virtual std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                          StringRef InFile) = 0;
 
   /// Callback before starting processing a single input, giving the
   /// opportunity to modify the CompilerInvocation or do some other action
   /// before BeginSourceFileAction is called.
   ///
   /// \return True on success; on failure BeginSourceFileAction(),
   /// ExecuteAction() and EndSourceFileAction() will not be called.
   virtual bool BeginInvocation(CompilerInstance &CI) { return true; }
 
   /// Callback at the start of processing a single input.
   ///
   /// \return True on success; on failure ExecutionAction() and
   /// EndSourceFileAction() will not be called.
   virtual bool BeginSourceFileAction(CompilerInstance &CI) {
     return true;
   }
 
   /// Callback to run the program action, using the initialized
   /// compiler instance.
   ///
   /// This is guaranteed to only be called between BeginSourceFileAction()
   /// and EndSourceFileAction().
   virtual void ExecuteAction() = 0;
 
   /// Callback at the end of processing a single input.
   ///
   /// This is guaranteed to only be called following a successful call to
   /// BeginSourceFileAction (and BeginSourceFile).
   virtual void EndSourceFileAction() {}
 
   /// Callback at the end of processing a single input, to determine
   /// if the output files should be erased or not.
   ///
   /// By default it returns true if a compiler error occurred.
   /// This is guaranteed to only be called following a successful call to
   /// BeginSourceFileAction (and BeginSourceFile).
   virtual bool shouldEraseOutputFiles();
 
   /// @}
 
 public:
   FrontendAction();
   virtual ~FrontendAction();
 
   /// @name Compiler Instance Access
   /// @{
 
   CompilerInstance &getCompilerInstance() const {
     assert(Instance && "Compiler instance not registered!");
     return *Instance;
   }
 
   void setCompilerInstance(CompilerInstance *Value) { Instance = Value; }
 
   /// @}
   /// @name Current File Information
   /// @{
 
   bool isCurrentFileAST() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return (bool)CurrentASTUnit;
   }
 
   const FrontendInputFile &getCurrentInput() const {
     return CurrentInput;
   }
 
   StringRef getCurrentFile() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return CurrentInput.getFile();
   }
 
   StringRef getCurrentFileOrBufferName() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return CurrentInput.isFile()
                ? CurrentInput.getFile()
                : CurrentInput.getBuffer().getBufferIdentifier();
   }
 
   InputKind getCurrentFileKind() const {
     assert(!CurrentInput.isEmpty() && "No current file!");
     return CurrentInput.getKind();
   }
 
   ASTUnit &getCurrentASTUnit() const {
     assert(CurrentASTUnit && "No current AST unit!");
     return *CurrentASTUnit;
   }
 
   Module *getCurrentModule() const;
 
   std::unique_ptr<ASTUnit> takeCurrentASTUnit() {
     return std::move(CurrentASTUnit);
   }
 
   void setCurrentInput(const FrontendInputFile &CurrentInput,
                        std::unique_ptr<ASTUnit> AST = nullptr);
 
   /// @}
   /// @name Supported Modes
   /// @{
 
   /// Is this action invoked on a model file?
   ///
   /// Model files are incomplete translation units that relies on type
   /// information from another translation unit. Check ParseModelFileAction for
   /// details.
   virtual bool isModelParsingAction() const { return false; }
 
   /// Does this action only use the preprocessor?
   ///
   /// If so no AST context will be created and this action will be invalid
   /// with AST file inputs.
   virtual bool usesPreprocessorOnly() const = 0;
 
   /// For AST-based actions, the kind of translation unit we're handling.
   virtual TranslationUnitKind getTranslationUnitKind() {
     // The ASTContext, if exists, knows the exact TUKind of the frondend.
     if (Instance && Instance->hasASTContext())
       return Instance->getASTContext().TUKind;
     return TU_Complete;
   }
 
   /// Does this action support use with PCH?
   virtual bool hasPCHSupport() const { return true; }
 
   /// Does this action support use with AST files?
   virtual bool hasASTFileSupport() const { return true; }
 
   /// Does this action support use with IR files?
   virtual bool hasIRSupport() const { return false; }
 
   /// Does this action support use with code completion?
   virtual bool hasCodeCompletionSupport() const { return false; }
 
   /// @}
   /// @name Public Action Interface
   /// @{
 
   /// Prepare the action to execute on the given compiler instance.
   bool PrepareToExecute(CompilerInstance &CI) {
     return PrepareToExecuteAction(CI);
   }
 
   /// Prepare the action for processing the input file \p Input.
   ///
   /// This is run after the options and frontend have been initialized,
   /// but prior to executing any per-file processing.
   ///
   /// \param CI - The compiler instance this action is being run from. The
   /// action may store and use this object up until the matching EndSourceFile
   /// action.
   ///
   /// \param Input - The input filename and kind. Some input kinds are handled
   /// specially, for example AST inputs, since the AST file itself contains
   /// several objects which would normally be owned by the
   /// CompilerInstance. When processing AST input files, these objects should
   /// generally not be initialized in the CompilerInstance -- they will
   /// automatically be shared with the AST file in between
   /// BeginSourceFile() and EndSourceFile().
   ///
   /// \return True on success; on failure the compilation of this file should
   /// be aborted and neither Execute() nor EndSourceFile() should be called.
   bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input);
 
   /// Set the source manager's main input file, and run the action.
   llvm::Error Execute();
 
   /// Perform any per-file post processing, deallocate per-file
   /// objects, and run statistics and output file cleanup code.
   virtual void EndSourceFile();
 
   /// @}
 };
 
 /// Abstract base class to use for AST consumer-based frontend actions.
 class ASTFrontendAction : public FrontendAction {
 protected:
   /// Implement the ExecuteAction interface by running Sema on
   /// the already-initialized AST consumer.
   ///
   /// This will also take care of instantiating a code completion consumer if
   /// the user requested it and the action supports it.
   void ExecuteAction() override;
 
 public:
   ASTFrontendAction() {}
   bool usesPreprocessorOnly() const override { return false; }
 };
 
 class PluginASTAction : public ASTFrontendAction {
   virtual void anchor();
 public:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override = 0;
 
   /// Parse the given plugin command line arguments.
   ///
   /// \param CI - The compiler instance, for use in reporting diagnostics.
   /// \return True if the parsing succeeded; otherwise the plugin will be
   /// destroyed and no action run. The plugin is responsible for using the
   /// CompilerInstance's Diagnostic object to report errors.
   virtual bool ParseArgs(const CompilerInstance &CI,
                          const std::vector<std::string> &arg) = 0;
 
   enum ActionType {
     CmdlineBeforeMainAction, ///< Execute the action before the main action if
                              ///< on the command line
     CmdlineAfterMainAction,  ///< Execute the action after the main action if on
                              ///< the command line
     ReplaceAction,           ///< Replace the main action
     AddBeforeMainAction,     ///< Execute the action before the main action
     AddAfterMainAction       ///< Execute the action after the main action
   };
   /// Get the action type for this plugin
   ///
   /// \return The action type. By default we use CmdlineAfterMainAction.
   virtual ActionType getActionType() { return CmdlineAfterMainAction; }
 };
 
 /// Abstract base class to use for preprocessor-based frontend actions.
 class PreprocessorFrontendAction : public FrontendAction {
 protected:
   /// Provide a default implementation which returns aborts;
   /// this method should never be called by FrontendAction clients.
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 
 public:
   bool usesPreprocessorOnly() const override { return true; }
 };
 
 /// A frontend action which simply wraps some other runtime-specified
 /// frontend action.
 ///
 /// Deriving from this class allows an action to inject custom logic around
 /// some existing action's behavior. It implements every virtual method in
 /// the FrontendAction interface by forwarding to the wrapped action.
 class WrapperFrontendAction : public FrontendAction {
 protected:
   std::unique_ptr<FrontendAction> WrappedAction;
 
   bool PrepareToExecuteAction(CompilerInstance &CI) override;
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
   bool BeginInvocation(CompilerInstance &CI) override;
   bool BeginSourceFileAction(CompilerInstance &CI) override;
   void ExecuteAction() override;
   void EndSourceFile() override;
   void EndSourceFileAction() override;
   bool shouldEraseOutputFiles() override;
 
 public:
   /// Construct a WrapperFrontendAction from an existing action, taking
   /// ownership of it.
   WrapperFrontendAction(std::unique_ptr<FrontendAction> WrappedAction);
 
   bool usesPreprocessorOnly() const override;
   TranslationUnitKind getTranslationUnitKind() override;
   bool hasPCHSupport() const override;
   bool hasASTFileSupport() const override;
   bool hasIRSupport() const override;
   bool hasCodeCompletionSupport() const override;
 };
 
 }  // end namespace clang
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team