1 //===--- PreprocessingRecord.cpp - Record of Preprocessing ------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the PreprocessingRecord class, which maintains a record
11 // of what occurred during preprocessing, and its helpers.
12 //
13 //===----------------------------------------------------------------------===//
14 #include "clang/Lex/PreprocessingRecord.h"
15 #include "clang/Lex/MacroInfo.h"
16 #include "clang/Lex/Token.h"
17 #include "clang/Basic/IdentifierTable.h"
18 #include "llvm/Support/ErrorHandling.h"
19
20 using namespace clang;
21
~ExternalPreprocessingRecordSource()22 ExternalPreprocessingRecordSource::~ExternalPreprocessingRecordSource() { }
23
24
InclusionDirective(PreprocessingRecord & PPRec,InclusionKind Kind,llvm::StringRef FileName,bool InQuotes,const FileEntry * File,SourceRange Range)25 InclusionDirective::InclusionDirective(PreprocessingRecord &PPRec,
26 InclusionKind Kind,
27 llvm::StringRef FileName,
28 bool InQuotes, const FileEntry *File,
29 SourceRange Range)
30 : PreprocessingDirective(InclusionDirectiveKind, Range),
31 InQuotes(InQuotes), Kind(Kind), File(File)
32 {
33 char *Memory
34 = (char*)PPRec.Allocate(FileName.size() + 1, llvm::alignOf<char>());
35 memcpy(Memory, FileName.data(), FileName.size());
36 Memory[FileName.size()] = 0;
37 this->FileName = llvm::StringRef(Memory, FileName.size());
38 }
39
MaybeLoadPreallocatedEntities() const40 void PreprocessingRecord::MaybeLoadPreallocatedEntities() const {
41 if (!ExternalSource || LoadedPreallocatedEntities)
42 return;
43
44 LoadedPreallocatedEntities = true;
45 ExternalSource->ReadPreprocessedEntities();
46 }
47
PreprocessingRecord(bool IncludeNestedMacroExpansions)48 PreprocessingRecord::PreprocessingRecord(bool IncludeNestedMacroExpansions)
49 : IncludeNestedMacroExpansions(IncludeNestedMacroExpansions),
50 ExternalSource(0), NumPreallocatedEntities(0),
51 LoadedPreallocatedEntities(false)
52 {
53 }
54
55 PreprocessingRecord::iterator
begin(bool OnlyLocalEntities)56 PreprocessingRecord::begin(bool OnlyLocalEntities) {
57 if (OnlyLocalEntities)
58 return PreprocessedEntities.begin() + NumPreallocatedEntities;
59
60 MaybeLoadPreallocatedEntities();
61 return PreprocessedEntities.begin();
62 }
63
end(bool OnlyLocalEntities)64 PreprocessingRecord::iterator PreprocessingRecord::end(bool OnlyLocalEntities) {
65 if (!OnlyLocalEntities)
66 MaybeLoadPreallocatedEntities();
67
68 return PreprocessedEntities.end();
69 }
70
71 PreprocessingRecord::const_iterator
begin(bool OnlyLocalEntities) const72 PreprocessingRecord::begin(bool OnlyLocalEntities) const {
73 if (OnlyLocalEntities)
74 return PreprocessedEntities.begin() + NumPreallocatedEntities;
75
76 MaybeLoadPreallocatedEntities();
77 return PreprocessedEntities.begin();
78 }
79
80 PreprocessingRecord::const_iterator
end(bool OnlyLocalEntities) const81 PreprocessingRecord::end(bool OnlyLocalEntities) const {
82 if (!OnlyLocalEntities)
83 MaybeLoadPreallocatedEntities();
84
85 return PreprocessedEntities.end();
86 }
87
addPreprocessedEntity(PreprocessedEntity * Entity)88 void PreprocessingRecord::addPreprocessedEntity(PreprocessedEntity *Entity) {
89 PreprocessedEntities.push_back(Entity);
90 }
91
SetExternalSource(ExternalPreprocessingRecordSource & Source,unsigned NumPreallocatedEntities)92 void PreprocessingRecord::SetExternalSource(
93 ExternalPreprocessingRecordSource &Source,
94 unsigned NumPreallocatedEntities) {
95 assert(!ExternalSource &&
96 "Preprocessing record already has an external source");
97 ExternalSource = &Source;
98 this->NumPreallocatedEntities = NumPreallocatedEntities;
99 PreprocessedEntities.insert(PreprocessedEntities.begin(),
100 NumPreallocatedEntities, 0);
101 }
102
SetPreallocatedEntity(unsigned Index,PreprocessedEntity * Entity)103 void PreprocessingRecord::SetPreallocatedEntity(unsigned Index,
104 PreprocessedEntity *Entity) {
105 assert(Index < NumPreallocatedEntities &&"Out-of-bounds preallocated entity");
106 PreprocessedEntities[Index] = Entity;
107 }
108
RegisterMacroDefinition(MacroInfo * Macro,MacroDefinition * MD)109 void PreprocessingRecord::RegisterMacroDefinition(MacroInfo *Macro,
110 MacroDefinition *MD) {
111 MacroDefinitions[Macro] = MD;
112 }
113
findMacroDefinition(const MacroInfo * MI)114 MacroDefinition *PreprocessingRecord::findMacroDefinition(const MacroInfo *MI) {
115 llvm::DenseMap<const MacroInfo *, MacroDefinition *>::iterator Pos
116 = MacroDefinitions.find(MI);
117 if (Pos == MacroDefinitions.end())
118 return 0;
119
120 return Pos->second;
121 }
122
MacroExpands(const Token & Id,const MacroInfo * MI)123 void PreprocessingRecord::MacroExpands(const Token &Id, const MacroInfo* MI) {
124 if (!IncludeNestedMacroExpansions && Id.getLocation().isMacroID())
125 return;
126
127 if (MacroDefinition *Def = findMacroDefinition(MI))
128 PreprocessedEntities.push_back(
129 new (*this) MacroExpansion(Id.getIdentifierInfo(),
130 Id.getLocation(), Def));
131 }
132
MacroDefined(const Token & Id,const MacroInfo * MI)133 void PreprocessingRecord::MacroDefined(const Token &Id,
134 const MacroInfo *MI) {
135 SourceRange R(MI->getDefinitionLoc(), MI->getDefinitionEndLoc());
136 MacroDefinition *Def
137 = new (*this) MacroDefinition(Id.getIdentifierInfo(),
138 MI->getDefinitionLoc(),
139 R);
140 MacroDefinitions[MI] = Def;
141 PreprocessedEntities.push_back(Def);
142 }
143
MacroUndefined(const Token & Id,const MacroInfo * MI)144 void PreprocessingRecord::MacroUndefined(const Token &Id,
145 const MacroInfo *MI) {
146 llvm::DenseMap<const MacroInfo *, MacroDefinition *>::iterator Pos
147 = MacroDefinitions.find(MI);
148 if (Pos != MacroDefinitions.end())
149 MacroDefinitions.erase(Pos);
150 }
151
InclusionDirective(SourceLocation HashLoc,const clang::Token & IncludeTok,llvm::StringRef FileName,bool IsAngled,const FileEntry * File,clang::SourceLocation EndLoc,llvm::StringRef SearchPath,llvm::StringRef RelativePath)152 void PreprocessingRecord::InclusionDirective(
153 SourceLocation HashLoc,
154 const clang::Token &IncludeTok,
155 llvm::StringRef FileName,
156 bool IsAngled,
157 const FileEntry *File,
158 clang::SourceLocation EndLoc,
159 llvm::StringRef SearchPath,
160 llvm::StringRef RelativePath) {
161 InclusionDirective::InclusionKind Kind = InclusionDirective::Include;
162
163 switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
164 case tok::pp_include:
165 Kind = InclusionDirective::Include;
166 break;
167
168 case tok::pp_import:
169 Kind = InclusionDirective::Import;
170 break;
171
172 case tok::pp_include_next:
173 Kind = InclusionDirective::IncludeNext;
174 break;
175
176 case tok::pp___include_macros:
177 Kind = InclusionDirective::IncludeMacros;
178 break;
179
180 default:
181 llvm_unreachable("Unknown include directive kind");
182 return;
183 }
184
185 clang::InclusionDirective *ID
186 = new (*this) clang::InclusionDirective(*this, Kind, FileName, !IsAngled,
187 File, SourceRange(HashLoc, EndLoc));
188 PreprocessedEntities.push_back(ID);
189 }
190