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.
26 void Preprocessor::EnableBacktrackAtThisPos() {
27   BacktrackPositions.push_back(CachedLexPos);
28   EnterCachingLexMode();
29 }
30 
31 /// CommitBacktrackedTokens - Disable the last EnableBacktrackAtThisPos call.
32 void Preprocessor::CommitBacktrackedTokens() {
33   assert(!BacktrackPositions.empty()
34          && "EnableBacktrackAtThisPos was not called!");
35   BacktrackPositions.pop_back();
36 }
37 
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();
45 }
46 
47 void Preprocessor::CachingLex(Token &Result) {
48   if (CachedLexPos < CachedTokens.size()) {
49     Result = CachedTokens[CachedLexPos++];
50     return;
51   }
52 
53   ExitCachingLexMode();
54   Lex(Result);
55 
56   if (!isBacktrackEnabled()) {
57     // All cached tokens were consumed.
58     CachedTokens.clear();
59     CachedLexPos = 0;
60     return;
61   }
62 
63   // We should cache the lexed token.
64 
65   EnterCachingLexMode();
66   if (Result.isNot(tok::eof)) {
67     CachedTokens.push_back(Result);
68     ++CachedLexPos;
69   }
70 }
71 
72 void Preprocessor::EnterCachingLexMode() {
73   if (InCachingLexMode())
74     return;
75 
76   PushIncludeMacroStack();
77 }
78 
79 
80 const Token &Preprocessor::PeekAhead(unsigned N) {
81   assert(CachedLexPos + N > CachedTokens.size() && "Confused caching.");
82   ExitCachingLexMode();
83   for (unsigned C = CachedLexPos + N - CachedTokens.size(); C > 0; --C) {
84     CachedTokens.push_back(Token());
85     Lex(CachedTokens.back());
86   }
87   EnterCachingLexMode();
88   return CachedTokens.back();
89 }
90 
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");
96 
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);
106       *AnnotBegin = Tok;
107       CachedLexPos = i;
108       return;
109     }
110   }
111 
112   assert(0&&"Didn't find the first token represented by the annotation token!");
113 }
114