 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
0.0% |
0 / 0 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
0.0% |
0 / 0 |
| |
|
Line Coverage: |
70.0% |
7 / 10 |
| |
 |
|
 |
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_PRAGMA_H
15 : #define LLVM_CLANG_PRAGMA_H
16 :
17 : #include <cassert>
18 : #include <vector>
19 :
20 : namespace clang {
21 : class Preprocessor;
22 : class Token;
23 : class IdentifierInfo;
24 : class PragmaNamespace;
25 :
26 : /// PragmaHandler - Instances of this interface defined to handle the various
27 : /// pragmas that the language front-end uses. Each handler optionally has a
28 : /// name (e.g. "pack") and the HandlePragma method is invoked when a pragma with
29 : /// that identifier is found. If a handler does not match any of the declared
30 : /// pragmas the handler with a null identifier is invoked, if it exists.
31 : ///
32 : /// Note that the PragmaNamespace class can be used to subdivide pragmas, e.g.
33 : /// we treat "#pragma STDC" and "#pragma GCC" as namespaces that contain other
34 : /// pragmas.
35 : class PragmaHandler {
36 : const IdentifierInfo *Name;
37 : public:
38 52769: PragmaHandler(const IdentifierInfo *name) : Name(name) {}
39 : virtual ~PragmaHandler();
40 :
41 432507: const IdentifierInfo *getName() const { return Name; }
42 : virtual void HandlePragma(Preprocessor &PP, Token &FirstToken) = 0;
43 :
44 : /// getIfNamespace - If this is a namespace, return it. This is equivalent to
45 : /// using a dynamic_cast, but doesn't require RTTI.
46 0: virtual PragmaNamespace *getIfNamespace() { return 0; }
47 : };
48 :
49 : /// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas,
50 : /// allowing hierarchical pragmas to be defined. Common examples of namespaces
51 : /// are "#pragma GCC", "#pragma STDC", and "#pragma omp", but any namespaces may
52 : /// be (potentially recursively) defined.
53 : class PragmaNamespace : public PragmaHandler {
54 : /// Handlers - This is the list of handlers in this namespace.
55 : ///
56 : std::vector<PragmaHandler*> Handlers;
57 : public:
58 10132: PragmaNamespace(const IdentifierInfo *Name) : PragmaHandler(Name) {}
59 : virtual ~PragmaNamespace();
60 :
61 : /// FindHandler - Check to see if there is already a handler for the
62 : /// specified name. If not, return the handler for the null identifier if it
63 : /// exists, otherwise return null. If IgnoreNull is true (the default) then
64 : /// the null handler isn't returned on failure to match.
65 : PragmaHandler *FindHandler(const IdentifierInfo *Name,
66 : bool IgnoreNull = true) const;
67 :
68 : /// AddPragma - Add a pragma to this namespace.
69 : ///
70 50236: void AddPragma(PragmaHandler *Handler) {
71 50236: Handlers.push_back(Handler);
72 50236: }
73 :
74 : /// RemovePragmaHandler - Remove the given handler from the
75 : /// namespace.
76 : void RemovePragmaHandler(PragmaHandler *Handler);
77 :
78 0: bool IsEmpty() {
79 0: return Handlers.empty();
80 : }
81 :
82 : virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
83 :
84 22997: virtual PragmaNamespace *getIfNamespace() { return this; }
85 : };
86 :
87 :
88 : } // end namespace clang
89 :
90 : #endif
Generated: 2010-02-10 01:31 by zcov