Pragma.h revision 1eb4433ac451dc16f4133a88af2d002ac26c58ef 
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
20namespace 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.
35class PragmaHandler {
36  const IdentifierInfo *Name;
37public:
38  PragmaHandler(const IdentifierInfo *name) : Name(name) {}
39  virtual ~PragmaHandler();
40
41  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  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.
53class PragmaNamespace : public PragmaHandler {
54  /// Handlers - This is the list of handlers in this namespace.
55  ///
56  std::vector<PragmaHandler*> Handlers;
57public:
58  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  void AddPragma(PragmaHandler *Handler) {
71    Handlers.push_back(Handler);
72  }
73
74  /// RemovePragmaHandler - Remove the given handler from the
75  /// namespace.
76  void RemovePragmaHandler(PragmaHandler *Handler);
77
78  bool IsEmpty() {
79    return Handlers.empty();
80  }
81
82  virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
83
84  virtual PragmaNamespace *getIfNamespace() { return this; }
85};
86
87
88}  // end namespace clang
89
90#endif
91