1 //===--- PPCaching.cpp - Handle caching lexed tokens ----------------------===// 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 pieces of the Preprocessor interface that manage the 11 // caching of lexed tokens. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "clang/Lex/Preprocessor.h" 16 using namespace clang; 17 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. 22 // 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. EnableBacktrackAtThisPos()26void Preprocessor::EnableBacktrackAtThisPos() { 27 BacktrackPositions.push_back(CachedLexPos); 28 EnterCachingLexMode(); 29 } 30 31 // Disable the last EnableBacktrackAtThisPos call. CommitBacktrackedTokens()32void Preprocessor::CommitBacktrackedTokens() { 33 assert(!BacktrackPositions.empty() 34 && "EnableBacktrackAtThisPos was not called!"); 35 BacktrackPositions.pop_back(); 36 } 37 38 // Make Preprocessor re-lex the tokens that were lexed since 39 // EnableBacktrackAtThisPos() was previously called. Backtrack()40void Preprocessor::Backtrack() { 41 assert(!BacktrackPositions.empty() 42 && "EnableBacktrackAtThisPos was not called!"); 43 CachedLexPos = BacktrackPositions.back(); 44 BacktrackPositions.pop_back(); 45 recomputeCurLexerKind(); 46 } 47 CachingLex(Token & Result)48void Preprocessor::CachingLex(Token &Result) { 49 if (!InCachingLexMode()) 50 return; 51 52 if (CachedLexPos < CachedTokens.size()) { 53 Result = CachedTokens[CachedLexPos++]; 54 return; 55 } 56 57 ExitCachingLexMode(); 58 Lex(Result); 59 60 if (isBacktrackEnabled()) { 61 // Cache the lexed token. 62 EnterCachingLexMode(); 63 CachedTokens.push_back(Result); 64 ++CachedLexPos; 65 return; 66 } 67 68 if (CachedLexPos < CachedTokens.size()) { 69 EnterCachingLexMode(); 70 } else { 71 // All cached tokens were consumed. 72 CachedTokens.clear(); 73 CachedLexPos = 0; 74 } 75 } 76 EnterCachingLexMode()77void Preprocessor::EnterCachingLexMode() { 78 if (InCachingLexMode()) 79 return; 80 81 PushIncludeMacroStack(); 82 CurLexerKind = CLK_CachingLexer; 83 } 84 85 PeekAhead(unsigned N)86const Token &Preprocessor::PeekAhead(unsigned N) { 87 assert(CachedLexPos + N > CachedTokens.size() && "Confused caching."); 88 ExitCachingLexMode(); 89 for (unsigned C = CachedLexPos + N - CachedTokens.size(); C > 0; --C) { 90 CachedTokens.push_back(Token()); 91 Lex(CachedTokens.back()); 92 } 93 EnterCachingLexMode(); 94 return CachedTokens.back(); 95 } 96 AnnotatePreviousCachedTokens(const Token & Tok)97void Preprocessor::AnnotatePreviousCachedTokens(const Token &Tok) { 98 assert(Tok.isAnnotation() && "Expected annotation token"); 99 assert(CachedLexPos != 0 && "Expected to have some cached tokens"); 100 assert(CachedTokens[CachedLexPos-1].getLastLoc() == Tok.getAnnotationEndLoc() 101 && "The annotation should be until the most recent cached token"); 102 103 // Start from the end of the cached tokens list and look for the token 104 // that is the beginning of the annotation token. 105 for (CachedTokensTy::size_type i = CachedLexPos; i != 0; --i) { 106 CachedTokensTy::iterator AnnotBegin = CachedTokens.begin() + i-1; 107 if (AnnotBegin->getLocation() == Tok.getLocation()) { 108 assert((BacktrackPositions.empty() || BacktrackPositions.back() < i) && 109 "The backtrack pos points inside the annotated tokens!"); 110 // Replace the cached tokens with the single annotation token. 111 if (i < CachedLexPos) 112 CachedTokens.erase(AnnotBegin + 1, CachedTokens.begin() + CachedLexPos); 113 *AnnotBegin = Tok; 114 CachedLexPos = i; 115 return; 116 } 117 } 118 } 119 IsPreviousCachedToken(const Token & Tok) const120bool Preprocessor::IsPreviousCachedToken(const Token &Tok) const { 121 // There's currently no cached token... 122 if (!CachedLexPos) 123 return false; 124 125 const Token LastCachedTok = CachedTokens[CachedLexPos - 1]; 126 if (LastCachedTok.getKind() != Tok.getKind()) 127 return false; 128 129 int RelOffset = 0; 130 if ((!getSourceManager().isInSameSLocAddrSpace( 131 Tok.getLocation(), getLastCachedTokenLocation(), &RelOffset)) || 132 RelOffset) 133 return false; 134 135 return true; 136 } 137 ReplacePreviousCachedToken(ArrayRef<Token> NewToks)138void Preprocessor::ReplacePreviousCachedToken(ArrayRef<Token> NewToks) { 139 assert(CachedLexPos != 0 && "Expected to have some cached tokens"); 140 CachedTokens.insert(CachedTokens.begin() + CachedLexPos - 1, NewToks.begin(), 141 NewToks.end()); 142 CachedTokens.erase(CachedTokens.begin() + CachedLexPos - 1 + NewToks.size()); 143 CachedLexPos += NewToks.size() - 1; 144 } 145