1 //===--- Pragma.h - Pragma registration and handling ------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the PragmaHandler and PragmaTable interfaces.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_LEX_PRAGMA_H
15 #define LLVM_CLANG_LEX_PRAGMA_H
17 #include "clang/Basic/LLVM.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/ADT/StringRef.h"
26 class PragmaNamespace;
29 * \brief Describes how the pragma was introduced, e.g., with \#pragma,
30 * _Pragma, or __pragma.
32 enum PragmaIntroducerKind {
34 * \brief The pragma was introduced via \#pragma.
39 * \brief The pragma was introduced via the C99 _Pragma(string-literal).
44 * \brief The pragma was introduced via the Microsoft
45 * __pragma(token-string).
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.
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
62 explicit PragmaHandler(StringRef name) : Name(name) {}
64 virtual ~PragmaHandler();
66 StringRef getName() const { return Name; }
67 virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
68 Token &FirstToken) = 0;
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 nullptr; }
75 /// EmptyPragmaHandler - A pragma handler which takes no action, which can be
76 /// used to ignore particular pragmas.
77 class EmptyPragmaHandler : public PragmaHandler {
79 explicit EmptyPragmaHandler(StringRef Name = StringRef());
81 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
82 Token &FirstToken) override;
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
93 llvm::StringMap<PragmaHandler*> Handlers;
95 explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {}
96 ~PragmaNamespace() override;
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;
105 /// AddPragma - Add a pragma to this namespace.
107 void AddPragma(PragmaHandler *Handler);
109 /// RemovePragmaHandler - Remove the given handler from the
111 void RemovePragmaHandler(PragmaHandler *Handler);
114 return Handlers.empty();
117 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
118 Token &FirstToken) override;
120 PragmaNamespace *getIfNamespace() override { return this; }
124 } // end namespace clang