1 //===--- PPCaching.cpp - Handle caching lexed tokens ----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements pieces of the Preprocessor interface that manage the
11 // caching of lexed tokens.
13 //===----------------------------------------------------------------------===//
15 #include "clang/Lex/Preprocessor.h"
16 using namespace clang
;
18 /// EnableBacktrackAtThisPos - From the point that this method is called, and
19 /// until CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor
20 /// keeps track of the lexed tokens so that a subsequent Backtrack() call will
21 /// make the Preprocessor re-lex the same tokens.
23 /// Nested backtracks are allowed, meaning that EnableBacktrackAtThisPos can
24 /// be called multiple times and CommitBacktrackedTokens/Backtrack calls will
25 /// be combined with the EnableBacktrackAtThisPos calls in reverse order.
26 void Preprocessor::EnableBacktrackAtThisPos() {
27 BacktrackPositions
.push_back(CachedLexPos
);
28 EnterCachingLexMode();
31 /// CommitBacktrackedTokens - Disable the last EnableBacktrackAtThisPos call.
32 void Preprocessor::CommitBacktrackedTokens() {
33 assert(!BacktrackPositions
.empty()
34 && "EnableBacktrackAtThisPos was not called!");
35 BacktrackPositions
.pop_back();
38 /// Backtrack - Make Preprocessor re-lex the tokens that were lexed since
39 /// EnableBacktrackAtThisPos() was previously called.
40 void Preprocessor::Backtrack() {
41 assert(!BacktrackPositions
.empty()
42 && "EnableBacktrackAtThisPos was not called!");
43 CachedLexPos
= BacktrackPositions
.back();
44 BacktrackPositions
.pop_back();
47 void Preprocessor::CachingLex(Token
&Result
) {
48 if (CachedLexPos
< CachedTokens
.size()) {
49 Result
= CachedTokens
[CachedLexPos
++];
56 if (!isBacktrackEnabled()) {
57 // All cached tokens were consumed.
63 // We should cache the lexed token.
65 EnterCachingLexMode();
66 if (Result
.isNot(tok::eof
)) {
67 CachedTokens
.push_back(Result
);
72 void Preprocessor::EnterCachingLexMode() {
73 if (InCachingLexMode())
76 PushIncludeMacroStack();
80 const Token
&Preprocessor::PeekAhead(unsigned N
) {
81 assert(CachedLexPos
+ N
> CachedTokens
.size() && "Confused caching.");
83 for (unsigned C
= CachedLexPos
+ N
- CachedTokens
.size(); C
> 0; --C
) {
84 CachedTokens
.push_back(Token());
85 Lex(CachedTokens
.back());
87 EnterCachingLexMode();
88 return CachedTokens
.back();
91 void Preprocessor::AnnotatePreviousCachedTokens(const Token
&Tok
) {
92 assert(Tok
.isAnnotation() && "Expected annotation token");
93 assert(CachedLexPos
!= 0 && "Expected to have some cached tokens");
94 assert(CachedTokens
[CachedLexPos
-1].getLocation() == Tok
.getAnnotationEndLoc()
95 && "The annotation should be until the most recent cached token");
97 // Start from the end of the cached tokens list and look for the token
98 // that is the beginning of the annotation token.
99 for (CachedTokensTy::size_type i
= CachedLexPos
; i
!= 0; --i
) {
100 CachedTokensTy::iterator AnnotBegin
= CachedTokens
.begin() + i
-1;
101 if (AnnotBegin
->getLocation() == Tok
.getLocation()) {
102 assert((BacktrackPositions
.empty() || BacktrackPositions
.back() < i
) &&
103 "The backtrack pos points inside the annotated tokens!");
104 // Replace the cached tokens with the single annotation token.
105 CachedTokens
.erase(AnnotBegin
+ 1, CachedTokens
.begin() + CachedLexPos
);
112 assert(0&&"Didn't find the first token represented by the annotation token!");