/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Lex/Pragma.h
Line | Count | Source (jump to first uncovered line) |
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 | 46.1k | PragmaHandler() = default; |
70 | 2.25M | explicit PragmaHandler(StringRef name) : Name(name) {} |
71 | | virtual ~PragmaHandler(); |
72 | | |
73 | 3.25M | 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 | 0 | 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<PragmaHandler *> Handlers; |
100 | | |
101 | | public: |
102 | 220k | explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {} |
103 | | ~PragmaNamespace() override; |
104 | | |
105 | | /// FindHandler - Check to see if there is already a handler for the |
106 | | /// specified name. If not, return the handler for the null name if it |
107 | | /// exists, otherwise return null. If IgnoreNull is true (the default) then |
108 | | /// the null handler isn't returned on failure to match. |
109 | | PragmaHandler *FindHandler(StringRef Name, |
110 | | bool IgnoreNull = true) const; |
111 | | |
112 | | /// AddPragma - Add a pragma to this namespace. |
113 | | void AddPragma(PragmaHandler *Handler); |
114 | | |
115 | | /// RemovePragmaHandler - Remove the given handler from the |
116 | | /// namespace. |
117 | | void RemovePragmaHandler(PragmaHandler *Handler); |
118 | | |
119 | 419k | bool IsEmpty() const { return Handlers.empty(); } |
120 | | |
121 | | void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, |
122 | | Token &Tok) override; |
123 | | |
124 | 1.32M | PragmaNamespace *getIfNamespace() override { return this; } |
125 | | }; |
126 | | |
127 | | } // namespace clang |
128 | | |
129 | | #endif // LLVM_CLANG_LEX_PRAGMA_H |