//===--- PPCaching.cpp - Handle caching lexed tokens ----------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements pieces of the Preprocessor interface that manage the

// caching of lexed tokens.

//

//===----------------------------------------------------------------------===//

#include "clang/Lex/Preprocessor.h"

using namespace clang;

// EnableBacktrackAtThisPos - From the point that this method is called, and

// until CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor

// keeps track of the lexed tokens so that a subsequent Backtrack() call will

// make the Preprocessor re-lex the same tokens.

//

// Nested backtracks are allowed, meaning that EnableBacktrackAtThisPos can

// be called multiple times and CommitBacktrackedTokens/Backtrack calls will

// be combined with the EnableBacktrackAtThisPos calls in reverse order.

void Preprocessor::EnableBacktrackAtThisPos() {

  assert(LexLevel == 0 && "cannot use lookahead while lexing");

  BacktrackPositions.push_back(CachedLexPos);

  EnterCachingLexMode();

}

// Disable the last EnableBacktrackAtThisPos call.

void Preprocessor::CommitBacktrackedTokens() {

  assert(!BacktrackPositions.empty()

         && "EnableBacktrackAtThisPos was not called!");

  BacktrackPositions.pop_back();

}

// Make Preprocessor re-lex the tokens that were lexed since

// EnableBacktrackAtThisPos() was previously called.

void Preprocessor::Backtrack() {

  assert(!BacktrackPositions.empty()

         && "EnableBacktrackAtThisPos was not called!");

  CachedLexPos = BacktrackPositions.back();

  BacktrackPositions.pop_back();

  recomputeCurLexerKind();

}

void Preprocessor::CachingLex(Token &Result) {

  if (!InCachingLexMode())

    return;

  // The assert in EnterCachingLexMode should prevent this from happening.

  assert(LexLevel == 1 &&

         "should not use token caching within the preprocessor");

  if (CachedLexPos < CachedTokens.size()) {

    Result = CachedTokens[CachedLexPos++];

    Result.setFlag(Token::IsReinjected);

    return;

  }

  ExitCachingLexMode();

  Lex(Result);

  if (isBacktrackEnabled()) {

    // Cache the lexed token.

    EnterCachingLexModeUnchecked();

    CachedTokens.push_back(Result);

    ++CachedLexPos;

    return;

  }

  if (CachedLexPos < CachedTokens.size()) {

    EnterCachingLexModeUnchecked();

  } else {

    // All cached tokens were consumed.

    CachedTokens.clear();

    CachedLexPos = 0;

  }

}

void Preprocessor::EnterCachingLexMode() {

  // The caching layer sits on top of all the other lexers, so it's incorrect

  // to cache tokens while inside a nested lex action. The cached tokens would

  // be retained after returning to the enclosing lex action and, at best,

  // would appear at the wrong position in the token stream.

  assert(LexLevel == 0 &&

         "entered caching lex mode while lexing something else");

  if (InCachingLexMode()) {

    assert(CurLexerKind == CLK_CachingLexer && "Unexpected lexer kind");

    return;

  }

  EnterCachingLexModeUnchecked();

}

void Preprocessor::EnterCachingLexModeUnchecked() {

  assert(CurLexerKind != CLK_CachingLexer && "already in caching lex mode");

  PushIncludeMacroStack();

  CurLexerKind = CLK_CachingLexer;

}

const Token &Preprocessor::PeekAhead(unsigned N) {

  assert(CachedLexPos + N > CachedTokens.size() && "Confused caching.");

  ExitCachingLexMode();

  for (size_t C = CachedLexPos + N - CachedTokens.size(); C > 0; 
--C161M
) {

    CachedTokens.push_back(Token());

    Lex(CachedTokens.back());

  }

  EnterCachingLexMode();

  return CachedTokens.back();

}

void Preprocessor::AnnotatePreviousCachedTokens(const Token &Tok) {

  assert(Tok.isAnnotation() && "Expected annotation token");

  assert(CachedLexPos != 0 && "Expected to have some cached tokens");

  assert(CachedTokens[CachedLexPos-1].getLastLoc() == Tok.getAnnotationEndLoc()

         && "The annotation should be until the most recent cached token");

  // Start from the end of the cached tokens list and look for the token

  // that is the beginning of the annotation token.

  
for (CachedTokensTy::size_type i = CachedLexPos; 11.7M
i != 0; 
--i550k
) {

    CachedTokensTy::iterator AnnotBegin = CachedTokens.begin() + i-1;

    if (AnnotBegin->getLocation() == Tok.getLocation()) {

      assert((BacktrackPositions.empty() || BacktrackPositions.back() <= i) &&

             "The backtrack pos points inside the annotated tokens!");

      // Replace the cached tokens with the single annotation token.

      if (i < CachedLexPos)

        CachedTokens.erase(AnnotBegin + 1, CachedTokens.begin() + CachedLexPos);

      *AnnotBegin = Tok;

      CachedLexPos = i;

      return;

    }

  }

}

bool Preprocessor::IsPreviousCachedToken(const Token &Tok) const {

  // There's currently no cached token...

  if (!CachedLexPos)

    return false;

  const Token LastCachedTok = CachedTokens[CachedLexPos - 1];

  if (LastCachedTok.getKind() != Tok.getKind())

    return false;

  SourceLocation::IntTy RelOffset = 0;

  if ((!getSourceManager().isInSameSLocAddrSpace(

          Tok.getLocation(), getLastCachedTokenLocation(), &RelOffset)) ||

      RelOffset)

    return false;

  return true;

}

void Preprocessor::ReplacePreviousCachedToken(ArrayRef<Token> NewToks) {

  assert(CachedLexPos != 0 && "Expected to have some cached tokens");

  CachedTokens.insert(CachedTokens.begin() + CachedLexPos - 1, NewToks.begin(),

                      NewToks.end());

  CachedTokens.erase(CachedTokens.begin() + CachedLexPos - 1 + NewToks.size());

  CachedLexPos += NewToks.size() - 1;

}