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; PragmaHandler(StringRef name)70 explicit PragmaHandler(StringRef name) : Name(name) {} 71 virtual ~PragmaHandler(); 72 getName()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. getIfNamespace()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: PragmaNamespace(StringRef Name)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 IsEmpty()118 bool IsEmpty() const { return Handlers.empty(); } 119 120 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, 121 Token &Tok) override; 122 getIfNamespace()123 PragmaNamespace *getIfNamespace() override { return this; } 124 }; 125 126 /// Destringize a \c _Pragma("") string according to C11 6.10.9.1: 127 /// "The string literal is destringized by deleting any encoding prefix, 128 /// deleting the leading and trailing double-quotes, replacing each escape 129 /// sequence \" by a double-quote, and replacing each escape sequence \\ by a 130 /// single backslash." 131 void prepare_PragmaString(SmallVectorImpl<char> &StrVal); 132 133 } // namespace clang 134 135 #endif // LLVM_CLANG_LEX_PRAGMA_H 136