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/// \brief Encapsulates the data about a macro definition (e.g. its tokens).
26/// There's an instance of this class for every #define.
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 \c __VA_ARGS__ identifier on the list.
39  IdentifierInfo **ArgumentList;
40  unsigned NumArguments;
41
42  /// \brief This is the list of tokens that the macro is defined to.
43  SmallVector<Token, 8> ReplacementTokens;
44
45  /// \brief Length in characters of the macro definition.
46  mutable unsigned DefinitionLength;
47  mutable bool IsDefinitionLengthCached : 1;
48
49  /// \brief True if this macro is a function-like macro, false if it
50  /// is an object-like macro.
51  bool IsFunctionLike : 1;
52
53  /// IsC99Varargs - True if this macro is of the form "#define X(...)" or
54  /// "#define X(Y,Z,...)".  The __VA_ARGS__ token should be replaced with the
55  /// contents of "..." in an invocation.
56  bool IsC99Varargs : 1;
57
58  /// IsGNUVarargs -  True if this macro is of the form "#define X(a...)".  The
59  /// "a" identifier in the replacement list will be replaced with all arguments
60  /// of the macro starting with the specified one.
61  bool IsGNUVarargs : 1;
62
63  /// IsBuiltinMacro - True if this is a builtin macro, such as __LINE__, and if
64  /// it has not yet been redefined or undefined.
65  bool IsBuiltinMacro : 1;
66
67  /// \brief Whether this macro contains the sequence ", ## __VA_ARGS__"
68  bool HasCommaPasting : 1;
69
70private:
71  //===--------------------------------------------------------------------===//
72  // State that changes as the macro is used.
73
74  /// IsDisabled - True if we have started an expansion of this macro already.
75  /// This disables recursive expansion, which would be quite bad for things
76  /// like \#define A A.
77  bool IsDisabled : 1;
78
79  /// IsUsed - True if this macro is either defined in the main file and has
80  /// been used, or if it is not defined in the main file.  This is used to
81  /// emit -Wunused-macros diagnostics.
82  bool IsUsed : 1;
83
84  /// AllowRedefinitionsWithoutWarning - True if this macro can be redefined
85  /// without emitting a warning.
86  bool IsAllowRedefinitionsWithoutWarning : 1;
87
88  /// \brief Must warn if the macro is unused at the end of translation unit.
89  bool IsWarnIfUnused : 1;
90
91   ~MacroInfo() {
92    assert(ArgumentList == 0 && "Didn't call destroy before dtor!");
93  }
94
95public:
96  MacroInfo(SourceLocation DefLoc);
97
98  /// FreeArgumentList - Free the argument list of the macro, restoring it to a
99  /// state where it can be reused for other devious purposes.
100  void FreeArgumentList() {
101    ArgumentList = 0;
102    NumArguments = 0;
103  }
104
105  /// Destroy - destroy this MacroInfo object.
106  void Destroy() {
107    FreeArgumentList();
108    this->~MacroInfo();
109  }
110
111  /// getDefinitionLoc - Return the location that the macro was defined at.
112  ///
113  SourceLocation getDefinitionLoc() const { return Location; }
114
115  /// setDefinitionEndLoc - Set the location of the last token in the macro.
116  ///
117  void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; }
118
119  /// getDefinitionEndLoc - Return the location of the last token in the macro.
120  ///
121  SourceLocation getDefinitionEndLoc() const { return EndLocation; }
122
123  /// \brief Get length in characters of the macro definition.
124  unsigned getDefinitionLength(SourceManager &SM) const {
125    if (IsDefinitionLengthCached)
126      return DefinitionLength;
127    return getDefinitionLengthSlow(SM);
128  }
129
130  /// isIdenticalTo - Return true if the specified macro definition is equal to
131  /// this macro in spelling, arguments, and whitespace.  This is used to emit
132  /// duplicate definition warnings.  This implements the rules in C99 6.10.3.
133  bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP) const;
134
135  /// setIsBuiltinMacro - Set or clear the isBuiltinMacro flag.
136  ///
137  void setIsBuiltinMacro(bool Val = true) {
138    IsBuiltinMacro = Val;
139  }
140
141  /// setIsUsed - Set the value of the IsUsed flag.
142  ///
143  void setIsUsed(bool Val) {
144    IsUsed = Val;
145  }
146
147  /// setIsAllowRedefinitionsWithoutWarning - Set the value of the
148  /// IsAllowRedefinitionsWithoutWarning flag.
149  void setIsAllowRedefinitionsWithoutWarning(bool Val) {
150    IsAllowRedefinitionsWithoutWarning = Val;
151  }
152
153  /// \brief Set the value of the IsWarnIfUnused flag.
154  void setIsWarnIfUnused(bool val) {
155    IsWarnIfUnused = val;
156  }
157
158  /// setArgumentList - Set the specified list of identifiers as the argument
159  /// list for this macro.
160  void setArgumentList(IdentifierInfo* const *List, unsigned NumArgs,
161                       llvm::BumpPtrAllocator &PPAllocator) {
162    assert(ArgumentList == 0 && NumArguments == 0 &&
163           "Argument list already set!");
164    if (NumArgs == 0) return;
165
166    NumArguments = NumArgs;
167    ArgumentList = PPAllocator.Allocate<IdentifierInfo*>(NumArgs);
168    for (unsigned i = 0; i != NumArgs; ++i)
169      ArgumentList[i] = List[i];
170  }
171
172  /// Arguments - The list of arguments for a function-like macro.  This can be
173  /// empty, for, e.g. "#define X()".
174  typedef IdentifierInfo* const *arg_iterator;
175  bool arg_empty() const { return NumArguments == 0; }
176  arg_iterator arg_begin() const { return ArgumentList; }
177  arg_iterator arg_end() const { return ArgumentList+NumArguments; }
178  unsigned getNumArgs() const { return NumArguments; }
179
180  /// getArgumentNum - Return the argument number of the specified identifier,
181  /// or -1 if the identifier is not a formal argument identifier.
182  int getArgumentNum(IdentifierInfo *Arg) const {
183    for (arg_iterator I = arg_begin(), E = arg_end(); I != E; ++I)
184      if (*I == Arg) return I-arg_begin();
185    return -1;
186  }
187
188  /// Function/Object-likeness.  Keep track of whether this macro has formal
189  /// parameters.
190  void setIsFunctionLike() { IsFunctionLike = true; }
191  bool isFunctionLike() const { return IsFunctionLike; }
192  bool isObjectLike() const { return !IsFunctionLike; }
193
194  /// Varargs querying methods.  This can only be set for function-like macros.
195  void setIsC99Varargs() { IsC99Varargs = true; }
196  void setIsGNUVarargs() { IsGNUVarargs = true; }
197  bool isC99Varargs() const { return IsC99Varargs; }
198  bool isGNUVarargs() const { return IsGNUVarargs; }
199  bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; }
200
201  /// isBuiltinMacro - Return true if this macro is a builtin macro, such as
202  /// __LINE__, which requires processing before expansion.
203  bool isBuiltinMacro() const { return IsBuiltinMacro; }
204
205  bool hasCommaPasting() const { return HasCommaPasting; }
206  void setHasCommaPasting() { HasCommaPasting = true; }
207
208  /// isUsed - Return false if this macro is defined in the main file and has
209  /// not yet been used.
210  bool isUsed() const { return IsUsed; }
211
212  /// isAllowRedefinitionsWithoutWarning - Return true if this macro can be
213  /// redefined without warning.
214  bool isAllowRedefinitionsWithoutWarning() const {
215    return IsAllowRedefinitionsWithoutWarning;
216  }
217
218  /// \brief Return true if we should emit a warning if the macro is unused.
219  bool isWarnIfUnused() const {
220    return IsWarnIfUnused;
221  }
222
223  /// getNumTokens - Return the number of tokens that this macro expands to.
224  ///
225  unsigned getNumTokens() const {
226    return ReplacementTokens.size();
227  }
228
229  const Token &getReplacementToken(unsigned Tok) const {
230    assert(Tok < ReplacementTokens.size() && "Invalid token #");
231    return ReplacementTokens[Tok];
232  }
233
234  typedef SmallVector<Token, 8>::const_iterator tokens_iterator;
235  tokens_iterator tokens_begin() const { return ReplacementTokens.begin(); }
236  tokens_iterator tokens_end() const { return ReplacementTokens.end(); }
237  bool tokens_empty() const { return ReplacementTokens.empty(); }
238
239  /// AddTokenToBody - Add the specified token to the replacement text for the
240  /// macro.
241  void AddTokenToBody(const Token &Tok) {
242    assert(!IsDefinitionLengthCached &&
243          "Changing replacement tokens after definition length got calculated");
244    ReplacementTokens.push_back(Tok);
245  }
246
247  /// isEnabled - Return true if this macro is enabled: in other words, that we
248  /// are not currently in an expansion of this macro.
249  bool isEnabled() const { return !IsDisabled; }
250
251  void EnableMacro() {
252    assert(IsDisabled && "Cannot enable an already-enabled macro!");
253    IsDisabled = false;
254  }
255
256  void DisableMacro() {
257    assert(!IsDisabled && "Cannot disable an already-disabled macro!");
258    IsDisabled = true;
259  }
260
261private:
262  unsigned getDefinitionLengthSlow(SourceManager &SM) const;
263};
264
265/// \brief Encapsulates changes to the "macros namespace" (the location where
266/// the macro name became active, the location where it was undefined, etc.).
267///
268/// MacroDirectives, associated with an identifier, are used to model the macro
269/// history. Usually a macro definition (MacroInfo) is where a macro name
270/// becomes active (MacroDirective) but modules can have their own macro
271/// history, separate from the local (current translation unit) macro history.
272///
273/// For example, if "@import A;" imports macro FOO, there will be a new local
274/// MacroDirective created to indicate that "FOO" became active at the import
275/// location. Module "A" itself will contain another MacroDirective in its macro
276/// history (at the point of the definition of FOO) and both MacroDirectives
277/// will point to the same MacroInfo object.
278///
279class MacroDirective {
280  MacroInfo *Info;
281
282  /// \brief Previous definition, the identifier of this macro was defined to,
283  /// or NULL.
284  MacroDirective *Previous;
285
286  SourceLocation Loc;
287
288  /// \brief The location where the macro was #undef'd, or an invalid location
289  /// for macros that haven't been undefined.
290  SourceLocation UndefLocation;
291
292  /// \brief The location at which this macro was either explicitly exported
293  /// from its module or marked as private.
294  ///
295  /// If invalid, this macro has not been explicitly given any visibility.
296  SourceLocation VisibilityLocation;
297
298  /// \brief True if this macro was loaded from an AST file.
299  bool IsImported : 1;
300
301  /// \brief Whether the macro has public (when described in a module).
302  bool IsPublic : 1;
303
304  /// \brief Whether the macro definition is currently "hidden".
305  /// Note that this is transient state that is never serialized to the AST
306  /// file.
307  bool IsHidden : 1;
308
309  /// \brief Whether the definition of this macro is ambiguous, due to
310  /// multiple definitions coming in from multiple modules.
311  bool IsAmbiguous : 1;
312
313  /// \brief Whether this macro changed after it was loaded from an AST file.
314  bool ChangedAfterLoad : 1;
315
316public:
317  explicit MacroDirective(MacroInfo *MI)
318    : Info(MI), Previous(0), Loc(MI->getDefinitionLoc()),
319      IsImported(false), IsPublic(true), IsHidden(false), IsAmbiguous(false),
320      ChangedAfterLoad(false) {
321    assert(MI && "MacroInfo is null");
322  }
323
324  MacroDirective(MacroInfo *MI, SourceLocation Loc, bool isImported)
325    : Info(MI), Previous(0), Loc(Loc),
326      IsImported(isImported), IsPublic(true), IsHidden(false),
327      IsAmbiguous(false), ChangedAfterLoad(false) {
328    assert(MI && "MacroInfo is null");
329  }
330
331  SourceLocation getLocation() const { return Loc; }
332
333  /// \brief Set the location where macro was undefined. Can only be set once.
334  void setUndefLoc(SourceLocation UndefLoc) {
335    assert(UndefLocation.isInvalid() && "UndefLocation is already set!");
336    assert(UndefLoc.isValid() && "Invalid UndefLoc!");
337    UndefLocation = UndefLoc;
338  }
339
340  /// \brief The data for the macro definition.
341  const MacroInfo *getInfo() const { return Info; }
342  MacroInfo *getInfo() { return Info; }
343
344  /// \brief Get the location where macro was undefined.
345  SourceLocation getUndefLoc() const { return UndefLocation; }
346
347  /// \brief Set previous definition of the macro with the same name.
348  void setPrevious(MacroDirective *Prev) {
349    Previous = Prev;
350  }
351
352  /// \brief Get previous definition of the macro with the same name.
353  const MacroDirective *getPrevious() const { return Previous; }
354
355  /// \brief Get previous definition of the macro with the same name.
356  MacroDirective *getPrevious() { return Previous; }
357
358  /// \brief Find macro definition active in the specified source location. If
359  /// this macro was not defined there, return NULL.
360  const MacroDirective *findDirectiveAtLoc(SourceLocation L,
361                                           SourceManager &SM) const;
362
363  /// \brief Set the export location for this macro.
364  void setVisibility(bool Public, SourceLocation Loc) {
365    VisibilityLocation = Loc;
366    IsPublic = Public;
367  }
368
369  /// \brief Determine whether this macro is part of the public API of its
370  /// module.
371  bool isPublic() const { return IsPublic; }
372
373  /// \brief Determine the location where this macro was explicitly made
374  /// public or private within its module.
375  SourceLocation getVisibilityLocation() const { return VisibilityLocation; }
376
377  /// \brief True if this macro was loaded from an AST file.
378  bool isImported() const { return IsImported; }
379
380  /// \brief Determine whether this macro is currently defined (and has not
381  /// been #undef'd) or has been hidden.
382  bool isDefined() const { return UndefLocation.isInvalid() && !IsHidden; }
383
384  /// \brief Determine whether this macro definition is hidden.
385  bool isHidden() const { return IsHidden; }
386
387  /// \brief Set whether this macro definition is hidden.
388  void setHidden(bool Val) { IsHidden = Val; }
389
390  /// \brief Determine whether this macro definition is ambiguous with
391  /// other macro definitions.
392  bool isAmbiguous() const { return IsAmbiguous; }
393
394  /// \brief Set whether this macro definition is ambiguous.
395  void setAmbiguous(bool Val) { IsAmbiguous = Val; }
396
397  /// \brief Determine whether this macro has changed since it was loaded from
398  /// an AST file.
399  bool hasChangedAfterLoad() const { return ChangedAfterLoad; }
400
401  /// \brief Note whether this macro has changed after it was loaded from an
402  /// AST file.
403  void setChangedAfterLoad(bool CAL = true) { ChangedAfterLoad = CAL; }
404};
405
406}  // end namespace clang
407
408#endif
409