ZYM/BH-Python-Interpreter-2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

upd: first version of Expr_stmt

Browse Source
This commit is contained in:
ZhuangYumin
2023-11-09 16:49:45 +08:00
parent 5852b2738f
commit 9cc802fb7a
1 changed files with 184 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
src/Evalvisitor.cpp
View File

@ -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<RawVarible>(&left_value);
std::vector<std::any> *ptr_vec =
std::any_cast<std::vector<std::any>>(&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<std::vector<std::any>>(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<RawVarible>(&(*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<std::vector<std::any>>(right_value)[i]);
else if (ctx->augassign()->SUB_ASSIGN())
SelfSub(old_val,
std::any_cast<std::vector<std::any>>(right_value)[i]);
else if (ctx->augassign()->MULT_ASSIGN())
SelfMul(old_val,
std::any_cast<std::vector<std::any>>(right_value)[i]);
else if (ctx->augassign()->DIV_ASSIGN())
SelfDiv(old_val,
std::any_cast<std::vector<std::any>>(right_value)[i]);
else if (ctx->augassign()->IDIV_ASSIGN())
SelfDivv(old_val,
std::any_cast<std::vector<std::any>>(right_value)[i]);
else if (ctx->augassign()->MOD_ASSIGN())
SelfMod(old_val,
std::any_cast<std::vector<std::any>>(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<RawVarible>(&dest);
std::vector<std::any> *ptr_dest_tuple =
std::any_cast<std::vector<std::any>>(&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<std::vector<std::any>>(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<RawVarible>(&(*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<std::vector<std::any>>(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<std::any> 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<NoneType>(&val)) {
std::cerr << "NoneType" << std::endl;
} else if (auto ptr = std::any_cast<RawVarible>(&val)) {