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 | |
28 | namespace clang { |
29 | |
30 | class DefMacroDirective; |
31 | class IdentifierInfo; |
32 | class Module; |
33 | class Preprocessor; |
34 | class 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. |
39 | class 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 : 1; |
116 | |
117 | // Only the Preprocessor gets to create and destroy these. |
118 | MacroInfo(SourceLocation DefLoc); |
119 | ~MacroInfo() = default; |
120 | |
121 | public: |
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 | assert(ParameterList == nullptr && NumParameters == 0 && |
167 | "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 | 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 | assert( |
250 | !IsDefinitionLengthCached && |
251 | "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 | assert(IsDisabled && "Cannot enable an already-enabled macro!" ); |
262 | IsDisabled = false; |
263 | } |
264 | |
265 | void DisableMacro() { |
266 | 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 () const { return UsedForHeaderGuard; } |
272 | |
273 | void (bool Val) { UsedForHeaderGuard = Val; } |
274 | |
275 | void dump() const; |
276 | |
277 | private: |
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. |
290 | class MacroDirective { |
291 | public: |
292 | enum Kind { |
293 | MD_Define, |
294 | MD_Undefine, |
295 | MD_Visibility |
296 | }; |
297 | |
298 | protected: |
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 | |
319 | public: |
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. |
406 | class DefMacroDirective : public MacroDirective { |
407 | MacroInfo *Info; |
408 | |
409 | public: |
410 | DefMacroDirective(MacroInfo *MI, SourceLocation Loc) |
411 | : MacroDirective(MD_Define, Loc), Info(MI) { |
412 | 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. |
429 | class UndefMacroDirective : public MacroDirective { |
430 | public: |
431 | explicit UndefMacroDirective(SourceLocation UndefLoc) |
432 | : MacroDirective(MD_Undefine, UndefLoc) { |
433 | 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. |
444 | class VisibilityMacroDirective : public MacroDirective { |
445 | public: |
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 | |
462 | inline SourceLocation MacroDirective::DefInfo::getLocation() const { |
463 | if (isInvalid()) |
464 | return {}; |
465 | return DefDirective->getLocation(); |
466 | } |
467 | |
468 | inline MacroInfo *MacroDirective::DefInfo::getMacroInfo() { |
469 | if (isInvalid()) |
470 | return nullptr; |
471 | return DefDirective->getInfo(); |
472 | } |
473 | |
474 | inline MacroDirective::DefInfo |
475 | MacroDirective::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. |
488 | class 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 | |
514 | public: |
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 | const 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. |
564 | class MacroDefinition { |
565 | llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous; |
566 | ArrayRef<ModuleMacro *> ModuleMacros; |
567 | |
568 | public: |
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 | |