BH-Python-Interpreter-2023/src/Evalvisitor.cpp

#include "Evalvisitor.h"

#include <any>
#include <iostream>

#include "Python3ParserBaseVisitor.h"
#include "int2048/int2048.h"
#include "names.h"
#include "utils.h"

VariableContainer Variables;
FucntionContainer Functions;

std::any EvalVisitor::visitFile_input(Python3Parser::File_inputContext *ctx) {
  return visitChildren(ctx);
}

std::any EvalVisitor::visitFuncdef(Python3Parser::FuncdefContext *ctx) {
  std::vector<ParaArguItemType> paraVec =
      std::any_cast<std::vector<ParaArguItemType>>(
          visitParameters(ctx->parameters()));
  std::string name = ctx->NAME()->getText();
  Functions.AddFunction(name, FunctionItem(ctx->suite(), paraVec));
  return NoneType();
}

std::any EvalVisitor::visitParameters(Python3Parser::ParametersContext *ctx) {
  if (!ctx->typedargslist())
    return std::vector<ParaArguItemType>();
  else
    return visitTypedargslist(ctx->typedargslist());
}

std::any EvalVisitor::visitTypedargslist(
    Python3Parser::TypedargslistContext *ctx) {
  auto tfpdef_list = ctx->tfpdef();
  auto default_value_list = ctx->test();
  const int lenght_delta = tfpdef_list.size() - default_value_list.size();
  std::vector<ParaArguItemType> res;
  res.reserve(tfpdef_list.size());
  for (int i = 0; i < lenght_delta; i++)
    res.emplace_back(tfpdef_list[i]->NAME()->getText(), nullptr);
  for (int i = lenght_delta; i < tfpdef_list.size(); i++)
    res.emplace_back(tfpdef_list[i]->NAME()->getText(),
                     DeQuate(visitTest(default_value_list[i - lenght_delta]),
                             Variables));
  return res;
}

std::any EvalVisitor::visitTfpdef(Python3Parser::TfpdefContext *ctx) {
  return visitChildren(ctx);
}

std::any EvalVisitor::visitStmt(Python3Parser::StmtContext *ctx) {
  return visitChildren(ctx);
}

std::any EvalVisitor::visitSimple_stmt(Python3Parser::Simple_stmtContext *ctx) {
  return visitChildren(ctx);
}

std::any EvalVisitor::visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) {
  return visitChildren(ctx);
}

std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitAugassign(Python3Parser::AugassignContext *ctx) {
  throw FatalError("Function visitAugassign Shouldn't be called");
}

std::any EvalVisitor::visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) {
  return visitChildren(ctx);
}

std::any EvalVisitor::visitBreak_stmt(Python3Parser::Break_stmtContext *ctx) {
  return FlowType(BREAK);
}

std::any EvalVisitor::visitContinue_stmt(
    Python3Parser::Continue_stmtContext *ctx) {
  return FlowType(CONTINUE);
}

std::any EvalVisitor::visitReturn_stmt(Python3Parser::Return_stmtContext *ctx) {
  // TODO
  throw FatalError("Not implemented in function visitReturn_stmt");
  return visitChildren(ctx);
}

std::any EvalVisitor::visitCompound_stmt(
    Python3Parser::Compound_stmtContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitIf_stmt(Python3Parser::If_stmtContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitSuite(Python3Parser::SuiteContext *ctx) {
  // TODO
  return visitChildren(ctx);
}
std::any EvalVisitor::visitTestlist(Python3Parser::TestlistContext *ctx) {
  // TODO
  return visitChildren(ctx);
}
std::any EvalVisitor::visitTest(Python3Parser::TestContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitNot_test(Python3Parser::Not_testContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitComp_op(Python3Parser::Comp_opContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitMuldivmod_op(
    Python3Parser::Muldivmod_opContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) {
  // TODO
  return visitChildren(ctx);
}

std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) {
  if (!ctx->trailer()) {
    auto val = visitAtom(ctx->atom());
    std::cerr << "[Log] The Atom returns : ";
    if (auto ptr = std::any_cast<NoneType>(&val)) {
      std::cerr << "NoneType" << std::endl;
    } else if (auto ptr = std::any_cast<RawVarible>(&val)) {
      std::cerr << "Variable Name=" << ptr->name
                << " val=" << Any2String(Variables.ReadVariable(ptr->name))
                << std::endl;
    } else
      std::cerr << Any2String(val) << std::endl;
    return val;
  }
  std::string func_name = ctx->atom()->NAME()->getText();
  std::vector<ParaArguItemType> args =
      std::any_cast<std::vector<ParaArguItemType>>(
          visitTrailer(ctx->trailer()));
  return Functions.CallFunction(func_name, args);
}

std::any EvalVisitor::visitTrailer(Python3Parser::TrailerContext *ctx) {
  if (!ctx->arglist()) return std::vector<ParaArguItemType>();
  return visitArglist(ctx->arglist());
}
std::any EvalVisitor::visitArglist(Python3Parser::ArglistContext *ctx) {
  auto argument_list = ctx->argument();
  std::vector<ParaArguItemType> resolved_args;
  for (auto item : argument_list) {
    resolved_args.push_back(
        std::any_cast<ParaArguItemType>(visitArgument(item)));
  }
  return resolved_args;
}

std::any EvalVisitor::visitArgument(Python3Parser::ArgumentContext *ctx) {
  auto arg_list = ctx->test();
  if (arg_list.size() != 1 && arg_list.size() != 2)
    throw FatalError("visitArgument: arg_list.size()!=1&&arg_list!=2");
  if (arg_list.size() == 1)
    return ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables));
  else
    return ParaArguItemType(arg_list[0]->getText(),
                            DeQuate(visitTest(arg_list[1]), Variables));
}
std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
  if (ctx->NONE())
    return NoneType();
  else if (ctx->TRUE())
    return true;
  else if (ctx->FALSE())
    return false;
  else if (ctx->NUMBER()) {
    std::string num = ctx->getText();
    if (num.find('.') == std::string::npos)
      return std::move(ZYM::int2048(num));
    else
      return std::stod(num);
  } else if (ctx->test())
    return visitTest(ctx->test());
  else if (ctx->NAME()) {
    return RawVarible(ctx->getText());
  } else {
    auto string_lists = ctx->STRING();
    std::string res;
    for (auto item : string_lists) {
      const std::string &tmp = item->getText();
      res.append(tmp, 1, tmp.size() - 2);
    }
    // std::cerr<<"[Log] The string is : "<<res<<std::endl;
    return res;
  }
}