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