From 9cc802fb7ac76583e0bde25d1fa4a64e720879cf Mon Sep 17 00:00:00 2001 From: ZhuangYumin Date: Thu, 9 Nov 2023 16:49:45 +0800 Subject: [PATCH] upd: first version of Expr_stmt --- src/Evalvisitor.cpp | 210 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 184 insertions(+), 26 deletions(-) diff --git a/src/Evalvisitor.cpp b/src/Evalvisitor.cpp index 4450de4..8047532 100644 --- a/src/Evalvisitor.cpp +++ b/src/Evalvisitor.cpp @@ -64,8 +64,98 @@ std::any EvalVisitor::visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) { } std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) { - // TODO - return visitChildren(ctx); + if (!ctx->augassign() && !ctx->ASSIGN(0)) + return visitTestlist(ctx->testlist(0)); + if (ctx->augassign()) { + auto left_value = visitTestlist(ctx->testlist(0)); + auto right_value = visitTestlist(ctx->testlist(1)); + DeQuate(right_value, Variables); + RawVarible *ptr_var = std::any_cast(&left_value); + std::vector *ptr_vec = + std::any_cast>(&left_value); + if (!ptr_var && !ptr_vec) + throw InterpretException( + "visitExpr_stmt: Expect left value or tuple at the left of " + "augassign"); + if (ptr_var) { + std::any old_val = DeQuate(*ptr_var, Variables); + if (ctx->augassign()->ADD_ASSIGN()) + SelfAdd(old_val, right_value); + else if (ctx->augassign()->SUB_ASSIGN()) + SelfSub(old_val, right_value); + else if (ctx->augassign()->MULT_ASSIGN()) + SelfMul(old_val, right_value); + else if (ctx->augassign()->DIV_ASSIGN()) + SelfDiv(old_val, right_value); + else if (ctx->augassign()->IDIV_ASSIGN()) + SelfDivv(old_val, right_value); + else if (ctx->augassign()->MOD_ASSIGN()) + SelfMod(old_val, right_value); + else + throw FatalError("visitExpr_stmt: Unknown operator at augassign"); + Variables.WriteVariable(ptr_var->name, old_val); + } else { + if (ptr_vec->size() != + std::any_cast>(right_value).size()) + throw InterpretException("visitExpr_stmt: Tuple size not match"); + for (int i = 0; i < ptr_vec->size(); i++) { + ptr_var = std::any_cast(&(*ptr_vec)[i]); + if (!ptr_var) + throw InterpretException( + "visitExpr_stmt: Expect left value at the left of augassign"); + std::any old_val = DeQuate(*ptr_var, Variables); + if (ctx->augassign()->ADD_ASSIGN()) + SelfAdd(old_val, + std::any_cast>(right_value)[i]); + else if (ctx->augassign()->SUB_ASSIGN()) + SelfSub(old_val, + std::any_cast>(right_value)[i]); + else if (ctx->augassign()->MULT_ASSIGN()) + SelfMul(old_val, + std::any_cast>(right_value)[i]); + else if (ctx->augassign()->DIV_ASSIGN()) + SelfDiv(old_val, + std::any_cast>(right_value)[i]); + else if (ctx->augassign()->IDIV_ASSIGN()) + SelfDivv(old_val, + std::any_cast>(right_value)[i]); + else if (ctx->augassign()->MOD_ASSIGN()) + SelfMod(old_val, + std::any_cast>(right_value)[i]); + else + throw FatalError("visitExpr_stmt: Unknown operator at augassign"); + Variables.WriteVariable(ptr_var->name, old_val); + } + } + return nullptr; + } + auto testlist_list = ctx->testlist(); + auto val = visitTestlist(testlist_list[testlist_list.size() - 1]); + val = DeQuate(val, Variables); + for (int i = testlist_list.size() - 2; i >= 0; i--) { + auto dest = visitTestlist(testlist_list[i]); + RawVarible *ptr_dest_single = std::any_cast(&dest); + std::vector *ptr_dest_tuple = + std::any_cast>(&dest); + if (ptr_dest_single) + Variables.WriteVariable(ptr_dest_single->name, val); + else if (ptr_dest_tuple) { + if (ptr_dest_tuple->size() != + std::any_cast>(val).size()) + throw InterpretException("visitExpr_stmt: Tuple size not match"); + for (int j = 0; j < ptr_dest_tuple->size(); j++) { + ptr_dest_single = std::any_cast(&(*ptr_dest_tuple)[j]); + if (!ptr_dest_single) + throw InterpretException( + "visitExpr_stmt: Expect left value at the left of assign"); + Variables.WriteVariable(ptr_dest_single->name, + std::any_cast>(val)[j]); + } + } else + throw InterpretException( + "visitExpr_stmt: Expect left value or tuple at the left of assign"); + } + return nullptr; } std::any EvalVisitor::visitAugassign(Python3Parser::AugassignContext *ctx) { @@ -112,69 +202,137 @@ std::any EvalVisitor::visitSuite(Python3Parser::SuiteContext *ctx) { return visitChildren(ctx); } std::any EvalVisitor::visitTestlist(Python3Parser::TestlistContext *ctx) { - // TODO - return visitChildren(ctx); + auto test_list = ctx->test(); + if (test_list.size() == 1) return visitTest(test_list[0]); + std::vector res; + for (auto item : test_list) { + res.push_back(visitTest(item)); + } + return res; } std::any EvalVisitor::visitTest(Python3Parser::TestContext *ctx) { - // TODO return visitChildren(ctx); } std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) { - // TODO - return visitChildren(ctx); + auto or_list = ctx->and_test(); + if (or_list.size() == 1) return visitAnd_test(or_list[0]); + for (auto or_item : or_list) { + if (Any2Bool(DeQuate(visitAnd_test(or_item), Variables))) return true; + } + return false; } std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) { - // TODO - return visitChildren(ctx); + auto not_list = ctx->not_test(); + if (not_list.size() == 1) return visitNot_test(not_list[0]); + for (auto not_item : not_list) { + if (!Any2Bool(DeQuate(visitNot_test(not_item), Variables))) return false; + } + return true; } std::any EvalVisitor::visitNot_test(Python3Parser::Not_testContext *ctx) { - // TODO - return visitChildren(ctx); + if (!ctx->NOT()) return visitComparison(ctx->comparison()); + return !Any2Bool(DeQuate(visitNot_test(ctx->not_test()), Variables)); } std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) { - // TODO - return visitChildren(ctx); + auto arith_expr_list = ctx->arith_expr(); + auto last_val = visitArith_expr(arith_expr_list[0]); + if (arith_expr_list.size() == 1) return last_val; + DeQuate(last_val, Variables); + auto op_list = ctx->comp_op(); + for (int i = 0; i < op_list.size(); i++) { + auto cur = visitArith_expr(arith_expr_list[i + 1]); + DeQuate(cur, Variables); + bool ok = false; + if (op_list[i]->GREATER_THAN()) + ok = Greater(last_val, cur); + else if (op_list[i]->LESS_THAN()) + ok = Less(last_val, cur); + else if (op_list[i]->EQUALS()) + ok = Equal(last_val, cur); + else if (op_list[i]->NOT_EQ_2()) + ok = NotEqual(last_val, cur); + else if (op_list[i]->GT_EQ()) + ok = GreaterEqual(last_val, cur); + else if (op_list[i]->LT_EQ()) + ok = LessEqual(last_val, cur); + else + throw InterpretException("visitComparison: Unknown operator"); + if (!ok) return false; + last_val = cur; + } + return true; } std::any EvalVisitor::visitComp_op(Python3Parser::Comp_opContext *ctx) { - // TODO - return visitChildren(ctx); + throw FatalError("Function visitComp_op Shouldn't be called"); } std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) { - // TODO - return visitChildren(ctx); + auto term_list = ctx->term(); + auto ans = visitTerm(term_list[0]); + if (term_list.size() == 1) return ans; + auto op_list = ctx->addorsub_op(); + DeQuate(ans, Variables); + for (int i = 0; i < op_list.size(); i++) { + auto cur = visitTerm(term_list[i + 1]); + DeQuate(cur, Variables); + if (op_list[i]->ADD()) + SelfAdd(ans, cur); + else if (op_list[i]->MINUS()) + SelfSub(ans, cur); + else + throw FatalError("visitArith_expr: Unknown operator"); + } + return ans; } std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) { - // TODO - return visitChildren(ctx); + throw FatalError("Function visitAddorsub_op Shouldn't be called"); } std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) { - // TODO - return visitChildren(ctx); + auto factor_list = ctx->factor(); + auto ans = visitFactor(factor_list[0]); + if (factor_list.size() == 1) return ans; + auto op_list = ctx->muldivmod_op(); + DeQuate(ans, Variables); + for (int i = 0; i < op_list.size(); i++) { + auto cur = visitFactor(factor_list[i + 1]); + DeQuate(cur, Variables); + if (op_list[i]->STAR()) + SelfMul(ans, cur); + else if (op_list[i]->DIV()) + SelfDiv(ans, cur); + else if (op_list[i]->IDIV()) + SelfDivv(ans, cur); + else if (op_list[i]->MOD()) + SelfMod(ans, cur); + else + throw FatalError("visitTerm: Unknown operator"); + } + return ans; } std::any EvalVisitor::visitMuldivmod_op( Python3Parser::Muldivmod_opContext *ctx) { - // TODO - return visitChildren(ctx); + throw FatalError("Function visitMuldivmod_op Shouldn't be called"); } std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) { - // TODO - return visitChildren(ctx); + if (ctx->atom_expr()) return visitAtom_expr(ctx->atom_expr()); + std::any res = visitFactor(ctx->factor()); + res = DeQuate(res, Variables); + return res; } std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) { if (!ctx->trailer()) { auto val = visitAtom(ctx->atom()); - std::cerr << "[Log] The Atom returns : "; + std::cerr << "[Log] In func visitAtom_expr. The Atom returns : "; if (auto ptr = std::any_cast(&val)) { std::cerr << "NoneType" << std::endl; } else if (auto ptr = std::any_cast(&val)) {