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