 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
74.3% |
168 / 226 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
84.1% |
190 / 226 |
| |
|
Line Coverage: |
93.3% |
238 / 255 |
| |
 |
|
 |
1 : //===--- Preprocess.cpp - C Language Family Preprocessor Implementation ---===//
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 Preprocessor interface.
11 : //
12 : //===----------------------------------------------------------------------===//
13 : //
14 : // Options to support:
15 : // -H - Print the name of each header file used.
16 : // -d[DNI] - Dump various things.
17 : // -fworking-directory - #line's with preprocessor's working dir.
18 : // -fpreprocessed
19 : // -dependency-file,-M,-MM,-MF,-MG,-MP,-MT,-MQ,-MD,-MMD
20 : // -W*
21 : // -w
22 : //
23 : // Messages to emit:
24 : // "Multiple include guards may be useful for:\n"
25 : //
26 : //===----------------------------------------------------------------------===//
27 :
28 : #include "clang/Lex/Preprocessor.h"
29 : #include "MacroArgs.h"
30 : #include "clang/Lex/ExternalPreprocessorSource.h"
31 : #include "clang/Lex/HeaderSearch.h"
32 : #include "clang/Lex/MacroInfo.h"
33 : #include "clang/Lex/Pragma.h"
34 : #include "clang/Lex/ScratchBuffer.h"
35 : #include "clang/Lex/LexDiagnostic.h"
36 : #include "clang/Basic/SourceManager.h"
37 : #include "clang/Basic/FileManager.h"
38 : #include "clang/Basic/TargetInfo.h"
39 : #include "llvm/ADT/APFloat.h"
40 : #include "llvm/ADT/SmallVector.h"
41 : #include "llvm/Support/MemoryBuffer.h"
42 : #include "llvm/Support/raw_ostream.h"
43 : #include <cstdio>
44 : using namespace clang;
45 :
46 : //===----------------------------------------------------------------------===//
44: branch 0 taken
44: branch 1 taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 6 not taken
44: branch 7 taken
47 44: ExternalPreprocessorSource::~ExternalPreprocessorSource() { }
48 :
49 : Preprocessor::Preprocessor(Diagnostic &diags, const LangOptions &opts,
50 : const TargetInfo &target, SourceManager &SM,
51 : HeaderSearch &Headers,
52 : IdentifierInfoLookup* IILookup,
53 2533: bool OwnsHeaders)
54 : : Diags(&diags), Features(opts), Target(target),FileMgr(Headers.getFileMgr()),
55 : SourceMgr(SM), HeaderInfo(Headers), ExternalSource(0),
56 : Identifiers(opts, IILookup), BuiltinInfo(Target), CodeCompletionFile(0),
57 2533: CurPPLexer(0), CurDirLookup(0), Callbacks(0), MacroArgCache(0) {
58 2533: ScratchBuf = new ScratchBuffer(SourceMgr);
59 2533: CounterValue = 0; // __COUNTER__ starts at 0.
60 2533: OwnsHeaderSearch = OwnsHeaders;
61 :
62 : // Clear stats.
63 2533: NumDirectives = NumDefined = NumUndefined = NumPragma = 0;
64 2533: NumIf = NumElse = NumEndif = 0;
65 2533: NumEnteredSourceFiles = 0;
66 2533: NumMacroExpanded = NumFnMacroExpanded = NumBuiltinMacroExpanded = 0;
67 2533: NumFastMacroExpanded = NumTokenPaste = NumFastTokenPaste = 0;
68 2533: MaxIncludeStackDepth = 0;
69 2533: NumSkipped = 0;
70 :
71 : // Default to discarding comments.
72 2533: KeepComments = false;
73 2533: KeepMacroComments = false;
74 :
75 : // Macro expansion is enabled.
76 2533: DisableMacroExpansion = false;
77 2533: InMacroArgs = false;
78 2533: NumCachedTokenLexers = 0;
79 :
80 2533: CachedLexPos = 0;
81 :
82 : // We haven't read anything from the external source.
83 2533: ReadMacrosFromExternalSource = false;
84 :
85 : // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
86 : // This gets unpoisoned where it is allowed.
87 2533: (Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned();
88 :
89 : // Initialize the pragma handlers.
90 2533: PragmaHandlers = new PragmaNamespace(0);
91 2533: RegisterBuiltinPragmas();
92 :
93 : // Initialize builtin macros like __LINE__ and friends.
94 2533: RegisterBuiltinMacros();
95 2533: }
96 :
97 2530: Preprocessor::~Preprocessor() {
2530: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
98 2530: assert(BacktrackPositions.empty() && "EnableBacktrack/Backtrack imbalance!");
99 :
8: branch 1 taken
2530: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
100 5068: while (!IncludeMacroStack.empty()) {
4: branch 1 taken
4: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
101 8: delete IncludeMacroStack.back().TheLexer;
0: branch 1 not taken
8: branch 2 taken
0: branch 6 not taken
0: branch 7 not taken
102 8: delete IncludeMacroStack.back().TheTokenLexer;
103 8: IncludeMacroStack.pop_back();
104 : }
105 :
106 : // Free any macro definitions.
302412: branch 3 taken
2530: branch 4 taken
0: branch 8 not taken
0: branch 9 not taken
107 304942: for (llvm::DenseMap<IdentifierInfo*, MacroInfo*>::iterator I =
108 2530: Macros.begin(), E = Macros.end(); I != E; ++I) {
109 : // We don't need to free the MacroInfo objects directly. These
110 : // will be released when the BumpPtrAllocator 'BP' object gets
111 : // destroyed. We still need to run the dtor, however, to free
112 : // memory alocated by MacroInfo.
113 302412: I->second->Destroy(BP);
114 302412: I->first->setHasMacroDefinition(false);
115 : }
116 :
117 : // Free any cached macro expanders.
931: branch 0 taken
2530: branch 1 taken
2530: branch 2 taken
2530: branch 3 taken
118 3461: for (unsigned i = 0, e = NumCachedTokenLexers; i != e; ++i)
931: branch 0 taken
0: branch 1 not taken
931: branch 4 taken
931: branch 5 taken
119 931: delete TokenLexerCache[i];
120 :
121 : // Free any cached MacroArgs.
630: branch 0 taken
2530: branch 1 taken
2530: branch 2 taken
2530: branch 3 taken
122 5690: for (MacroArgs *ArgList = MacroArgCache; ArgList; )
123 630: ArgList = ArgList->deallocate();
124 :
125 : // Release pragma information.
2530: branch 0 taken
0: branch 1 not taken
2530: branch 3 taken
2530: branch 4 taken
126 2530: delete PragmaHandlers;
127 :
128 : // Delete the scratch buffer info.
129 2530: delete ScratchBuf;
130 :
131 : // Delete the header search info, if we own it.
2520: branch 0 taken
10: branch 1 taken
10: branch 2 taken
10: branch 3 taken
132 2530: if (OwnsHeaderSearch)
2520: branch 0 taken
0: branch 1 not taken
2520: branch 4 taken
2520: branch 5 taken
133 2520: delete &HeaderInfo;
134 :
202: branch 0 taken
2328: branch 1 taken
202: branch 3 taken
202: branch 4 taken
135 2530: delete Callbacks;
136 2530: }
137 :
138 1: void Preprocessor::setPTHManager(PTHManager* pm) {
139 1: PTH.reset(pm);
140 1: FileMgr.addStatCache(PTH->createStatCache());
141 1: }
142 :
143 37: void Preprocessor::DumpToken(const Token &Tok, bool DumpFlags) const {
144 : llvm::errs() << tok::getTokenName(Tok.getKind()) << " '"
145 37: << getSpelling(Tok) << "'";
146 :
37: branch 0 taken
0: branch 1 not taken
147 37: if (!DumpFlags) return;
148 :
149 37: llvm::errs() << "\t";
9: branch 1 taken
28: branch 2 taken
150 37: if (Tok.isAtStartOfLine())
151 9: llvm::errs() << " [StartOfLine]";
15: branch 1 taken
22: branch 2 taken
152 37: if (Tok.hasLeadingSpace())
153 15: llvm::errs() << " [LeadingSpace]";
0: branch 1 not taken
37: branch 2 taken
154 37: if (Tok.isExpandDisabled())
155 0: llvm::errs() << " [ExpandDisabled]";
0: branch 1 not taken
37: branch 2 taken
156 37: if (Tok.needsCleaning()) {
157 0: const char *Start = SourceMgr.getCharacterData(Tok.getLocation());
158 : llvm::errs() << " [UnClean='" << std::string(Start, Start+Tok.getLength())
159 0: << "']";
160 : }
161 :
162 37: llvm::errs() << "\tLoc=<";
163 37: DumpLocation(Tok.getLocation());
164 37: llvm::errs() << ">";
165 : }
166 :
167 37: void Preprocessor::DumpLocation(SourceLocation Loc) const {
168 37: Loc.dump(SourceMgr);
169 37: }
170 :
171 0: void Preprocessor::DumpMacro(const MacroInfo &MI) const {
172 0: llvm::errs() << "MACRO: ";
0: branch 1 not taken
0: branch 2 not taken
173 0: for (unsigned i = 0, e = MI.getNumTokens(); i != e; ++i) {
174 0: DumpToken(MI.getReplacementToken(i));
175 0: llvm::errs() << " ";
176 : }
177 0: llvm::errs() << "\n";
178 0: }
179 :
180 2: void Preprocessor::PrintStats() {
181 2: llvm::errs() << "\n*** Preprocessor Stats:\n";
182 2: llvm::errs() << NumDirectives << " directives found:\n";
183 2: llvm::errs() << " " << NumDefined << " #define.\n";
184 2: llvm::errs() << " " << NumUndefined << " #undef.\n";
185 2: llvm::errs() << " #include/#include_next/#import:\n";
186 2: llvm::errs() << " " << NumEnteredSourceFiles << " source files entered.\n";
187 2: llvm::errs() << " " << MaxIncludeStackDepth << " max include stack depth\n";
188 2: llvm::errs() << " " << NumIf << " #if/#ifndef/#ifdef.\n";
189 2: llvm::errs() << " " << NumElse << " #else/#elif.\n";
190 2: llvm::errs() << " " << NumEndif << " #endif.\n";
191 2: llvm::errs() << " " << NumPragma << " #pragma.\n";
192 2: llvm::errs() << NumSkipped << " #if/#ifndef#ifdef regions skipped\n";
193 :
194 : llvm::errs() << NumMacroExpanded << "/" << NumFnMacroExpanded << "/"
195 : << NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, "
196 2: << NumFastMacroExpanded << " on the fast path.\n";
197 : llvm::errs() << (NumFastTokenPaste+NumTokenPaste)
198 : << " token paste (##) operations performed, "
199 2: << NumFastTokenPaste << " on the fast path.\n";
200 2: }
201 :
202 : Preprocessor::macro_iterator
203 104: Preprocessor::macro_begin(bool IncludeExternalMacros) const {
104: branch 0 taken
0: branch 1 not taken
3: branch 2 taken
101: branch 3 taken
3: branch 4 taken
0: branch 5 not taken
204 104: if (IncludeExternalMacros && ExternalSource &&
205 : !ReadMacrosFromExternalSource) {
206 3: ReadMacrosFromExternalSource = true;
207 3: ExternalSource->ReadDefinedMacros();
208 : }
209 :
210 104: return Macros.begin();
211 : }
212 :
213 : Preprocessor::macro_iterator
214 104: Preprocessor::macro_end(bool IncludeExternalMacros) const {
104: branch 0 taken
0: branch 1 not taken
3: branch 2 taken
101: branch 3 taken
0: branch 4 not taken
3: branch 5 taken
215 104: if (IncludeExternalMacros && ExternalSource &&
216 : !ReadMacrosFromExternalSource) {
217 0: ReadMacrosFromExternalSource = true;
218 0: ExternalSource->ReadDefinedMacros();
219 : }
220 :
221 104: return Macros.end();
222 : }
223 :
224 : bool Preprocessor::SetCodeCompletionPoint(const FileEntry *File,
225 : unsigned TruncateAtLine,
226 174: unsigned TruncateAtColumn) {
227 : using llvm::MemoryBuffer;
228 :
229 174: CodeCompletionFile = File;
230 :
231 : // Okay to clear out the code-completion point by passing NULL.
87: branch 0 taken
87: branch 1 taken
232 174: if (!CodeCompletionFile)
233 87: return false;
234 :
235 : // Load the actual file's contents.
236 87: const MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File);
0: branch 0 not taken
87: branch 1 taken
237 87: if (!Buffer)
238 0: return true;
239 :
240 : // Find the byte position of the truncation point.
241 87: const char *Position = Buffer->getBufferStart();
1652: branch 0 taken
87: branch 1 taken
242 1739: for (unsigned Line = 1; Line < TruncateAtLine; ++Line) {
30650: branch 0 taken
0: branch 1 not taken
243 30650: for (; *Position; ++Position) {
30650: branch 0 taken
0: branch 1 not taken
1652: branch 2 taken
28998: branch 3 taken
244 30650: if (*Position != '\r' && *Position != '\n')
245 28998: continue;
246 :
247 : // Eat \r\n or \n\r as a single line.
1652: branch 0 taken
0: branch 1 not taken
290: branch 2 taken
1362: branch 3 taken
0: branch 4 not taken
290: branch 5 taken
248 1652: if ((Position[1] == '\r' || Position[1] == '\n') &&
249 : Position[0] != Position[1])
250 0: ++Position;
251 1652: ++Position;
252 1652: break;
253 : }
254 : }
255 :
256 87: Position += TruncateAtColumn - 1;
257 :
258 : // Truncate the buffer.
87: branch 1 taken
0: branch 2 not taken
259 87: if (Position < Buffer->getBufferEnd()) {
260 : MemoryBuffer *TruncatedBuffer
261 : = MemoryBuffer::getMemBufferCopy(Buffer->getBufferStart(), Position,
262 87: Buffer->getBufferIdentifier());
263 87: SourceMgr.overrideFileContents(File, TruncatedBuffer);
264 : }
265 :
266 87: return false;
267 : }
268 :
269 5701: bool Preprocessor::isCodeCompletionFile(SourceLocation FileLoc) const {
270 : return CodeCompletionFile && FileLoc.isFileID() &&
271 : SourceMgr.getFileEntryForID(SourceMgr.getFileID(FileLoc))
177: branch 0 taken
5524: branch 1 taken
177: branch 3 taken
0: branch 4 not taken
87: branch 7 taken
90: branch 8 taken
272 5701: == CodeCompletionFile;
273 : }
274 :
275 : //===----------------------------------------------------------------------===//
276 : // Token Spelling
277 : //===----------------------------------------------------------------------===//
278 :
279 : /// getSpelling() - Return the 'spelling' of this token. The spelling of a
280 : /// token are the characters used to represent the token in the source file
281 : /// after trigraph expansion and escaped-newline folding. In particular, this
282 : /// wants to get the true, uncanonicalized, spelling of things like digraphs
283 : /// UCNs, etc.
284 : std::string Preprocessor::getSpelling(const Token &Tok,
285 : const SourceManager &SourceMgr,
286 15720: const LangOptions &Features) {
15720: branch 1 taken
0: branch 2 not taken
287 15720: assert((int)Tok.getLength() >= 0 && "Token character range is bogus!");
288 :
289 : // If this token contains nothing interesting, return it directly.
290 15720: const char* TokStart = SourceMgr.getCharacterData(Tok.getLocation());
15514: branch 1 taken
206: branch 2 taken
291 15720: if (!Tok.needsCleaning())
292 15514: return std::string(TokStart, TokStart+Tok.getLength());
293 :
294 206: std::string Result;
295 206: Result.reserve(Tok.getLength());
296 :
297 : // Otherwise, hard case, relex the characters into the string.
35204: branch 1 taken
206: branch 2 taken
298 35616: for (const char *Ptr = TokStart, *End = TokStart+Tok.getLength();
299 : Ptr != End; ) {
300 : unsigned CharSize;
301 35204: Result.push_back(Lexer::getCharAndSizeNoWarn(Ptr, CharSize, Features));
302 35204: Ptr += CharSize;
303 : }
304 : assert(Result.size() != unsigned(Tok.getLength()) &&
206: branch 2 taken
0: branch 3 not taken
305 206: "NeedsCleaning flag set on something that didn't need cleaning!");
306 206: return Result;
307 : }
308 :
309 : /// getSpelling() - Return the 'spelling' of this token. The spelling of a
310 : /// token are the characters used to represent the token in the source file
311 : /// after trigraph expansion and escaped-newline folding. In particular, this
312 : /// wants to get the true, uncanonicalized, spelling of things like digraphs
313 : /// UCNs, etc.
314 15720: std::string Preprocessor::getSpelling(const Token &Tok) const {
315 15720: return getSpelling(Tok, SourceMgr, Features);
316 : }
317 :
318 : /// getSpelling - This method is used to get the spelling of a token into a
319 : /// preallocated buffer, instead of as an std::string. The caller is required
320 : /// to allocate enough space for the token, which is guaranteed to be at least
321 : /// Tok.getLength() bytes long. The actual length of the token is returned.
322 : ///
323 : /// Note that this method may do two possible things: it may either fill in
324 : /// the buffer specified with characters, or it may *change the input pointer*
325 : /// to point to a constant buffer with the data already in it (avoiding a
326 : /// copy). The caller is not allowed to modify the returned buffer pointer
327 : /// if an internal buffer is returned.
328 : unsigned Preprocessor::getSpelling(const Token &Tok,
329 51015: const char *&Buffer) const {
51015: branch 1 taken
0: branch 2 not taken
330 51015: assert((int)Tok.getLength() >= 0 && "Token character range is bogus!");
331 :
332 : // If this token is an identifier, just return the string from the identifier
333 : // table, which is very quick.
2982: branch 1 taken
48033: branch 2 taken
334 51015: if (const IdentifierInfo *II = Tok.getIdentifierInfo()) {
335 2982: Buffer = II->getNameStart();
336 2982: return II->getLength();
337 : }
338 :
339 : // Otherwise, compute the start of the token in the input lexer buffer.
340 48033: const char *TokStart = 0;
341 :
41316: branch 1 taken
6717: branch 2 taken
342 48033: if (Tok.isLiteral())
343 41316: TokStart = Tok.getLiteralData();
344 :
6723: branch 0 taken
41310: branch 1 taken
345 48033: if (TokStart == 0)
346 6723: TokStart = SourceMgr.getCharacterData(Tok.getLocation());
347 :
348 : // If this token contains nothing interesting, return it directly.
48012: branch 1 taken
21: branch 2 taken
349 48033: if (!Tok.needsCleaning()) {
350 48012: Buffer = TokStart;
351 48012: return Tok.getLength();
352 : }
353 :
354 : // Otherwise, hard case, relex the characters into the string.
355 21: char *OutBuf = const_cast<char*>(Buffer);
119: branch 1 taken
21: branch 2 taken
356 161: for (const char *Ptr = TokStart, *End = TokStart+Tok.getLength();
357 : Ptr != End; ) {
358 : unsigned CharSize;
359 119: *OutBuf++ = Lexer::getCharAndSizeNoWarn(Ptr, CharSize, Features);
360 119: Ptr += CharSize;
361 : }
362 : assert(unsigned(OutBuf-Buffer) != Tok.getLength() &&
21: branch 1 taken
0: branch 2 not taken
363 21: "NeedsCleaning flag set on something that didn't need cleaning!");
364 :
365 21: return OutBuf-Buffer;
366 : }
367 :
368 : /// CreateString - Plop the specified string into a scratch buffer and return a
369 : /// location for it. If specified, the source location provides a source
370 : /// location for the token.
371 : void Preprocessor::CreateString(const char *Buf, unsigned Len, Token &Tok,
372 2124: SourceLocation InstantiationLoc) {
373 2124: Tok.setLength(Len);
374 :
375 : const char *DestPtr;
376 2124: SourceLocation Loc = ScratchBuf->getToken(Buf, Len, DestPtr);
377 :
218: branch 1 taken
1906: branch 2 taken
378 2124: if (InstantiationLoc.isValid())
379 : Loc = SourceMgr.createInstantiationLoc(Loc, InstantiationLoc,
380 218: InstantiationLoc, Len);
381 2124: Tok.setLocation(Loc);
382 :
383 : // If this is a literal token, set the pointer data.
2104: branch 1 taken
20: branch 2 taken
384 2124: if (Tok.isLiteral())
385 2104: Tok.setLiteralData(DestPtr);
386 2124: }
387 :
388 :
389 : /// AdvanceToTokenCharacter - Given a location that specifies the start of a
390 : /// token, return a new location that specifies a character within the token.
391 : SourceLocation Preprocessor::AdvanceToTokenCharacter(SourceLocation TokStart,
392 96034: unsigned CharNo) {
393 : // Figure out how many physical characters away the specified instantiation
394 : // character is. This needs to take into consideration newlines and
395 : // trigraphs.
396 96034: const char *TokPtr = SourceMgr.getCharacterData(TokStart);
397 :
398 : // If they request the first char of the token, we're trivially done.
89: branch 0 taken
95945: branch 1 taken
86: branch 3 taken
3: branch 4 taken
86: branch 5 taken
95948: branch 6 taken
399 96034: if (CharNo == 0 && Lexer::isObviouslySimpleCharacter(*TokPtr))
400 86: return TokStart;
401 :
402 95948: unsigned PhysOffset = 0;
403 :
404 : // The usual case is that tokens don't contain anything interesting. Skip
405 : // over the uninteresting characters. If a token only consists of simple
406 : // chars, this method is extremely fast.
628803: branch 1 taken
27: branch 2 taken
407 724778: while (Lexer::isObviouslySimpleCharacter(*TokPtr)) {
95921: branch 0 taken
532882: branch 1 taken
408 628803: if (CharNo == 0)
409 95921: return TokStart.getFileLocWithOffset(PhysOffset);
410 532882: ++TokPtr, --CharNo, ++PhysOffset;
411 : }
412 :
413 : // If we have a character that may be a trigraph or escaped newline, use a
414 : // lexer to parse it correctly.
55: branch 0 taken
27: branch 1 taken
415 82: for (; CharNo; --CharNo) {
416 : unsigned Size;
417 55: Lexer::getCharAndSizeNoWarn(TokPtr, Size, Features);
418 55: TokPtr += Size;
419 55: PhysOffset += Size;
420 : }
421 :
422 : // Final detail: if we end up on an escaped newline, we want to return the
423 : // location of the actual byte of the token. For example foo\<newline>bar
424 : // advanced by 3 should return the location of b, not of \\. One compounding
425 : // detail of this is that the escape may be made by a trigraph.
12: branch 1 taken
15: branch 2 taken
426 27: if (!Lexer::isObviouslySimpleCharacter(*TokPtr))
427 12: PhysOffset += Lexer::SkipEscapedNewLines(TokPtr)-TokPtr;
428 :
429 27: return TokStart.getFileLocWithOffset(PhysOffset);
430 : }
431 :
432 : SourceLocation Preprocessor::getLocForEndOfToken(SourceLocation Loc,
433 136174: unsigned Offset) {
136171: branch 1 taken
3: branch 2 taken
0: branch 4 not taken
136171: branch 5 taken
3: branch 6 taken
136171: branch 7 taken
434 136174: if (Loc.isInvalid() || !Loc.isFileID())
435 3: return SourceLocation();
436 :
437 136171: unsigned Len = Lexer::MeasureTokenLength(Loc, getSourceManager(), Features);
95764: branch 0 taken
40407: branch 1 taken
438 136171: if (Len > Offset)
439 95764: Len = Len - Offset;
440 : else
441 40407: return Loc;
442 :
443 95764: return AdvanceToTokenCharacter(Loc, Len);
444 : }
445 :
446 :
447 :
448 : //===----------------------------------------------------------------------===//
449 : // Preprocessor Initialization Methods
450 : //===----------------------------------------------------------------------===//
451 :
452 :
453 : /// EnterMainSourceFile - Enter the specified FileID as the main source file,
454 : /// which implicitly adds the builtin defines etc.
455 2519: void Preprocessor::EnterMainSourceFile() {
456 : // We do not allow the preprocessor to reenter the main file. Doing so will
457 : // cause FileID's to accumulate information from both runs (e.g. #line
458 : // information) and predefined macros aren't guaranteed to be set properly.
0: branch 0 not taken
2519: branch 1 taken
459 2519: assert(NumEnteredSourceFiles == 0 && "Cannot reenter the main file!");
460 2519: FileID MainFileID = SourceMgr.getMainFileID();
461 :
462 : // Enter the main file source buffer.
463 2519: std::string ErrorStr;
464 2519: bool Res = EnterSourceFile(MainFileID, 0, ErrorStr);
0: branch 0 not taken
2519: branch 1 taken
465 2519: assert(!Res && "Entering main file should not fail!");
466 :
467 : // Tell the header info that the main file was entered. If the file is later
468 : // #imported, it won't be re-entered.
2422: branch 1 taken
97: branch 2 taken
469 2519: if (const FileEntry *FE = SourceMgr.getFileEntryForID(MainFileID))
470 2422: HeaderInfo.IncrementIncludeCount(FE);
471 :
472 : // Preprocess Predefines to populate the initial preprocessor state.
473 : llvm::MemoryBuffer *SB =
474 : llvm::MemoryBuffer::getMemBufferCopy(Predefines.data(),
475 : Predefines.data() + Predefines.size(),
476 2519: "<built-in>");
0: branch 0 not taken
2519: branch 1 taken
477 2519: assert(SB && "Cannot fail to create predefined source buffer");
478 2519: FileID FID = SourceMgr.createFileIDForMemBuffer(SB);
2519: branch 1 taken
0: branch 2 not taken
479 2519: assert(!FID.isInvalid() && "Could not create FileID for predefines?");
480 :
481 : // Start parsing the predefines.
482 2519: Res = EnterSourceFile(FID, 0, ErrorStr);
0: branch 0 not taken
2519: branch 1 taken
483 2519: assert(!Res && "Entering predefines should not fail!");
484 2519: }
485 :
486 :
487 : //===----------------------------------------------------------------------===//
488 : // Lexer Event Handling.
489 : //===----------------------------------------------------------------------===//
490 :
491 : /// LookUpIdentifierInfo - Given a tok::identifier token, look up the
492 : /// identifier information for the token and install it into the token.
493 : IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier,
494 864130: const char *BufPtr) const {
864130: branch 1 taken
0: branch 2 not taken
495 864130: assert(Identifier.is(tok::identifier) && "Not an identifier!");
864130: branch 1 taken
0: branch 2 not taken
496 864130: assert(Identifier.getIdentifierInfo() == 0 && "Identinfo already exists!");
497 :
498 : // Look up this token, see if it is a macro, or if it is a language keyword.
499 : IdentifierInfo *II;
864063: branch 0 taken
67: branch 1 taken
864056: branch 3 taken
7: branch 4 taken
864056: branch 5 taken
74: branch 6 taken
500 1728193: if (BufPtr && !Identifier.needsCleaning()) {
501 : // No cleaning needed, just use the characters from the lexed buffer.
502 864056: II = getIdentifierInfo(llvm::StringRef(BufPtr, Identifier.getLength()));
503 : } else {
504 : // Cleaning needed, alloca a buffer, clean into it, then use the buffer.
505 74: llvm::SmallVector<char, 64> IdentifierBuffer;
506 74: IdentifierBuffer.resize(Identifier.getLength());
507 74: const char *TmpBuf = &IdentifierBuffer[0];
508 74: unsigned Size = getSpelling(Identifier, TmpBuf);
509 74: II = getIdentifierInfo(llvm::StringRef(TmpBuf, Size));
510 : }
511 864130: Identifier.setIdentifierInfo(II);
512 864130: return II;
513 : }
514 :
515 :
516 : /// HandleIdentifier - This callback is invoked when the lexer reads an
517 : /// identifier. This callback looks up the identifier in the map and/or
518 : /// potentially macro expands it or turns it into a named token (like 'for').
519 : ///
520 : /// Note that callers of this method are guarded by checking the
521 : /// IdentifierInfo's 'isHandleIdentifierCase' bit. If this method changes, the
522 : /// IdentifierInfo methods that compute these properties will need to change to
523 : /// match.
524 18603: void Preprocessor::HandleIdentifier(Token &Identifier) {
525 : assert(Identifier.getIdentifierInfo() &&
18603: branch 1 taken
0: branch 2 not taken
526 18603: "Can't handle identifiers without identifier info!");
527 :
528 18603: IdentifierInfo &II = *Identifier.getIdentifierInfo();
529 :
530 : // If this identifier was poisoned, and if it was not produced from a macro
531 : // expansion, emit an error.
8: branch 1 taken
18595: branch 2 taken
4: branch 3 taken
4: branch 4 taken
4: branch 5 taken
18599: branch 6 taken
532 18611: if (II.isPoisoned() && CurPPLexer) {
3: branch 0 taken
1: branch 1 taken
533 4: if (&II != Ident__VA_ARGS__) // We warn about __VA_ARGS__ with poisoning.
534 3: Diag(Identifier, diag::err_pp_used_poisoned_id);
535 : else
536 1: Diag(Identifier, diag::ext_pp_bad_vaargs_use);
537 : }
538 :
539 : // If this is a macro to be expanded, do it.
18338: branch 1 taken
265: branch 2 taken
540 18603: if (MacroInfo *MI = getMacroInfo(&II)) {
11868: branch 0 taken
6470: branch 1 taken
11847: branch 3 taken
21: branch 4 taken
11847: branch 5 taken
6491: branch 6 taken
541 18338: if (!DisableMacroExpansion && !Identifier.isExpandDisabled()) {
11808: branch 1 taken
39: branch 2 taken
542 11847: if (MI->isEnabled()) {
11770: branch 1 taken
38: branch 2 taken
543 11808: if (!HandleMacroExpandedIdentifier(Identifier, MI))
544 11770: return;
545 : } else {
546 : // C99 6.10.3.4p2 says that a disabled macro may never again be
547 : // expanded, even if it's in a context where it could be expanded in the
548 : // future.
549 39: Identifier.setFlag(Token::DisableExpand);
550 : }
551 : }
552 : }
553 :
554 : // C++ 2.11p2: If this is an alternative representation of a C++ operator,
555 : // then we act as if it is the actual operator and not the textual
556 : // representation of it.
34: branch 1 taken
6799: branch 2 taken
557 6833: if (II.isCPlusPlusOperatorKeyword())
558 34: Identifier.setIdentifierInfo(0);
559 :
560 : // If this is an extension token, diagnose its use.
561 : // We avoid diagnosing tokens that originate from macro definitions.
562 : // FIXME: This warning is disabled in cases where it shouldn't be,
563 : // like "#define TY typeof", "TY(1) x".
223: branch 1 taken
6610: branch 2 taken
209: branch 3 taken
14: branch 4 taken
209: branch 5 taken
6624: branch 6 taken
564 6833: if (II.isExtensionToken() && !DisableMacroExpansion)
565 209: Diag(Identifier, diag::ext_token_used);
566 : }
567 :
568 2251: void Preprocessor::AddCommentHandler(CommentHandler *Handler) {
0: branch 0 not taken
2251: branch 1 taken
569 2251: assert(Handler && "NULL comment handler");
570 : assert(std::find(CommentHandlers.begin(), CommentHandlers.end(), Handler) ==
2251: branch 5 taken
0: branch 6 not taken
571 2251: CommentHandlers.end() && "Comment handler already registered");
572 2251: CommentHandlers.push_back(Handler);
573 2251: }
574 :
575 2251: void Preprocessor::RemoveCommentHandler(CommentHandler *Handler) {
576 : std::vector<CommentHandler *>::iterator Pos
577 2251: = std::find(CommentHandlers.begin(), CommentHandlers.end(), Handler);
2251: branch 2 taken
0: branch 3 not taken
578 2251: assert(Pos != CommentHandlers.end() && "Comment handler not registered");
579 2251: CommentHandlers.erase(Pos);
580 2251: }
581 :
582 45521: bool Preprocessor::HandleComment(Token &result, SourceRange Comment) {
583 45521: bool AnyPendingTokens = false;
28241: branch 3 taken
45521: branch 4 taken
584 119283: for (std::vector<CommentHandler *>::iterator H = CommentHandlers.begin(),
585 45521: HEnd = CommentHandlers.end();
586 : H != HEnd; ++H) {
0: branch 2 not taken
28241: branch 3 taken
587 28241: if ((*H)->HandleComment(*this, Comment))
588 0: AnyPendingTokens = true;
589 : }
0: branch 0 not taken
45521: branch 1 taken
0: branch 3 not taken
0: branch 4 not taken
45521: branch 5 taken
0: branch 6 not taken
590 45521: if (!AnyPendingTokens || getCommentRetentionState())
591 45521: return false;
592 0: Lex(result);
593 0: return true;
594 : }
595 :
2251: branch 0 taken
2251: branch 1 taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 6 not taken
2251: branch 7 taken
596 2251: CommentHandler::~CommentHandler() { }
Generated: 2010-02-10 01:31 by zcov