Pragma.h revision 809d1be9820039b4cf6efa48246a0d70ffa13394 
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 "clang/Basic/LLVM.h"
18#include "llvm/ADT/StringMap.h"
19#include "llvm/ADT/StringRef.h"
20#include <cassert>
21
22namespace clang {
23  class Preprocessor;
24  class Token;
25  class IdentifierInfo;
26  class PragmaNamespace;
27
28  /**
29   * \brief Describes how the pragma was introduced, e.g., with \#pragma,
30   * _Pragma, or __pragma.
31   */
32  enum PragmaIntroducerKind {
33    /**
34     * \brief The pragma was introduced via \#pragma.
35     */
36    PIK_HashPragma,
37
38    /**
39     * \brief The pragma was introduced via the C99 _Pragma(string-literal).
40     */
41    PIK__Pragma,
42
43    /**
44     * \brief The pragma was introduced via the Microsoft
45     * __pragma(token-string).
46     */
47    PIK___pragma
48  };
49
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.
55///
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
58/// pragmas.
59class PragmaHandler {
60  std::string Name;
61public:
62  explicit PragmaHandler(StringRef name) : Name(name) {}
63  PragmaHandler() {}
64  virtual ~PragmaHandler();
65
66  StringRef getName() const { return Name; }
67  virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
68                            Token &FirstToken) = 0;
69
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 0; }
73};
74
75/// EmptyPragmaHandler - A pragma handler which takes no action, which can be
76/// used to ignore particular pragmas.
77class EmptyPragmaHandler : public PragmaHandler {
78public:
79  EmptyPragmaHandler();
80
81  virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
82                            Token &FirstToken);
83};
84
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.
89class PragmaNamespace : public PragmaHandler {
90  /// Handlers - This is a map of the handlers in this namespace with their name
91  /// as key.
92  ///
93  llvm::StringMap<PragmaHandler*> Handlers;
94public:
95  explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {}
96  virtual ~PragmaNamespace();
97
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;
104
105  /// AddPragma - Add a pragma to this namespace.
106  ///
107  void AddPragma(PragmaHandler *Handler);
108
109  /// RemovePragmaHandler - Remove the given handler from the
110  /// namespace.
111  void RemovePragmaHandler(PragmaHandler *Handler);
112
113  bool IsEmpty() {
114    return Handlers.empty();
115  }
116
117  virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
118                            Token &FirstToken);
119
120  virtual PragmaNamespace *getIfNamespace() { return this; }
121};
122
123
124}  // end namespace clang
125
126#endif
127