• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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()26 void Preprocessor::EnableBacktrackAtThisPos() {
27   BacktrackPositions.push_back(CachedLexPos);
28   EnterCachingLexMode();
29 }
30 
31 // Disable the last EnableBacktrackAtThisPos call.
CommitBacktrackedTokens()32 void 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()40 void 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)48 void 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()77 void Preprocessor::EnterCachingLexMode() {
78   if (InCachingLexMode())
79     return;
80 
81   PushIncludeMacroStack();
82   CurLexerKind = CLK_CachingLexer;
83 }
84 
85 
PeekAhead(unsigned N)86 const 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)97 void 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) const120 bool 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)138 void 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