clang 8.0.0

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