MacroInfo.h revision 7143aab97c6e849a5a5005b7853b8c7d5af008ed 
1//===--- MacroInfo.h - Information about #defined identifiers ---*- 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 MacroInfo interface.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_MACROINFO_H
15#define LLVM_CLANG_MACROINFO_H
16
17#include "clang/Lex/Token.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/Support/Allocator.h"
20#include <cassert>
21
22namespace clang {
23  class Preprocessor;
24
25/// MacroInfo - Each identifier that is #define'd has an instance of this class
26/// associated with it, used to implement macro expansion.
27class MacroInfo {
28  //===--------------------------------------------------------------------===//
29  // State set when the macro is defined.
30
31  /// Location - This is the place the macro is defined.
32  SourceLocation Location;
33  /// EndLocation - The location of the last token in the macro.
34  SourceLocation EndLocation;
35
36  /// Arguments - The list of arguments for a function-like macro.  This can be
37  /// empty, for, e.g. "#define X()".  In a C99-style variadic macro, this
38  /// includes the __VA_ARGS__ identifier on the list.
39  IdentifierInfo **ArgumentList;
40  unsigned NumArguments;
41
42  /// \brief The location at which this macro was exported from its module.
43  ///
44  /// If invalid, this macro has not been explicitly exported.
45  SourceLocation ExportLocation;
46
47  /// ReplacementTokens - This is the list of tokens that the macro is defined
48  /// to.
49  SmallVector<Token, 8> ReplacementTokens;
50
51  /// \brief Length in characters of the macro definition.
52  mutable unsigned DefinitionLength;
53  mutable bool IsDefinitionLengthCached : 1;
54
55  /// IsFunctionLike - True if this macro is a function-like macro, false if it
56  /// is an object-like macro.
57  bool IsFunctionLike : 1;
58
59  /// IsC99Varargs - True if this macro is of the form "#define X(...)" or
60  /// "#define X(Y,Z,...)".  The __VA_ARGS__ token should be replaced with the
61  /// contents of "..." in an invocation.
62  bool IsC99Varargs : 1;
63
64  /// IsGNUVarargs -  True if this macro is of the form "#define X(a...)".  The
65  /// "a" identifier in the replacement list will be replaced with all arguments
66  /// of the macro starting with the specified one.
67  bool IsGNUVarargs : 1;
68
69  /// IsBuiltinMacro - True if this is a builtin macro, such as __LINE__, and if
70  /// it has not yet been redefined or undefined.
71  bool IsBuiltinMacro : 1;
72
73  /// IsFromAST - True if this macro was loaded from an AST file.
74  bool IsFromAST : 1;
75
76  /// \brief Whether this macro changed after it was loaded from an AST file.
77  bool ChangedAfterLoad : 1;
78
79private:
80  //===--------------------------------------------------------------------===//
81  // State that changes as the macro is used.
82
83  /// IsDisabled - True if we have started an expansion of this macro already.
84  /// This disbles recursive expansion, which would be quite bad for things like
85  /// #define A A.
86  bool IsDisabled : 1;
87
88  /// IsUsed - True if this macro is either defined in the main file and has
89  /// been used, or if it is not defined in the main file.  This is used to
90  /// emit -Wunused-macros diagnostics.
91  bool IsUsed : 1;
92
93  /// AllowRedefinitionsWithoutWarning - True if this macro can be redefined
94  /// without emitting a warning.
95  bool IsAllowRedefinitionsWithoutWarning : 1;
96
97  /// \brief Must warn if the macro is unused at the end of translation unit.
98  bool IsWarnIfUnused : 1;
99
100   ~MacroInfo() {
101    assert(ArgumentList == 0 && "Didn't call destroy before dtor!");
102  }
103
104public:
105  MacroInfo(SourceLocation DefLoc);
106  MacroInfo(const MacroInfo &MI, llvm::BumpPtrAllocator &PPAllocator);
107
108  /// FreeArgumentList - Free the argument list of the macro, restoring it to a
109  /// state where it can be reused for other devious purposes.
110  void FreeArgumentList() {
111    ArgumentList = 0;
112    NumArguments = 0;
113  }
114
115  /// Destroy - destroy this MacroInfo object.
116  void Destroy() {
117    FreeArgumentList();
118    this->~MacroInfo();
119  }
120
121  /// getDefinitionLoc - Return the location that the macro was defined at.
122  ///
123  SourceLocation getDefinitionLoc() const { return Location; }
124
125  /// setDefinitionEndLoc - Set the location of the last token in the macro.
126  ///
127  void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; }
128  /// getDefinitionEndLoc - Return the location of the last token in the macro.
129  ///
130  SourceLocation getDefinitionEndLoc() const { return EndLocation; }
131
132  /// \brief Get length in characters of the macro definition.
133  unsigned getDefinitionLength(SourceManager &SM) const {
134    if (IsDefinitionLengthCached)
135      return DefinitionLength;
136    return getDefinitionLengthSlow(SM);
137  }
138
139  /// isIdenticalTo - Return true if the specified macro definition is equal to
140  /// this macro in spelling, arguments, and whitespace.  This is used to emit
141  /// duplicate definition warnings.  This implements the rules in C99 6.10.3.
142  bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP) const;
143
144  /// setIsBuiltinMacro - Set or clear the isBuiltinMacro flag.
145  ///
146  void setIsBuiltinMacro(bool Val = true) {
147    IsBuiltinMacro = Val;
148  }
149
150  /// setIsUsed - Set the value of the IsUsed flag.
151  ///
152  void setIsUsed(bool Val) {
153    IsUsed = Val;
154  }
155
156  /// setIsAllowRedefinitionsWithoutWarning - Set the value of the
157  /// IsAllowRedefinitionsWithoutWarning flag.
158  void setIsAllowRedefinitionsWithoutWarning(bool Val) {
159    IsAllowRedefinitionsWithoutWarning = Val;
160  }
161
162  /// \brief Set the value of the IsWarnIfUnused flag.
163  void setIsWarnIfUnused(bool val) {
164    IsWarnIfUnused = val;
165  }
166
167  /// setArgumentList - Set the specified list of identifiers as the argument
168  /// list for this macro.
169  void setArgumentList(IdentifierInfo* const *List, unsigned NumArgs,
170                       llvm::BumpPtrAllocator &PPAllocator) {
171    assert(ArgumentList == 0 && NumArguments == 0 &&
172           "Argument list already set!");
173    if (NumArgs == 0) return;
174
175    NumArguments = NumArgs;
176    ArgumentList = PPAllocator.Allocate<IdentifierInfo*>(NumArgs);
177    for (unsigned i = 0; i != NumArgs; ++i)
178      ArgumentList[i] = List[i];
179  }
180
181  /// Arguments - The list of arguments for a function-like macro.  This can be
182  /// empty, for, e.g. "#define X()".
183  typedef IdentifierInfo* const *arg_iterator;
184  bool arg_empty() const { return NumArguments == 0; }
185  arg_iterator arg_begin() const { return ArgumentList; }
186  arg_iterator arg_end() const { return ArgumentList+NumArguments; }
187  unsigned getNumArgs() const { return NumArguments; }
188
189  /// getArgumentNum - Return the argument number of the specified identifier,
190  /// or -1 if the identifier is not a formal argument identifier.
191  int getArgumentNum(IdentifierInfo *Arg) const {
192    for (arg_iterator I = arg_begin(), E = arg_end(); I != E; ++I)
193      if (*I == Arg) return I-arg_begin();
194    return -1;
195  }
196
197  /// Function/Object-likeness.  Keep track of whether this macro has formal
198  /// parameters.
199  void setIsFunctionLike() { IsFunctionLike = true; }
200  bool isFunctionLike() const { return IsFunctionLike; }
201  bool isObjectLike() const { return !IsFunctionLike; }
202
203  /// Varargs querying methods.  This can only be set for function-like macros.
204  void setIsC99Varargs() { IsC99Varargs = true; }
205  void setIsGNUVarargs() { IsGNUVarargs = true; }
206  bool isC99Varargs() const { return IsC99Varargs; }
207  bool isGNUVarargs() const { return IsGNUVarargs; }
208  bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; }
209
210  /// isBuiltinMacro - Return true if this macro is a builtin macro, such as
211  /// __LINE__, which requires processing before expansion.
212  bool isBuiltinMacro() const { return IsBuiltinMacro; }
213
214  /// isFromAST - Return true if this macro was loaded from an AST file.
215  bool isFromAST() const { return IsFromAST; }
216
217  /// setIsFromAST - Set whether this macro was loaded from an AST file.
218  void setIsFromAST(bool FromAST = true) { IsFromAST = FromAST; }
219
220  /// \brief Determine whether this macro has changed since it was loaded from
221  /// an AST file.
222  bool hasChangedAfterLoad() const { return ChangedAfterLoad; }
223
224  /// \brief Note whether this macro has changed after it was loaded from an
225  /// AST file.
226  void setChangedAfterLoad(bool CAL = true) { ChangedAfterLoad = CAL; }
227
228  /// isUsed - Return false if this macro is defined in the main file and has
229  /// not yet been used.
230  bool isUsed() const { return IsUsed; }
231
232  /// isAllowRedefinitionsWithoutWarning - Return true if this macro can be
233  /// redefined without warning.
234  bool isAllowRedefinitionsWithoutWarning() const {
235    return IsAllowRedefinitionsWithoutWarning;
236  }
237
238  /// \brief Return true if we should emit a warning if the macro is unused.
239  bool isWarnIfUnused() const {
240    return IsWarnIfUnused;
241  }
242
243  /// getNumTokens - Return the number of tokens that this macro expands to.
244  ///
245  unsigned getNumTokens() const {
246    return ReplacementTokens.size();
247  }
248
249  const Token &getReplacementToken(unsigned Tok) const {
250    assert(Tok < ReplacementTokens.size() && "Invalid token #");
251    return ReplacementTokens[Tok];
252  }
253
254  typedef SmallVector<Token, 8>::const_iterator tokens_iterator;
255  tokens_iterator tokens_begin() const { return ReplacementTokens.begin(); }
256  tokens_iterator tokens_end() const { return ReplacementTokens.end(); }
257  bool tokens_empty() const { return ReplacementTokens.empty(); }
258
259  /// AddTokenToBody - Add the specified token to the replacement text for the
260  /// macro.
261  void AddTokenToBody(const Token &Tok) {
262    assert(!IsDefinitionLengthCached &&
263          "Changing replacement tokens after definition length got calculated");
264    ReplacementTokens.push_back(Tok);
265  }
266
267  /// isEnabled - Return true if this macro is enabled: in other words, that we
268  /// are not currently in an expansion of this macro.
269  bool isEnabled() const { return !IsDisabled; }
270
271  void EnableMacro() {
272    assert(IsDisabled && "Cannot enable an already-enabled macro!");
273    IsDisabled = false;
274  }
275
276  void DisableMacro() {
277    assert(!IsDisabled && "Cannot disable an already-disabled macro!");
278    IsDisabled = true;
279  }
280
281  /// \brief Set the export location for this macro.
282  void setExportLocation(SourceLocation ExportLoc) {
283    ExportLocation = ExportLoc;
284  }
285
286  /// \brief Determine whether this macro was explicitly exported from its
287  /// module.
288  bool isExported() const { return ExportLocation.isValid(); }
289
290  /// \brief Determine the location where this macro was explicitly exported
291  /// from its module.
292  SourceLocation getExportLocation() { return ExportLocation; }
293
294private:
295  unsigned getDefinitionLengthSlow(SourceManager &SM) const;
296};
297
298}  // end namespace clang
299
300#endif
301