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