clang 18.0.0git
PreprocessingRecord.h
Go to the documentation of this file.
1//===- PreprocessingRecord.h - Record of Preprocessing ----------*- 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// This file defines the PreprocessingRecord class, which maintains a record
10// of what occurred during preprocessing.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
15#define LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
16
18#include "clang/Basic/LLVM.h"
21#include "llvm/ADT/DenseMap.h"
22#include "llvm/ADT/PointerUnion.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/iterator.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/Support/Allocator.h"
27#include "llvm/Support/Compiler.h"
28#include <cassert>
29#include <cstddef>
30#include <iterator>
31#include <optional>
32#include <utility>
33#include <vector>
34
35namespace clang {
36
37class PreprocessingRecord;
38
39} // namespace clang
40
41/// Allocates memory within a Clang preprocessing record.
42void *operator new(size_t bytes, clang::PreprocessingRecord &PR,
43 unsigned alignment = 8) noexcept;
44
45/// Frees memory allocated in a Clang preprocessing record.
46void operator delete(void *ptr, clang::PreprocessingRecord &PR,
47 unsigned) noexcept;
48
49namespace clang {
50
51class IdentifierInfo;
52class MacroInfo;
53class SourceManager;
54class Token;
55
56 /// Base class that describes a preprocessed entity, which may be a
57 /// preprocessor directive or macro expansion.
59 public:
60 /// The kind of preprocessed entity an object describes.
62 /// Indicates a problem trying to load the preprocessed entity.
64
65 /// A macro expansion.
67
68 /// \defgroup Preprocessing directives
69 /// @{
70
71 /// A macro definition.
73
74 /// An inclusion directive, such as \c \#include, \c
75 /// \#import, or \c \#include_next.
77
78 /// @}
79
82 };
83
84 private:
85 /// The kind of preprocessed entity that this object describes.
86 EntityKind Kind;
87
88 /// The source range that covers this preprocessed entity.
89 SourceRange Range;
90
91 protected:
92 friend class PreprocessingRecord;
93
95 : Kind(Kind), Range(Range) {}
96
97 public:
98 /// Retrieve the kind of preprocessed entity stored in this object.
99 EntityKind getKind() const { return Kind; }
100
101 /// Retrieve the source range that covers this entire preprocessed
102 /// entity.
103 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
104
105 /// Returns true if there was a problem loading the preprocessed
106 /// entity.
107 bool isInvalid() const { return Kind == InvalidKind; }
108
109 // Only allow allocation of preprocessed entities using the allocator
110 // in PreprocessingRecord or by doing a placement new.
111 void *operator new(size_t bytes, PreprocessingRecord &PR,
112 unsigned alignment = 8) noexcept {
113 return ::operator new(bytes, PR, alignment);
114 }
115
116 void *operator new(size_t bytes, void *mem) noexcept { return mem; }
117
118 void operator delete(void *ptr, PreprocessingRecord &PR,
119 unsigned alignment) noexcept {
120 return ::operator delete(ptr, PR, alignment);
121 }
122
123 void operator delete(void *, std::size_t) noexcept {}
124 void operator delete(void *, void *) noexcept {}
125
126 private:
127 // Make vanilla 'new' and 'delete' illegal for preprocessed entities.
128 void *operator new(size_t bytes) noexcept;
129 void operator delete(void *data) noexcept;
130 };
131
132 /// Records the presence of a preprocessor directive.
134 public:
136 : PreprocessedEntity(Kind, Range) {}
137
138 // Implement isa/cast/dyncast/etc.
139 static bool classof(const PreprocessedEntity *PD) {
140 return PD->getKind() >= FirstPreprocessingDirective &&
142 }
143 };
144
145 /// Record the location of a macro definition.
147 /// The name of the macro being defined.
148 const IdentifierInfo *Name;
149
150 public:
152 SourceRange Range)
153 : PreprocessingDirective(MacroDefinitionKind, Range), Name(Name) {}
154
155 /// Retrieve the name of the macro being defined.
156 const IdentifierInfo *getName() const { return Name; }
157
158 /// Retrieve the location of the macro name in the definition.
160
161 // Implement isa/cast/dyncast/etc.
162 static bool classof(const PreprocessedEntity *PE) {
163 return PE->getKind() == MacroDefinitionKind;
164 }
165 };
166
167 /// Records the location of a macro expansion.
169 /// The definition of this macro or the name of the macro if it is
170 /// a builtin macro.
171 llvm::PointerUnion<IdentifierInfo *, MacroDefinitionRecord *> NameOrDef;
172
173 public:
176 NameOrDef(BuiltinName) {}
177
179 : PreprocessedEntity(MacroExpansionKind, Range), NameOrDef(Definition) {
180 }
181
182 /// True if it is a builtin macro.
183 bool isBuiltinMacro() const { return NameOrDef.is<IdentifierInfo *>(); }
184
185 /// The name of the macro being expanded.
186 const IdentifierInfo *getName() const {
188 return Def->getName();
189 return NameOrDef.get<IdentifierInfo *>();
190 }
191
192 /// The definition of the macro being expanded. May return null if
193 /// this is a builtin macro.
195 return NameOrDef.dyn_cast<MacroDefinitionRecord *>();
196 }
197
198 // Implement isa/cast/dyncast/etc.
199 static bool classof(const PreprocessedEntity *PE) {
200 return PE->getKind() == MacroExpansionKind;
201 }
202 };
203
204 /// Record the location of an inclusion directive, such as an
205 /// \c \#include or \c \#import statement.
207 public:
208 /// The kind of inclusion directives known to the
209 /// preprocessor.
211 /// An \c \#include directive.
213
214 /// An Objective-C \c \#import directive.
216
217 /// A GNU \c \#include_next directive.
219
220 /// A Clang \c \#__include_macros directive.
222 };
223
224 private:
225 /// The name of the file that was included, as written in
226 /// the source.
227 StringRef FileName;
228
229 /// Whether the file name was in quotation marks; otherwise, it was
230 /// in angle brackets.
231 LLVM_PREFERRED_TYPE(bool)
232 unsigned InQuotes : 1;
233
234 /// The kind of inclusion directive we have.
235 ///
236 /// This is a value of type InclusionKind.
237 LLVM_PREFERRED_TYPE(InclusionKind)
238 unsigned Kind : 2;
239
240 /// Whether the inclusion directive was automatically turned into
241 /// a module import.
242 LLVM_PREFERRED_TYPE(bool)
243 unsigned ImportedModule : 1;
244
245 /// The file that was included.
247
248 public:
250 StringRef FileName, bool InQuotes, bool ImportedModule,
252
253 /// Determine what kind of inclusion directive this is.
254 InclusionKind getKind() const { return static_cast<InclusionKind>(Kind); }
255
256 /// Retrieve the included file name as it was written in the source.
257 StringRef getFileName() const { return FileName; }
258
259 /// Determine whether the included file name was written in quotes;
260 /// otherwise, it was written in angle brackets.
261 bool wasInQuotes() const { return InQuotes; }
262
263 /// Determine whether the inclusion directive was automatically
264 /// turned into a module import.
265 bool importedModule() const { return ImportedModule; }
266
267 /// Retrieve the file entry for the actual file that was included
268 /// by this directive.
270
271 // Implement isa/cast/dyncast/etc.
272 static bool classof(const PreprocessedEntity *PE) {
273 return PE->getKind() == InclusionDirectiveKind;
274 }
275 };
276
277 /// An abstract class that should be subclassed by any external source
278 /// of preprocessing record entries.
280 public:
282
283 /// Read a preallocated preprocessed entity from the external source.
284 ///
285 /// \returns null if an error occurred that prevented the preprocessed
286 /// entity from being loaded.
287 virtual PreprocessedEntity *ReadPreprocessedEntity(unsigned Index) = 0;
288
289 /// Returns a pair of [Begin, End) indices of preallocated
290 /// preprocessed entities that \p Range encompasses.
291 virtual std::pair<unsigned, unsigned>
293
294 /// Optionally returns true or false if the preallocated preprocessed
295 /// entity with index \p Index came from file \p FID.
296 virtual std::optional<bool> isPreprocessedEntityInFileID(unsigned Index,
297 FileID FID) {
298 return std::nullopt;
299 }
300
301 /// Read a preallocated skipped range from the external source.
302 virtual SourceRange ReadSkippedRange(unsigned Index) = 0;
303 };
304
305 /// A record of the steps taken while preprocessing a source file,
306 /// including the various preprocessing directives processed, macros
307 /// expanded, etc.
309 SourceManager &SourceMgr;
310
311 /// Allocator used to store preprocessing objects.
312 llvm::BumpPtrAllocator BumpAlloc;
313
314 /// The set of preprocessed entities in this record, in order they
315 /// were seen.
316 std::vector<PreprocessedEntity *> PreprocessedEntities;
317
318 /// The set of preprocessed entities in this record that have been
319 /// loaded from external sources.
320 ///
321 /// The entries in this vector are loaded lazily from the external source,
322 /// and are referenced by the iterator using negative indices.
323 std::vector<PreprocessedEntity *> LoadedPreprocessedEntities;
324
325 /// The set of ranges that were skipped by the preprocessor,
326 std::vector<SourceRange> SkippedRanges;
327
328 bool SkippedRangesAllLoaded = true;
329
330 /// Global (loaded or local) ID for a preprocessed entity.
331 /// Negative values are used to indicate preprocessed entities
332 /// loaded from the external source while non-negative values are used to
333 /// indicate preprocessed entities introduced by the current preprocessor.
334 /// Value -1 corresponds to element 0 in the loaded entities vector,
335 /// value -2 corresponds to element 1 in the loaded entities vector, etc.
336 /// Value 0 is an invalid value, the index to local entities is 1-based,
337 /// value 1 corresponds to element 0 in the local entities vector,
338 /// value 2 corresponds to element 1 in the local entities vector, etc.
339 class PPEntityID {
340 friend class PreprocessingRecord;
341
342 int ID = 0;
343
344 explicit PPEntityID(int ID) : ID(ID) {}
345
346 public:
347 PPEntityID() = default;
348 };
349
350 static PPEntityID getPPEntityID(unsigned Index, bool isLoaded) {
351 return isLoaded ? PPEntityID(-int(Index)-1) : PPEntityID(Index+1);
352 }
353
354 /// Mapping from MacroInfo structures to their definitions.
355 llvm::DenseMap<const MacroInfo *, MacroDefinitionRecord *> MacroDefinitions;
356
357 /// External source of preprocessed entities.
359
360 /// Retrieve the preprocessed entity at the given ID.
361 PreprocessedEntity *getPreprocessedEntity(PPEntityID PPID);
362
363 /// Retrieve the loaded preprocessed entity at the given index.
364 PreprocessedEntity *getLoadedPreprocessedEntity(unsigned Index);
365
366 /// Determine the number of preprocessed entities that were
367 /// loaded (or can be loaded) from an external source.
368 unsigned getNumLoadedPreprocessedEntities() const {
369 return LoadedPreprocessedEntities.size();
370 }
371
372 /// Returns a pair of [Begin, End) indices of local preprocessed
373 /// entities that \p Range encompasses.
374 std::pair<unsigned, unsigned>
375 findLocalPreprocessedEntitiesInRange(SourceRange Range) const;
376 unsigned findBeginLocalPreprocessedEntity(SourceLocation Loc) const;
377 unsigned findEndLocalPreprocessedEntity(SourceLocation Loc) const;
378
379 /// Allocate space for a new set of loaded preprocessed entities.
380 ///
381 /// \returns The index into the set of loaded preprocessed entities, which
382 /// corresponds to the first newly-allocated entity.
383 unsigned allocateLoadedEntities(unsigned NumEntities);
384
385 /// Allocate space for a new set of loaded preprocessed skipped
386 /// ranges.
387 ///
388 /// \returns The index into the set of loaded preprocessed ranges, which
389 /// corresponds to the first newly-allocated range.
390 unsigned allocateSkippedRanges(unsigned NumRanges);
391
392 /// Ensures that all external skipped ranges have been loaded.
393 void ensureSkippedRangesLoaded();
394
395 /// Register a new macro definition.
396 void RegisterMacroDefinition(MacroInfo *Macro, MacroDefinitionRecord *Def);
397
398 public:
399 /// Construct a new preprocessing record.
401
402 /// Allocate memory in the preprocessing record.
403 void *Allocate(unsigned Size, unsigned Align = 8) {
404 return BumpAlloc.Allocate(Size, Align);
405 }
406
407 /// Deallocate memory in the preprocessing record.
408 void Deallocate(void *Ptr) {}
409
410 size_t getTotalMemory() const;
411
412 SourceManager &getSourceManager() const { return SourceMgr; }
413
414 /// Iteration over the preprocessed entities.
415 ///
416 /// In a complete iteration, the iterator walks the range [-M, N),
417 /// where negative values are used to indicate preprocessed entities
418 /// loaded from the external source while non-negative values are used to
419 /// indicate preprocessed entities introduced by the current preprocessor.
420 /// However, to provide iteration in source order (for, e.g., chained
421 /// precompiled headers), dereferencing the iterator flips the negative
422 /// values (corresponding to loaded entities), so that position -M
423 /// corresponds to element 0 in the loaded entities vector, position -M+1
424 /// corresponds to element 1 in the loaded entities vector, etc. This
425 /// gives us a reasonably efficient, source-order walk.
426 ///
427 /// We define this as a wrapping iterator around an int. The
428 /// iterator_adaptor_base class forwards the iterator methods to basic
429 /// integer arithmetic.
430 class iterator : public llvm::iterator_adaptor_base<
431 iterator, int, std::random_access_iterator_tag,
432 PreprocessedEntity *, int, PreprocessedEntity *,
433 PreprocessedEntity *> {
435
437
438 iterator(PreprocessingRecord *Self, int Position)
439 : iterator::iterator_adaptor_base(Position), Self(Self) {}
440
441 public:
442 iterator() : iterator(nullptr, 0) {}
443
445 bool isLoaded = this->I < 0;
446 unsigned Index = isLoaded ?
447 Self->LoadedPreprocessedEntities.size() + this->I : this->I;
448 PPEntityID ID = Self->getPPEntityID(Index, isLoaded);
449 return Self->getPreprocessedEntity(ID);
450 }
451 PreprocessedEntity *operator->() const { return **this; }
452 };
453
454 /// Begin iterator for all preprocessed entities.
456 return iterator(this, -(int)LoadedPreprocessedEntities.size());
457 }
458
459 /// End iterator for all preprocessed entities.
461 return iterator(this, PreprocessedEntities.size());
462 }
463
464 /// Begin iterator for local, non-loaded, preprocessed entities.
466 return iterator(this, 0);
467 }
468
469 /// End iterator for local, non-loaded, preprocessed entities.
471 return iterator(this, PreprocessedEntities.size());
472 }
473
474 /// iterator range for the given range of loaded
475 /// preprocessed entities.
476 llvm::iterator_range<iterator> getIteratorsForLoadedRange(unsigned start,
477 unsigned count) {
478 unsigned end = start + count;
479 assert(end <= LoadedPreprocessedEntities.size());
480 return llvm::make_range(
481 iterator(this, int(start) - LoadedPreprocessedEntities.size()),
482 iterator(this, int(end) - LoadedPreprocessedEntities.size()));
483 }
484
485 /// Returns a range of preprocessed entities that source range \p R
486 /// encompasses.
487 ///
488 /// \param R the range to look for preprocessed entities.
489 llvm::iterator_range<iterator>
491
492 /// Returns true if the preprocessed entity that \p PPEI iterator
493 /// points to is coming from the file \p FID.
494 ///
495 /// Can be used to avoid implicit deserializations of preallocated
496 /// preprocessed entities if we only care about entities of a specific file
497 /// and not from files \#included in the range given at
498 /// \see getPreprocessedEntitiesInRange.
499 bool isEntityInFileID(iterator PPEI, FileID FID);
500
501 /// Add a new preprocessed entity to this record.
502 PPEntityID addPreprocessedEntity(PreprocessedEntity *Entity);
503
504 /// Set the external source for preprocessed entities.
506
507 /// Retrieve the external source for preprocessed entities.
509 return ExternalSource;
510 }
511
512 /// Retrieve the macro definition that corresponds to the given
513 /// \c MacroInfo.
515
516 /// Retrieve all ranges that got skipped while preprocessing.
517 const std::vector<SourceRange> &getSkippedRanges() {
518 ensureSkippedRangesLoaded();
519 return SkippedRanges;
520 }
521
522 private:
523 friend class ASTReader;
524 friend class ASTWriter;
525
526 void MacroExpands(const Token &Id, const MacroDefinition &MD,
527 SourceRange Range, const MacroArgs *Args) override;
528 void MacroDefined(const Token &Id, const MacroDirective *MD) override;
529 void MacroUndefined(const Token &Id, const MacroDefinition &MD,
530 const MacroDirective *Undef) override;
531 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
532 StringRef FileName, bool IsAngled,
533 CharSourceRange FilenameRange,
534 OptionalFileEntryRef File, StringRef SearchPath,
535 StringRef RelativePath, const Module *Imported,
536 SrcMgr::CharacteristicKind FileType) override;
537 void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
538 const MacroDefinition &MD) override;
539 void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
540 const MacroDefinition &MD) override;
541
544 void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
545 const MacroDefinition &MD) override;
546 void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
547 const MacroDefinition &MD) override;
548
549 /// Hook called whenever the 'defined' operator is seen.
550 void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
551 SourceRange Range) override;
552
553 void SourceRangeSkipped(SourceRange Range,
554 SourceLocation EndifLoc) override;
555
556 void addMacroExpansion(const Token &Id, const MacroInfo *MI,
558
559 /// Cached result of the last \see getPreprocessedEntitiesInRange
560 /// query.
561 struct {
563 std::pair<int, int> Result;
564 } CachedRangeQuery;
565
566 std::pair<int, int> getPreprocessedEntitiesInRangeSlow(SourceRange R);
567 };
568
569} // namespace clang
570
571inline void *operator new(size_t bytes, clang::PreprocessingRecord &PR,
572 unsigned alignment) noexcept {
573 return PR.Allocate(bytes, alignment);
574}
575
576inline void operator delete(void *ptr, clang::PreprocessingRecord &PR,
577 unsigned) noexcept {
578 PR.Deallocate(ptr);
579}
580
581#endif // LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
int Id
Definition: ASTDiff.cpp:190
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:123
static char ID
Definition: Arena.cpp:183
#define SM(sm)
Definition: Cuda.cpp:80
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the PPCallbacks interface.
Defines the clang::SourceLocation class and associated facilities.
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:366
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:86
Represents a character-granular source range.
An abstract class that should be subclassed by any external source of preprocessing record entries.
virtual SourceRange ReadSkippedRange(unsigned Index)=0
Read a preallocated skipped range from the external source.
virtual std::optional< bool > isPreprocessedEntityInFileID(unsigned Index, FileID FID)
Optionally returns true or false if the preallocated preprocessed entity with index Index came from f...
virtual PreprocessedEntity * ReadPreprocessedEntity(unsigned Index)=0
Read a preallocated preprocessed entity from the external source.
virtual std::pair< unsigned, unsigned > findPreprocessedEntitiesInRange(SourceRange Range)=0
Returns a pair of [Begin, End) indices of preallocated preprocessed entities that Range encompasses.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
Record the location of an inclusion directive, such as an #include or #import statement.
StringRef getFileName() const
Retrieve the included file name as it was written in the source.
InclusionKind getKind() const
Determine what kind of inclusion directive this is.
bool wasInQuotes() const
Determine whether the included file name was written in quotes; otherwise, it was written in angle br...
bool importedModule() const
Determine whether the inclusion directive was automatically turned into a module import.
InclusionKind
The kind of inclusion directives known to the preprocessor.
@ IncludeMacros
A Clang #__include_macros directive.
@ Import
An Objective-C #import directive.
@ IncludeNext
A GNU #include_next directive.
@ Include
An #include directive.
static bool classof(const PreprocessedEntity *PE)
OptionalFileEntryRef getFile() const
Retrieve the file entry for the actual file that was included by this directive.
MacroArgs - An instance of this class captures information about the formal arguments specified to a ...
Definition: MacroArgs.h:30
Record the location of a macro definition.
static bool classof(const PreprocessedEntity *PE)
SourceLocation getLocation() const
Retrieve the location of the macro name in the definition.
MacroDefinitionRecord(const IdentifierInfo *Name, SourceRange Range)
const IdentifierInfo * getName() const
Retrieve the name of the macro being defined.
A description of the current definition of a macro.
Definition: MacroInfo.h:590
Encapsulates changes to the "macros namespace" (the location where the macro name became active,...
Definition: MacroInfo.h:313
Records the location of a macro expansion.
MacroDefinitionRecord * getDefinition() const
The definition of the macro being expanded.
bool isBuiltinMacro() const
True if it is a builtin macro.
const IdentifierInfo * getName() const
The name of the macro being expanded.
static bool classof(const PreprocessedEntity *PE)
MacroExpansion(MacroDefinitionRecord *Definition, SourceRange Range)
MacroExpansion(IdentifierInfo *BuiltinName, SourceRange Range)
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
Describes a module or submodule.
Definition: Module.h:105
This interface provides a way to observe the actions of the preprocessor as it does its thing.
Definition: PPCallbacks.h:35
virtual void Elifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)
Hook called whenever an #elifndef branch is taken.
Definition: PPCallbacks.h:408
virtual void Elifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)
Hook called whenever an #elifdef branch is taken.
Definition: PPCallbacks.h:384
Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expan...
EntityKind
The kind of preprocessed entity an object describes.
@ InvalidKind
Indicates a problem trying to load the preprocessed entity.
@ MacroExpansionKind
A macro expansion.
bool isInvalid() const
Returns true if there was a problem loading the preprocessed entity.
PreprocessedEntity(EntityKind Kind, SourceRange Range)
EntityKind getKind() const
Retrieve the kind of preprocessed entity stored in this object.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range that covers this entire preprocessed entity.
Records the presence of a preprocessor directive.
PreprocessingDirective(EntityKind Kind, SourceRange Range)
static bool classof(const PreprocessedEntity *PD)
Iteration over the preprocessed entities.
PreprocessedEntity * operator->() const
PreprocessedEntity * operator*() const
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
SourceManager & getSourceManager() const
void Deallocate(void *Ptr)
Deallocate memory in the preprocessing record.
void * Allocate(unsigned Size, unsigned Align=8)
Allocate memory in the preprocessing record.
llvm::iterator_range< iterator > getPreprocessedEntitiesInRange(SourceRange R)
Returns a range of preprocessed entities that source range R encompasses.
iterator end()
End iterator for all preprocessed entities.
ExternalPreprocessingRecordSource * getExternalSource() const
Retrieve the external source for preprocessed entities.
MacroDefinitionRecord * findMacroDefinition(const MacroInfo *MI)
Retrieve the macro definition that corresponds to the given MacroInfo.
PPEntityID addPreprocessedEntity(PreprocessedEntity *Entity)
Add a new preprocessed entity to this record.
llvm::iterator_range< iterator > getIteratorsForLoadedRange(unsigned start, unsigned count)
iterator range for the given range of loaded preprocessed entities.
const std::vector< SourceRange > & getSkippedRanges()
Retrieve all ranges that got skipped while preprocessing.
bool isEntityInFileID(iterator PPEI, FileID FID)
Returns true if the preprocessed entity that PPEI iterator points to is coming from the file FID.
iterator begin()
Begin iterator for all preprocessed entities.
iterator local_begin()
Begin iterator for local, non-loaded, preprocessed entities.
std::pair< int, int > Result
iterator local_end()
End iterator for local, non-loaded, preprocessed entities.
void SetExternalSource(ExternalPreprocessingRecordSource &Source)
Set the external source for preprocessed entities.
Encodes a location in the source.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
@ MacroDefinitionKind
A macro definition.
@ InclusionDirectiveKind
An inclusion directive, such as #include, #import, or #include_next.
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:81