include/clang/Lex/Pragma.h

   1 //===--- Pragma.h - Pragma registration and handling ------------*- 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 defines the PragmaHandler and PragmaTable interfaces.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_PRAGMA_H
  15 #define LLVM_CLANG_PRAGMA_H
  16
  17 #include <cassert>
  18 #include <vector>
  19
  20 namespace clang {
  21   class Preprocessor;
  22   class Token;
  23   class IdentifierInfo;
  24   class PragmaNamespace;
  25
  26 /// PragmaHandler - Instances of this interface defined to handle the various
  27 /// pragmas that the language front-end uses.  Each handler optionally has a
  28 /// name (e.g. "pack") and the HandlePragma method is invoked when a pragma with
  29 /// that identifier is found.  If a handler does not match any of the declared
  30 /// pragmas the handler with a null identifier is invoked, if it exists.
  31 ///
  32 /// Note that the PragmaNamespace class can be used to subdivide pragmas, e.g.
  33 /// we treat "#pragma STDC" and "#pragma GCC" as namespaces that contain other
  34 /// pragmas.
  35 class PragmaHandler {
  36   const IdentifierInfo *Name;
  37 public:
  38   PragmaHandler(const IdentifierInfo *name) : Name(name) {}
  39   virtual ~PragmaHandler();
  40
  41   const IdentifierInfo *getName() const { return Name; }
  42   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken) = 0;
  43
  44   /// getIfNamespace - If this is a namespace, return it.  This is equivalent to
  45   /// using a dynamic_cast, but doesn't require RTTI.
  46   virtual PragmaNamespace *getIfNamespace() { return 0; }
  47 };
  48
  49 /// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas,
  50 /// allowing hierarchical pragmas to be defined.  Common examples of namespaces
  51 /// are "#pragma GCC", "#pragma STDC", and "#pragma omp", but any namespaces may
  52 /// be (potentially recursively) defined.
  53 class PragmaNamespace : public PragmaHandler {
  54   /// Handlers - This is the list of handlers in this namespace.
  55   ///
  56   std::vector<PragmaHandler*> Handlers;
  57 public:
  58   PragmaNamespace(const IdentifierInfo *Name) : PragmaHandler(Name) {}
  59   virtual ~PragmaNamespace();
  60
  61   /// FindHandler - Check to see if there is already a handler for the
  62   /// specified name.  If not, return the handler for the null identifier if it
  63   /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  64   /// the null handler isn't returned on failure to match.
  65   PragmaHandler *FindHandler(const IdentifierInfo *Name,
  66                              bool IgnoreNull = true) const;
  67
  68   /// AddPragma - Add a pragma to this namespace.
  69   ///
  70   void AddPragma(PragmaHandler *Handler) {
  71     Handlers.push_back(Handler);
  72   }
  73
  74   /// RemovePragmaHandler - Remove the given handler from the
  75   /// namespace.
  76   void RemovePragmaHandler(PragmaHandler *Handler);
  77
  78   bool IsEmpty() {
  79     return Handlers.empty();
  80   }
  81
  82   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
  83
  84   virtual PragmaNamespace *getIfNamespace() { return this; }
  85 };
  86
  87
  88 }  // end namespace clang
  89
  90 #endif