FormatTokenSource.h

Go to the documentation of this file.

//===--- FormatTokenSource.h - Format C++ code ------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file defines the \c FormatTokenSource interface, which provides a token
/// stream as well as the ability to manipulate the token stream.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_LIB_FORMAT_FORMATTOKENSOURCE_H
#define LLVM_CLANG_LIB_FORMAT_FORMATTOKENSOURCE_H
 
#include "FormatToken.h"
#include "UnwrappedLineParser.h"
#include "llvm/ADT/DenseMap.h"
#include <cstddef>
 
#define DEBUG_TYPE "format-token-source"
 
namespace clang {
namespace format {
 
// Navigate a token stream.
//
// Enables traversal of a token stream, resetting the position in a token
// stream, as well as inserting new tokens.
class FormatTokenSource {
public:
  virtual ~FormatTokenSource() {}
 
  // Returns the next token in the token stream.
  virtual FormatToken *getNextToken() = 0;
 
  // Returns the token preceding the token returned by the last call to
  // getNextToken() in the token stream, or nullptr if no such token exists.
  //
  // Must not be called directly at the position directly after insertTokens()
  // is called.
  virtual FormatToken *getPreviousToken() = 0;
 
  // Returns the token that would be returned by the next call to
  // getNextToken().
  virtual FormatToken *peekNextToken(bool SkipComment = false) = 0;
 
  // Returns whether we are at the end of the file.
  // This can be different from whether getNextToken() returned an eof token
  // when the FormatTokenSource is a view on a part of the token stream.
  virtual bool isEOF() = 0;
 
  // Gets the current position in the token stream, to be used by setPosition().
  //
  // Note that the value of the position is not meaningful, and specifically
  // should not be used to get relative token positions.
  virtual unsigned getPosition() = 0;
 
  // Resets the token stream to the state it was in when getPosition() returned
  // Position, and return the token at that position in the stream.
  virtual FormatToken *setPosition(unsigned Position) = 0;
 
  // Insert the given tokens before the current position.
  // Returns the first token in \c Tokens.
  // The next returned token will be the second token in \c Tokens.
  // Requires the last token in Tokens to be EOF; once the EOF token is reached,
  // the next token will be the last token returned by getNextToken();
  //
  // For example, given the token sequence 'a1 a2':
  // getNextToken() -> a1
  // insertTokens('b1 b2') -> b1
  // getNextToken() -> b2
  // getNextToken() -> a1
  // getNextToken() -> a2
  virtual FormatToken *insertTokens(ArrayRef<FormatToken *> Tokens) = 0;
};
 
class IndexedTokenSource : public FormatTokenSource {
public:
  IndexedTokenSource(ArrayRef<FormatToken *> Tokens)
      : Tokens(Tokens), Position(-1) {}
 
  FormatToken *getNextToken() override {
    if (Position >= 0 && isEOF()) {
      LLVM_DEBUG({
        llvm::dbgs() << "Next ";
        dbgToken(Position);
      });
      return Tokens[Position];
    }
    Position = successor(Position);
    LLVM_DEBUG({
      llvm::dbgs() << "Next ";
      dbgToken(Position);
    });
    return Tokens[Position];
  }
 
  FormatToken *getPreviousToken() override {
    assert(Position <= 0 || Tokens[Position - 1]->isNot(tok::eof));
    return Position > 0 ? Tokens[Position - 1] : nullptr;
  }
 
  FormatToken *peekNextToken(bool SkipComment = false) override {
    if (isEOF())
      return Tokens[Position];
    int Next = successor(Position);
    if (SkipComment)
      while (Tokens[Next]->is(tok::comment))
        Next = successor(Next);
    LLVM_DEBUG({
      llvm::dbgs() << "Peeking ";
      dbgToken(Next);
    });
    return Tokens[Next];
  }
 
  bool isEOF() override {
    return Position == -1 ? false : Tokens[Position]->is(tok::eof);
  }
 
  unsigned getPosition() override {
    LLVM_DEBUG(llvm::dbgs() << "Getting Position: " << Position << "\n");
    assert(Position >= 0);
    return Position;
  }
 
  FormatToken *setPosition(unsigned P) override {
    LLVM_DEBUG(llvm::dbgs() << "Setting Position: " << P << "\n");
    Position = P;
    return Tokens[Position];
  }
 
  FormatToken *insertTokens(ArrayRef<FormatToken *> New) override {
    assert(Position != -1);
    assert((*New.rbegin())->Tok.is(tok::eof));
    int Next = Tokens.size();
    Tokens.append(New.begin(), New.end());
    LLVM_DEBUG({
      llvm::dbgs() << "Inserting:\n";
      for (int I = Next, E = Tokens.size(); I != E; ++I)
        dbgToken(I, "  ");
      llvm::dbgs() << "  Jump from: " << (Tokens.size() - 1) << " -> "
                   << Position << "\n";
    });
    Jumps[Tokens.size() - 1] = Position;
    Position = Next;
    LLVM_DEBUG({
      llvm::dbgs() << "At inserted token ";
      dbgToken(Position);
    });
    return Tokens[Position];
  }
 
  void reset() { Position = -1; }
 
private:
  int successor(int Current) const {
    int Next = Current + 1;
    auto it = Jumps.find(Next);
    if (it != Jumps.end()) {
      Next = it->second;
      assert(!Jumps.contains(Next));
    }
    return Next;
  }
 
  void dbgToken(int Position, llvm::StringRef Indent = "") {
    FormatToken *Tok = Tokens[Position];
    llvm::dbgs() << Indent << "[" << Position
                 << "] Token: " << Tok->Tok.getName() << " / " << Tok->TokenText
                 << ", Macro: " << !!Tok->MacroCtx << "\n";
  }
 
  SmallVector<FormatToken *> Tokens;
  int Position;
 
  // Maps from position a to position b, so that when we reach a, the token
  // stream continues at position b instead.
  llvm::DenseMap<int, int> Jumps;
};
 
class ScopedMacroState : public FormatTokenSource {
public:
  ScopedMacroState(UnwrappedLine &Line, FormatTokenSource *&TokenSource,
                   FormatToken *&ResetToken)
      : Line(Line), TokenSource(TokenSource), ResetToken(ResetToken),
        PreviousLineLevel(Line.Level), PreviousTokenSource(TokenSource),
        Token(nullptr), PreviousToken(nullptr) {
    FakeEOF.Tok.startToken();
    FakeEOF.Tok.setKind(tok::eof);
    TokenSource = this;
    Line.Level = 0;
    Line.InPPDirective = true;
    // InMacroBody gets set after the `#define x` part.
  }
 
  ~ScopedMacroState() override {
    TokenSource = PreviousTokenSource;
    ResetToken = Token;
    Line.InPPDirective = false;
    Line.InMacroBody = false;
    Line.Level = PreviousLineLevel;
  }
 
  FormatToken *getNextToken() override {
    // The \c UnwrappedLineParser guards against this by never calling
    // \c getNextToken() after it has encountered the first eof token.
    assert(!eof());
    PreviousToken = Token;
    Token = PreviousTokenSource->getNextToken();
    if (eof())
      return &FakeEOF;
    return Token;
  }
 
  FormatToken *getPreviousToken() override {
    return PreviousTokenSource->getPreviousToken();
  }
 
  FormatToken *peekNextToken(bool SkipComment) override {
    if (eof())
      return &FakeEOF;
    return PreviousTokenSource->peekNextToken(SkipComment);
  }
 
  bool isEOF() override { return PreviousTokenSource->isEOF(); }
 
  unsigned getPosition() override { return PreviousTokenSource->getPosition(); }
 
  FormatToken *setPosition(unsigned Position) override {
    PreviousToken = nullptr;
    Token = PreviousTokenSource->setPosition(Position);
    return Token;
  }
 
  FormatToken *insertTokens(ArrayRef<FormatToken *> Tokens) override {
    llvm_unreachable("Cannot insert tokens while parsing a macro.");
    return nullptr;
  }
 
private:
  bool eof() {
    return Token && Token->HasUnescapedNewline &&
           !continuesLineComment(*Token, PreviousToken,
                                 /*MinColumnToken=*/PreviousToken);
  }
 
  FormatToken FakeEOF;
  UnwrappedLine &Line;
  FormatTokenSource *&TokenSource;
  FormatToken *&ResetToken;
  unsigned PreviousLineLevel;
  FormatTokenSource *PreviousTokenSource;
 
  FormatToken *Token;
  FormatToken *PreviousToken;
};
 
} // namespace format
} // namespace clang
 
#undef DEBUG_TYPE
 
#endif