//===--- Token.cpp - Tokens and token streams in the pseudoparser ---------===//

//

// 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

//

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

#include "clang-pseudo/Token.h"

#include "clang/Basic/LangOptions.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Support/Format.h"

#include "llvm/Support/FormatVariadic.h"

namespace clang {

namespace pseudo {

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Token &T) {

  OS << llvm::formatv("{0} {1}:{2} ", clang::tok::getTokenName(T.Kind), T.Line,

                      T.Indent);

  OS << '"';

  llvm::printEscapedString(T.text(), OS);

  OS << '"';

  if (T.Flags)

    OS << llvm::format(" flags=%x", T.Flags);

  return OS;

}

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const TokenStream &TS) {

  OS << "Index               Kind    Line  Text\n";

  for (const auto &T : TS.tokens()) {

    OS << llvm::format("%5d:  %16s %4d:%-2d  ", TS.index(T),

                       clang::tok::getTokenName(T.Kind), T.Line, T.Indent);

    OS << '"';

    llvm::printEscapedString(T.text(), OS);

    OS << '"';

    if (T.Flags)

      OS << llvm::format("  flags=%x", T.Flags);

    OS << '\n';

  }

  return OS;

}

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Token::Range &R) {

  OS << llvm::formatv("[{0},{1})", R.Begin, R.End);

  return OS;

}

TokenStream::TokenStream(std::shared_ptr<void> Payload)

    : Payload(std::move(Payload)) {

  Storage.emplace_back();

  Storage.back().Kind = clang::tok::eof;

}

void TokenStream::finalize() {

  assert(!isFinalized());

  unsigned LastLine = Storage.back().Line;

  Storage.emplace_back();

  Storage.back().Kind = tok::eof;

  Storage.back().Line = LastLine + 1;

  Tokens = Storage;

  Tokens = Tokens.drop_front().drop_back();

}

bool TokenStream::isFinalized() const {

  assert(!Storage.empty() && Storage.front().Kind == tok::eof);

  if (Storage.size() == 1)

    return false;

  return Storage.back().Kind == tok::eof;

}

void TokenStream::print(llvm::raw_ostream &OS) const {

  bool FirstToken = true;

  unsigned LastLine = -1;

  StringRef LastText;

  for (const auto &T : tokens()) {

    StringRef Text = T.text();

    if (FirstToken) {

      FirstToken = false;

    } else if (T.Line == LastLine) {

      if (LastText.data() + LastText.size() != Text.data())

        OS << ' ';

    } else {

      OS << '\n';

      OS.indent(T.Indent);

    }

    OS << Text;

    LastLine = T.Line;

    LastText = Text;

  }

  if (!FirstToken)

    OS << '\n';

}

clang::LangOptions genericLangOpts(clang::Language Lang,

                                   clang::LangStandard::Kind Standard) {

  clang::LangOptions Opts;

  std::vector<std::string> UnusedIncludes;

  LangOptions::setLangDefaults(Opts, Lang, llvm::Triple(), UnusedIncludes,

                               Standard);

  // Some options are "on by default", but e.g. at the driver level.

  if (Opts.CPlusPlus)

    Opts.CXXOperatorNames = true;

  if (Opts.CPlusPlus20)

    Opts.Coroutines = true;

  // Some options are off by default, but define keywords we want to tolerate.

  if (Opts.CPlusPlus)

    Opts.MicrosoftExt = true;  // kw__try, kw__finally

  Opts.DeclSpecKeyword = true; // __declspec

  Opts.WChar = true;

  return Opts;

}

TokenStream stripComments(const TokenStream &Input) {

  TokenStream Out(Input.getPayload());

  for (const Token &T : Input.tokens()) {

    if (T.Kind == tok::comment)

      continue;

    Out.push(T);

  }

  Out.finalize();

  return Out;

}

} // namespace pseudo

} // namespace clang