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_LEX_PRAGMA_H
15 #define LLVM_CLANG_LEX_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:
PragmaHandler(StringRef name)62   explicit PragmaHandler(StringRef name) : Name(name) {}
PragmaHandler()63   PragmaHandler() {}
64   virtual ~PragmaHandler();
65 
getName()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.
getIfNamespace()72   virtual PragmaNamespace *getIfNamespace() { return nullptr; }
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   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
82                     Token &FirstToken) override;
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:
PragmaNamespace(StringRef Name)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 
IsEmpty()113   bool IsEmpty() {
114     return Handlers.empty();
115   }
116 
117   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
118                     Token &FirstToken) override;
119 
getIfNamespace()120   PragmaNamespace *getIfNamespace() override { return this; }
121 };
122 
123 
124 }  // end namespace clang
125 
126 #endif
127