Clang Project

clang_source_code/include/clang/Lex/MacroInfo.h
1//===- MacroInfo.h - Information about #defined identifiers -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::MacroInfo and clang::MacroDirective classes.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_LEX_MACROINFO_H
15#define LLVM_CLANG_LEX_MACROINFO_H
16
17#include "clang/Lex/Token.h"
18#include "clang/Basic/LLVM.h"
19#include "clang/Basic/SourceLocation.h"
20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/ADT/FoldingSet.h"
22#include "llvm/ADT/PointerIntPair.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/Support/Allocator.h"
25#include <algorithm>
26#include <cassert>
27
28namespace clang {
29
30class DefMacroDirective;
31class IdentifierInfo;
32class Module;
33class Preprocessor;
34class SourceManager;
35
36/// Encapsulates the data about a macro definition (e.g. its tokens).
37///
38/// There's an instance of this class for every #define.
39class MacroInfo {
40  //===--------------------------------------------------------------------===//
41  // State set when the macro is defined.
42
43  /// The location the macro is defined.
44  SourceLocation Location;
45
46  /// The location of the last token in the macro.
47  SourceLocation EndLocation;
48
49  /// The list of arguments for a function-like macro.
50  ///
51  /// ParameterList points to the first of NumParameters pointers.
52  ///
53  /// This can be empty, for, e.g. "#define X()".  In a C99-style variadic
54  /// macro, this includes the \c __VA_ARGS__ identifier on the list.
55  IdentifierInfo **ParameterList = nullptr;
56
57  /// \see ParameterList
58  unsigned NumParameters = 0;
59
60  /// This is the list of tokens that the macro is defined to.
61  SmallVector<Token, 8> ReplacementTokens;
62
63  /// Length in characters of the macro definition.
64  mutable unsigned DefinitionLength;
65  mutable bool IsDefinitionLengthCached : 1;
66
67  /// True if this macro is function-like, false if it is object-like.
68  bool IsFunctionLike : 1;
69
70  /// True if this macro is of the form "#define X(...)" or
71  /// "#define X(Y,Z,...)".
72  ///
73  /// The __VA_ARGS__ token should be replaced with the contents of "..." in an
74  /// invocation.
75  bool IsC99Varargs : 1;
76
77  /// True if this macro is of the form "#define X(a...)".
78  ///
79  /// The "a" identifier in the replacement list will be replaced with all
80  /// arguments of the macro starting with the specified one.
81  bool IsGNUVarargs : 1;
82
83  /// True if this macro requires processing before expansion.
84  ///
85  /// This is the case for builtin macros such as __LINE__, so long as they have
86  /// not been redefined, but not for regular predefined macros from the
87  /// "<built-in>" memory buffer (see Preprocessing::getPredefinesFileID).
88  bool IsBuiltinMacro : 1;
89
90  /// Whether this macro contains the sequence ", ## __VA_ARGS__"
91  bool HasCommaPasting : 1;
92
93  //===--------------------------------------------------------------------===//
94  // State that changes as the macro is used.
95
96  /// True if we have started an expansion of this macro already.
97  ///
98  /// This disables recursive expansion, which would be quite bad for things
99  /// like \#define A A.
100  bool IsDisabled : 1;
101
102  /// True if this macro is either defined in the main file and has
103  /// been used, or if it is not defined in the main file.
104  ///
105  /// This is used to emit -Wunused-macros diagnostics.
106  bool IsUsed : 1;
107
108  /// True if this macro can be redefined without emitting a warning.
109  bool IsAllowRedefinitionsWithoutWarning : 1;
110
111  /// Must warn if the macro is unused at the end of translation unit.
112  bool IsWarnIfUnused : 1;
113
114  /// Whether this macro was used as header guard.
115  bool UsedForHeaderGuard : 1;
116
117  // Only the Preprocessor gets to create and destroy these.
118  MacroInfo(SourceLocation DefLoc);
119  ~MacroInfo() = default;
120
121public:
122  /// Return the location that the macro was defined at.
123  SourceLocation getDefinitionLoc() const { return Location; }
124
125  /// Set the location of the last token in the macro.
126  void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; }
127
128  /// Return the location of the last token in the macro.
129  SourceLocation getDefinitionEndLoc() const { return EndLocation; }
130
131  /// Get length in characters of the macro definition.
132  unsigned getDefinitionLength(const SourceManager &SM) const {
133    if (IsDefinitionLengthCached)
134      return DefinitionLength;
135    return getDefinitionLengthSlow(SM);
136  }
137
138  /// Return true if the specified macro definition is equal to
139  /// this macro in spelling, arguments, and whitespace.
140  ///
141  /// \param Syntactically if true, the macro definitions can be identical even
142  /// if they use different identifiers for the function macro parameters.
143  /// Otherwise the comparison is lexical and this implements the rules in
144  /// C99 6.10.3.
145  bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
146                     bool Syntactically) const;
147
148  /// Set or clear the isBuiltinMacro flag.
149  void setIsBuiltinMacro(bool Val = true) { IsBuiltinMacro = Val; }
150
151  /// Set the value of the IsUsed flag.
152  void setIsUsed(bool Val) { IsUsed = Val; }
153
154  /// Set the value of the IsAllowRedefinitionsWithoutWarning flag.
155  void setIsAllowRedefinitionsWithoutWarning(bool Val) {
156    IsAllowRedefinitionsWithoutWarning = Val;
157  }
158
159  /// Set the value of the IsWarnIfUnused flag.
160  void setIsWarnIfUnused(bool val) { IsWarnIfUnused = val; }
161
162  /// Set the specified list of identifiers as the parameter list for
163  /// this macro.
164  void setParameterList(ArrayRef<IdentifierInfo *> List,
165                       llvm::BumpPtrAllocator &PPAllocator) {
166     (0) . __assert_fail ("ParameterList == nullptr && NumParameters == 0 && \"Parameter list already set!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 167, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(ParameterList == nullptr && NumParameters == 0 &&
167 (0) . __assert_fail ("ParameterList == nullptr && NumParameters == 0 && \"Parameter list already set!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 167, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">           "Parameter list already set!");
168    if (List.empty())
169      return;
170
171    NumParameters = List.size();
172    ParameterList = PPAllocator.Allocate<IdentifierInfo *>(List.size());
173    std::copy(List.begin(), List.end(), ParameterList);
174  }
175
176  /// Parameters - The list of parameters for a function-like macro.  This can
177  /// be empty, for, e.g. "#define X()".
178  using param_iterator = IdentifierInfo *const *;
179  bool param_empty() const { return NumParameters == 0; }
180  param_iterator param_begin() const { return ParameterList; }
181  param_iterator param_end() const { return ParameterList + NumParameters; }
182  unsigned getNumParams() const { return NumParameters; }
183  ArrayRef<const IdentifierInfo *> params() const {
184    return ArrayRef<const IdentifierInfo *>(ParameterList, NumParameters);
185  }
186
187  /// Return the parameter number of the specified identifier,
188  /// or -1 if the identifier is not a formal parameter identifier.
189  int getParameterNum(const IdentifierInfo *Arg) const {
190    for (param_iterator I = param_begin(), E = param_end(); I != E; ++I)
191      if (*I == Arg)
192        return I - param_begin();
193    return -1;
194  }
195
196  /// Function/Object-likeness.  Keep track of whether this macro has formal
197  /// parameters.
198  void setIsFunctionLike() { IsFunctionLike = true; }
199  bool isFunctionLike() const { return IsFunctionLike; }
200  bool isObjectLike() const { return !IsFunctionLike; }
201
202  /// Varargs querying methods.  This can only be set for function-like macros.
203  void setIsC99Varargs() { IsC99Varargs = true; }
204  void setIsGNUVarargs() { IsGNUVarargs = true; }
205  bool isC99Varargs() const { return IsC99Varargs; }
206  bool isGNUVarargs() const { return IsGNUVarargs; }
207  bool isVariadic() const { return IsC99Varargs | IsGNUVarargs; }
208
209  /// Return true if this macro requires processing before expansion.
210  ///
211  /// This is true only for builtin macro, such as \__LINE__, whose values
212  /// are not given by fixed textual expansions.  Regular predefined macros
213  /// from the "<built-in>" buffer are not reported as builtins by this
214  /// function.
215  bool isBuiltinMacro() const { return IsBuiltinMacro; }
216
217  bool hasCommaPasting() const { return HasCommaPasting; }
218  void setHasCommaPasting() { HasCommaPasting = true; }
219
220  /// Return false if this macro is defined in the main file and has
221  /// not yet been used.
222  bool isUsed() const { return IsUsed; }
223
224  /// Return true if this macro can be redefined without warning.
225  bool isAllowRedefinitionsWithoutWarning() const {
226    return IsAllowRedefinitionsWithoutWarning;
227  }
228
229  /// Return true if we should emit a warning if the macro is unused.
230  bool isWarnIfUnused() const { return IsWarnIfUnused; }
231
232  /// Return the number of tokens that this macro expands to.
233  unsigned getNumTokens() const { return ReplacementTokens.size(); }
234
235  const Token &getReplacementToken(unsigned Tok) const {
236     (0) . __assert_fail ("Tok < ReplacementTokens.size() && \"Invalid token #\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 236, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(Tok < ReplacementTokens.size() && "Invalid token #");
237    return ReplacementTokens[Tok];
238  }
239
240  using tokens_iterator = SmallVectorImpl<Token>::const_iterator;
241
242  tokens_iterator tokens_begin() const { return ReplacementTokens.begin(); }
243  tokens_iterator tokens_end() const { return ReplacementTokens.end(); }
244  bool tokens_empty() const { return ReplacementTokens.empty(); }
245  ArrayRef<Token> tokens() const { return ReplacementTokens; }
246
247  /// Add the specified token to the replacement text for the macro.
248  void AddTokenToBody(const Token &Tok) {
249     (0) . __assert_fail ("!IsDefinitionLengthCached && \"Changing replacement tokens after definition length got calculated\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 251, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(
250 (0) . __assert_fail ("!IsDefinitionLengthCached && \"Changing replacement tokens after definition length got calculated\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 251, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">        !IsDefinitionLengthCached &&
251 (0) . __assert_fail ("!IsDefinitionLengthCached && \"Changing replacement tokens after definition length got calculated\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 251, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">        "Changing replacement tokens after definition length got calculated");
252    ReplacementTokens.push_back(Tok);
253  }
254
255  /// Return true if this macro is enabled.
256  ///
257  /// In other words, that we are not currently in an expansion of this macro.
258  bool isEnabled() const { return !IsDisabled; }
259
260  void EnableMacro() {
261     (0) . __assert_fail ("IsDisabled && \"Cannot enable an already-enabled macro!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 261, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(IsDisabled && "Cannot enable an already-enabled macro!");
262    IsDisabled = false;
263  }
264
265  void DisableMacro() {
266     (0) . __assert_fail ("!IsDisabled && \"Cannot disable an already-disabled macro!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 266, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(!IsDisabled && "Cannot disable an already-disabled macro!");
267    IsDisabled = true;
268  }
269
270  /// Determine whether this macro was used for a header guard.
271  bool isUsedForHeaderGuard() const { return UsedForHeaderGuard; }
272
273  void setUsedForHeaderGuard(bool Val) { UsedForHeaderGuard = Val; }
274
275  void dump() const;
276
277private:
278  friend class Preprocessor;
279
280  unsigned getDefinitionLengthSlow(const SourceManager &SM) const;
281};
282
283/// Encapsulates changes to the "macros namespace" (the location where
284/// the macro name became active, the location where it was undefined, etc.).
285///
286/// MacroDirectives, associated with an identifier, are used to model the macro
287/// history. Usually a macro definition (MacroInfo) is where a macro name
288/// becomes active (MacroDirective) but #pragma push_macro / pop_macro can
289/// create additional DefMacroDirectives for the same MacroInfo.
290class MacroDirective {
291public:
292  enum Kind {
293    MD_Define,
294    MD_Undefine,
295    MD_Visibility
296  };
297
298protected:
299  /// Previous macro directive for the same identifier, or nullptr.
300  MacroDirective *Previous = nullptr;
301
302  SourceLocation Loc;
303
304  /// MacroDirective kind.
305  unsigned MDKind : 2;
306
307  /// True if the macro directive was loaded from a PCH file.
308  unsigned IsFromPCH : 1;
309
310  // Used by VisibilityMacroDirective ----------------------------------------//
311
312  /// Whether the macro has public visibility (when described in a
313  /// module).
314  unsigned IsPublic : 1;
315
316  MacroDirective(Kind K, SourceLocation Loc)
317      : Loc(Loc), MDKind(K), IsFromPCH(false), IsPublic(true) {}
318
319public:
320  Kind getKind() const { return Kind(MDKind); }
321
322  SourceLocation getLocation() const { return Loc; }
323
324  /// Set previous definition of the macro with the same name.
325  void setPrevious(MacroDirective *Prev) { Previous = Prev; }
326
327  /// Get previous definition of the macro with the same name.
328  const MacroDirective *getPrevious() const { return Previous; }
329
330  /// Get previous definition of the macro with the same name.
331  MacroDirective *getPrevious() { return Previous; }
332
333  /// Return true if the macro directive was loaded from a PCH file.
334  bool isFromPCH() const { return IsFromPCH; }
335
336  void setIsFromPCH() { IsFromPCH = true; }
337
338  class DefInfo {
339    DefMacroDirective *DefDirective = nullptr;
340    SourceLocation UndefLoc;
341    bool IsPublic = true;
342
343  public:
344    DefInfo() = default;
345    DefInfo(DefMacroDirective *DefDirective, SourceLocation UndefLoc,
346            bool isPublic)
347        : DefDirective(DefDirective), UndefLoc(UndefLoc), IsPublic(isPublic) {}
348
349    const DefMacroDirective *getDirective() const { return DefDirective; }
350    DefMacroDirective *getDirective() { return DefDirective; }
351
352    inline SourceLocation getLocation() const;
353    inline MacroInfo *getMacroInfo();
354
355    const MacroInfo *getMacroInfo() const {
356      return const_cast<DefInfo *>(this)->getMacroInfo();
357    }
358
359    SourceLocation getUndefLocation() const { return UndefLoc; }
360    bool isUndefined() const { return UndefLoc.isValid(); }
361
362    bool isPublic() const { return IsPublic; }
363
364    bool isValid() const { return DefDirective != nullptr; }
365    bool isInvalid() const { return !isValid(); }
366
367    explicit operator bool() const { return isValid(); }
368
369    inline DefInfo getPreviousDefinition();
370
371    const DefInfo getPreviousDefinition() const {
372      return const_cast<DefInfo *>(this)->getPreviousDefinition();
373    }
374  };
375
376  /// Traverses the macro directives history and returns the next
377  /// macro definition directive along with info about its undefined location
378  /// (if there is one) and if it is public or private.
379  DefInfo getDefinition();
380  const DefInfo getDefinition() const {
381    return const_cast<MacroDirective *>(this)->getDefinition();
382  }
383
384  bool isDefined() const {
385    if (const DefInfo Def = getDefinition())
386      return !Def.isUndefined();
387    return false;
388  }
389
390  const MacroInfo *getMacroInfo() const {
391    return getDefinition().getMacroInfo();
392  }
393  MacroInfo *getMacroInfo() { return getDefinition().getMacroInfo(); }
394
395  /// Find macro definition active in the specified source location. If
396  /// this macro was not defined there, return NULL.
397  const DefInfo findDirectiveAtLoc(SourceLocation L,
398                                   const SourceManager &SM) const;
399
400  void dump() const;
401
402  static bool classof(const MacroDirective *) { return true; }
403};
404
405/// A directive for a defined macro or a macro imported from a module.
406class DefMacroDirective : public MacroDirective {
407  MacroInfo *Info;
408
409public:
410  DefMacroDirective(MacroInfo *MI, SourceLocation Loc)
411      : MacroDirective(MD_Define, Loc), Info(MI) {
412     (0) . __assert_fail ("MI && \"MacroInfo is null\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 412, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(MI && "MacroInfo is null");
413  }
414  explicit DefMacroDirective(MacroInfo *MI)
415      : DefMacroDirective(MI, MI->getDefinitionLoc()) {}
416
417  /// The data for the macro definition.
418  const MacroInfo *getInfo() const { return Info; }
419  MacroInfo *getInfo() { return Info; }
420
421  static bool classof(const MacroDirective *MD) {
422    return MD->getKind() == MD_Define;
423  }
424
425  static bool classof(const DefMacroDirective *) { return true; }
426};
427
428/// A directive for an undefined macro.
429class UndefMacroDirective : public MacroDirective {
430public:
431  explicit UndefMacroDirective(SourceLocation UndefLoc)
432      : MacroDirective(MD_Undefine, UndefLoc) {
433     (0) . __assert_fail ("UndefLoc.isValid() && \"Invalid UndefLoc!\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Lex/MacroInfo.h", 433, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(UndefLoc.isValid() && "Invalid UndefLoc!");
434  }
435
436  static bool classof(const MacroDirective *MD) {
437    return MD->getKind() == MD_Undefine;
438  }
439
440  static bool classof(const UndefMacroDirective *) { return true; }
441};
442
443/// A directive for setting the module visibility of a macro.
444class VisibilityMacroDirective : public MacroDirective {
445public:
446  explicit VisibilityMacroDirective(SourceLocation Loc, bool Public)
447      : MacroDirective(MD_Visibility, Loc) {
448    IsPublic = Public;
449  }
450
451  /// Determine whether this macro is part of the public API of its
452  /// module.
453  bool isPublic() const { return IsPublic; }
454
455  static bool classof(const MacroDirective *MD) {
456    return MD->getKind() == MD_Visibility;
457  }
458
459  static bool classof(const VisibilityMacroDirective *) { return true; }
460};
461
462inline SourceLocation MacroDirective::DefInfo::getLocation() const {
463  if (isInvalid())
464    return {};
465  return DefDirective->getLocation();
466}
467
468inline MacroInfo *MacroDirective::DefInfo::getMacroInfo() {
469  if (isInvalid())
470    return nullptr;
471  return DefDirective->getInfo();
472}
473
474inline MacroDirective::DefInfo
475MacroDirective::DefInfo::getPreviousDefinition() {
476  if (isInvalid() || DefDirective->getPrevious() == nullptr)
477    return {};
478  return DefDirective->getPrevious()->getDefinition();
479}
480
481/// Represents a macro directive exported by a module.
482///
483/// There's an instance of this class for every macro #define or #undef that is
484/// the final directive for a macro name within a module. These entities also
485/// represent the macro override graph.
486///
487/// These are stored in a FoldingSet in the preprocessor.
488class ModuleMacro : public llvm::FoldingSetNode {
489  friend class Preprocessor;
490
491  /// The name defined by the macro.
492  IdentifierInfo *II;
493
494  /// The body of the #define, or nullptr if this is a #undef.
495  MacroInfo *Macro;
496
497  /// The module that exports this macro.
498  Module *OwningModule;
499
500  /// The number of module macros that override this one.
501  unsigned NumOverriddenBy = 0;
502
503  /// The number of modules whose macros are directly overridden by this one.
504  unsigned NumOverrides;
505
506  ModuleMacro(Module *OwningModule, IdentifierInfo *II, MacroInfo *Macro,
507              ArrayRef<ModuleMacro *> Overrides)
508      : II(II), Macro(Macro), OwningModule(OwningModule),
509        NumOverrides(Overrides.size()) {
510    std::copy(Overrides.begin(), Overrides.end(),
511              reinterpret_cast<ModuleMacro **>(this + 1));
512  }
513
514public:
515  static ModuleMacro *create(Preprocessor &PP, Module *OwningModule,
516                             IdentifierInfo *II, MacroInfo *Macro,
517                             ArrayRef<ModuleMacro *> Overrides);
518
519  void Profile(llvm::FoldingSetNodeID &ID) const {
520    return Profile(ID, OwningModule, II);
521  }
522
523  static void Profile(llvm::FoldingSetNodeID &ID, Module *OwningModule,
524                      IdentifierInfo *II) {
525    ID.AddPointer(OwningModule);
526    ID.AddPointer(II);
527  }
528
529  /// Get the name of the macro.
530  IdentifierInfo *getName() const { return II; }
531
532  /// Get the ID of the module that exports this macro.
533  Module *getOwningModule() const { return OwningModule; }
534
535  /// Get definition for this exported #define, or nullptr if this
536  /// represents a #undef.
537  MacroInfo *getMacroInfo() const { return Macro; }
538
539  /// Iterators over the overridden module IDs.
540  /// \{
541  using overrides_iterator = ModuleMacro *const *;
542
543  overrides_iterator overrides_begin() const {
544    return reinterpret_cast<overrides_iterator>(this + 1);
545  }
546
547  overrides_iterator overrides_end() const {
548    return overrides_begin() + NumOverrides;
549  }
550
551  ArrayRef<ModuleMacro *> overrides() const {
552    return llvm::makeArrayRef(overrides_begin(), overrides_end());
553  }
554  /// \}
555
556  /// Get the number of macros that override this one.
557  unsigned getNumOverridingMacros() const { return NumOverriddenBy; }
558};
559
560/// A description of the current definition of a macro.
561///
562/// The definition of a macro comprises a set of (at least one) defining
563/// entities, which are either local MacroDirectives or imported ModuleMacros.
564class MacroDefinition {
565  llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous;
566  ArrayRef<ModuleMacro *> ModuleMacros;
567
568public:
569  MacroDefinition() = default;
570  MacroDefinition(DefMacroDirective *MD, ArrayRef<ModuleMacro *> MMs,
571                  bool IsAmbiguous)
572      : LatestLocalAndAmbiguous(MD, IsAmbiguous), ModuleMacros(MMs) {}
573
574  /// Determine whether there is a definition of this macro.
575  explicit operator bool() const {
576    return getLocalDirective() || !ModuleMacros.empty();
577  }
578
579  /// Get the MacroInfo that should be used for this definition.
580  MacroInfo *getMacroInfo() const {
581    if (!ModuleMacros.empty())
582      return ModuleMacros.back()->getMacroInfo();
583    if (auto *MD = getLocalDirective())
584      return MD->getMacroInfo();
585    return nullptr;
586  }
587
588  /// \c true if the definition is ambiguous, \c false otherwise.
589  bool isAmbiguous() const { return LatestLocalAndAmbiguous.getInt(); }
590
591  /// Get the latest non-imported, non-\#undef'd macro definition
592  /// for this macro.
593  DefMacroDirective *getLocalDirective() const {
594    return LatestLocalAndAmbiguous.getPointer();
595  }
596
597  /// Get the active module macros for this macro.
598  ArrayRef<ModuleMacro *> getModuleMacros() const { return ModuleMacros; }
599
600  template <typename Fn> void forAllDefinitions(Fn F) const {
601    if (auto *MD = getLocalDirective())
602      F(MD->getMacroInfo());
603    for (auto *MM : getModuleMacros())
604      F(MM->getMacroInfo());
605  }
606};
607
608} // namespace clang
609
610#endif // LLVM_CLANG_LEX_MACROINFO_H
611
clang::MacroInfo::Location
clang::MacroInfo::EndLocation
clang::MacroInfo::ParameterList
clang::MacroInfo::NumParameters
clang::MacroInfo::ReplacementTokens
clang::MacroInfo::DefinitionLength
clang::MacroInfo::IsDefinitionLengthCached
clang::MacroInfo::IsFunctionLike
clang::MacroInfo::IsC99Varargs
clang::MacroInfo::IsGNUVarargs
clang::MacroInfo::IsBuiltinMacro
clang::MacroInfo::HasCommaPasting
clang::MacroInfo::IsDisabled
clang::MacroInfo::IsUsed
clang::MacroInfo::IsAllowRedefinitionsWithoutWarning
clang::MacroInfo::IsWarnIfUnused
clang::MacroInfo::UsedForHeaderGuard
clang::MacroInfo::getDefinitionLoc
clang::MacroInfo::setDefinitionEndLoc
clang::MacroInfo::getDefinitionEndLoc
clang::MacroInfo::getDefinitionLength
clang::MacroInfo::isIdenticalTo
clang::MacroInfo::setIsBuiltinMacro
clang::MacroInfo::setIsUsed
clang::MacroInfo::setIsAllowRedefinitionsWithoutWarning
clang::MacroInfo::setIsWarnIfUnused
clang::MacroInfo::setParameterList
clang::MacroInfo::param_empty
clang::MacroInfo::param_begin
clang::MacroInfo::param_end
clang::MacroInfo::getNumParams
clang::MacroInfo::params
clang::MacroInfo::getParameterNum
clang::MacroInfo::setIsFunctionLike
clang::MacroInfo::isFunctionLike
clang::MacroInfo::isObjectLike
clang::MacroInfo::setIsC99Varargs
clang::MacroInfo::setIsGNUVarargs
clang::MacroInfo::isC99Varargs
clang::MacroInfo::isGNUVarargs
clang::MacroInfo::isVariadic
clang::MacroInfo::isBuiltinMacro
clang::MacroInfo::hasCommaPasting
clang::MacroInfo::setHasCommaPasting
clang::MacroInfo::isUsed
clang::MacroInfo::isAllowRedefinitionsWithoutWarning
clang::MacroInfo::isWarnIfUnused
clang::MacroInfo::getNumTokens
clang::MacroInfo::getReplacementToken
clang::MacroInfo::tokens_begin
clang::MacroInfo::tokens_end
clang::MacroInfo::tokens_empty
clang::MacroInfo::tokens
clang::MacroInfo::AddTokenToBody
clang::MacroInfo::isEnabled
clang::MacroInfo::EnableMacro
clang::MacroInfo::DisableMacro
clang::MacroInfo::isUsedForHeaderGuard
clang::MacroInfo::setUsedForHeaderGuard
clang::MacroInfo::dump
clang::MacroInfo::getDefinitionLengthSlow
clang::MacroDirective::Kind
clang::MacroDirective::Previous
clang::MacroDirective::Loc
clang::MacroDirective::MDKind
clang::MacroDirective::IsFromPCH
clang::MacroDirective::IsPublic
clang::MacroDirective::getKind
clang::MacroDirective::getLocation
clang::MacroDirective::setPrevious
clang::MacroDirective::getPrevious
clang::MacroDirective::getPrevious
clang::MacroDirective::isFromPCH
clang::MacroDirective::setIsFromPCH
clang::MacroDirective::DefInfo
clang::MacroDirective::DefInfo::DefDirective
clang::MacroDirective::DefInfo::UndefLoc
clang::MacroDirective::DefInfo::IsPublic
clang::MacroDirective::DefInfo::getDirective
clang::MacroDirective::DefInfo::getDirective
clang::MacroDirective::DefInfo::getLocation
clang::MacroDirective::DefInfo::getMacroInfo
clang::MacroDirective::DefInfo::getMacroInfo
clang::MacroDirective::DefInfo::getUndefLocation
clang::MacroDirective::DefInfo::isUndefined
clang::MacroDirective::DefInfo::isPublic
clang::MacroDirective::DefInfo::isValid
clang::MacroDirective::DefInfo::isInvalid
clang::MacroDirective::DefInfo::getPreviousDefinition
clang::MacroDirective::DefInfo::getPreviousDefinition
clang::MacroDirective::getDefinition
clang::MacroDirective::getDefinition
clang::MacroDirective::isDefined
clang::MacroDirective::getMacroInfo
clang::MacroDirective::getMacroInfo
clang::MacroDirective::findDirectiveAtLoc
clang::MacroDirective::dump
clang::MacroDirective::classof
clang::DefMacroDirective::Info
clang::DefMacroDirective::getInfo
clang::DefMacroDirective::getInfo
clang::DefMacroDirective::classof
clang::DefMacroDirective::classof
clang::UndefMacroDirective::classof
clang::UndefMacroDirective::classof
clang::VisibilityMacroDirective::isPublic
clang::VisibilityMacroDirective::classof
clang::VisibilityMacroDirective::classof
clang::MacroDirective::DefInfo::getLocation
clang::MacroDirective::DefInfo::getMacroInfo
clang::MacroDirective::DefInfo::getPreviousDefinition
clang::ModuleMacro::II
clang::ModuleMacro::Macro
clang::ModuleMacro::OwningModule
clang::ModuleMacro::NumOverriddenBy
clang::ModuleMacro::NumOverrides
clang::ModuleMacro::create
clang::ModuleMacro::Profile
clang::ModuleMacro::Profile
clang::ModuleMacro::getName
clang::ModuleMacro::getOwningModule
clang::ModuleMacro::getMacroInfo
clang::ModuleMacro::overrides_begin
clang::ModuleMacro::overrides_end
clang::ModuleMacro::overrides
clang::ModuleMacro::getNumOverridingMacros
clang::MacroDefinition::LatestLocalAndAmbiguous
clang::MacroDefinition::ModuleMacros
clang::MacroDefinition::getMacroInfo
clang::MacroDefinition::isAmbiguous
clang::MacroDefinition::getLocalDirective
clang::MacroDefinition::getModuleMacros
clang::MacroDefinition::forAllDefinitions
clang::ModuleMacro::Profile
clang::ModuleMacro::Profile
CodeThinker, Enjoy your reading code