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

upd: remove unnecessary std::move

Browse Source
This commit is contained in:
ZhuangYumin
2023-11-13 10:13:37 +08:00
parent 90239c1cf8
commit afde665371
3 changed files with 130 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
src/Evalvisitor.cpp
View File

@ -12,14 +12,14 @@ VariableContainer Variables;
FucntionContainer Functions; FucntionContainer Functions;
std::any EvalVisitor::visitFile_input(Python3Parser::File_inputContext *ctx) { std::any EvalVisitor::visitFile_input(Python3Parser::File_inputContext *ctx) {
return std::move(visitChildren(ctx)); return visitChildren(ctx);
} }
std::any EvalVisitor::visitFuncdef(Python3Parser::FuncdefContext *ctx) { std::any EvalVisitor::visitFuncdef(Python3Parser::FuncdefContext *ctx) {
std::vector<ParaArguItemType> paraVec = std::vector<ParaArguItemType> paraVec =
std::any_cast<std::vector<ParaArguItemType>>( std::any_cast<std::vector<ParaArguItemType>>(
visitParameters(ctx->parameters())); visitParameters(ctx->parameters()));
std::string name = std::move(ctx->NAME()->getText()); std::string name = ctx->NAME()->getText();
Functions.AddFunction(name, FunctionItem(ctx->suite(), paraVec)); Functions.AddFunction(name, FunctionItem(ctx->suite(), paraVec));
return NoneType(); return NoneType();
} }
@ -28,13 +28,13 @@ std::any EvalVisitor::visitParameters(Python3Parser::ParametersContext *ctx) {
if (!ctx->typedargslist()) if (!ctx->typedargslist())
return std::vector<ParaArguItemType>(); return std::vector<ParaArguItemType>();
else else
return std::move(visitTypedargslist(ctx->typedargslist())); return visitTypedargslist(ctx->typedargslist());
} }
std::any EvalVisitor::visitTypedargslist( std::any EvalVisitor::visitTypedargslist(
Python3Parser::TypedargslistContext *ctx) { Python3Parser::TypedargslistContext *ctx) {
const auto &tfpdef_list = ctx->tfpdef(); auto tfpdef_list = ctx->tfpdef();
const auto &default_value_list = ctx->test(); auto default_value_list = ctx->test();
const int lenght_delta = tfpdef_list.size() - default_value_list.size(); const int lenght_delta = tfpdef_list.size() - default_value_list.size();
std::vector<ParaArguItemType> res; std::vector<ParaArguItemType> res;
res.reserve(tfpdef_list.size()); res.reserve(tfpdef_list.size());
@ -44,37 +44,36 @@ std::any EvalVisitor::visitTypedargslist(
res.emplace_back(tfpdef_list[i]->NAME()->getText(), res.emplace_back(tfpdef_list[i]->NAME()->getText(),
DeQuate(visitTest(default_value_list[i - lenght_delta]), DeQuate(visitTest(default_value_list[i - lenght_delta]),
Variables)); Variables));
return std::move(res); return res;
} }
std::any EvalVisitor::visitTfpdef(Python3Parser::TfpdefContext *ctx) { std::any EvalVisitor::visitTfpdef(Python3Parser::TfpdefContext *ctx) {
return std::move(ctx->NAME()->getText()); return ctx->NAME()->getText();
} }
std::any EvalVisitor::visitStmt(Python3Parser::StmtContext *ctx) { std::any EvalVisitor::visitStmt(Python3Parser::StmtContext *ctx) {
if (ctx->compound_stmt()) if (ctx->compound_stmt()) return visitCompound_stmt(ctx->compound_stmt());
return std::move(visitCompound_stmt(ctx->compound_stmt())); return visitSimple_stmt(ctx->simple_stmt());
return std::move(visitSimple_stmt(ctx->simple_stmt()));
} }
std::any EvalVisitor::visitSimple_stmt(Python3Parser::Simple_stmtContext *ctx) { std::any EvalVisitor::visitSimple_stmt(Python3Parser::Simple_stmtContext *ctx) {
return std::move(visitSmall_stmt(ctx->small_stmt())); return visitSmall_stmt(ctx->small_stmt());
} }
std::any EvalVisitor::visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) { std::any EvalVisitor::visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) {
if (ctx->expr_stmt()) if (ctx->expr_stmt())
return std::move(visitExpr_stmt(ctx->expr_stmt())); return visitExpr_stmt(ctx->expr_stmt());
else else
return std::move(visitFlow_stmt(ctx->flow_stmt())); return visitFlow_stmt(ctx->flow_stmt());
} }
std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) { std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
if (!ctx->augassign() && !ctx->ASSIGN(0)) if (!ctx->augassign() && !ctx->ASSIGN(0))
return std::move(visitTestlist(ctx->testlist(0))); return visitTestlist(ctx->testlist(0));
if (ctx->augassign()) { if (ctx->augassign()) {
auto left_value = std::move(visitTestlist(ctx->testlist(0))); auto left_value = visitTestlist(ctx->testlist(0));
auto right_value = std::move(visitTestlist(ctx->testlist(1))); auto right_value = visitTestlist(ctx->testlist(1));
right_value = std::move(DeQuate(right_value, Variables)); right_value = DeQuate(right_value, Variables);
RawVarible *ptr_var = std::any_cast<RawVarible>(&left_value); RawVarible *ptr_var = std::any_cast<RawVarible>(&left_value);
std::vector<std::any> *ptr_vec = std::vector<std::any> *ptr_vec =
std::any_cast<std::vector<std::any>>(&left_value); std::any_cast<std::vector<std::any>>(&left_value);
@ -84,7 +83,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
"augassign", "augassign",
1); 1);
if (ptr_var) { if (ptr_var) {
std::any old_val = std::move(DeQuate(*ptr_var, Variables)); std::any old_val = DeQuate(*ptr_var, Variables);
if (ctx->augassign()->ADD_ASSIGN()) if (ctx->augassign()->ADD_ASSIGN())
SelfAdd(old_val, right_value); SelfAdd(old_val, right_value);
else if (ctx->augassign()->SUB_ASSIGN()) else if (ctx->augassign()->SUB_ASSIGN())
@ -109,7 +108,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
if (!ptr_var) if (!ptr_var)
throw InterpretException( throw InterpretException(
"visitExpr_stmt: Expect left value at the left of augassign", 4); "visitExpr_stmt: Expect left value at the left of augassign", 4);
std::any old_val = std::move(DeQuate(*ptr_var, Variables)); std::any old_val = DeQuate(*ptr_var, Variables);
if (ctx->augassign()->ADD_ASSIGN()) if (ctx->augassign()->ADD_ASSIGN())
SelfAdd(old_val, SelfAdd(old_val,
std::any_cast<std::vector<std::any>>(right_value)[i]); std::any_cast<std::vector<std::any>>(right_value)[i]);
@ -135,11 +134,11 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
} }
return NoneType(); return NoneType();
} }
const auto &testlist_list = ctx->testlist(); auto testlist_list = ctx->testlist();
auto val = std::move(visitTestlist(testlist_list[testlist_list.size() - 1])); auto val = visitTestlist(testlist_list[testlist_list.size() - 1]);
val = std::move(DeQuate(val, Variables)); val = DeQuate(val, Variables);
for (int i = testlist_list.size() - 2; i >= 0; i--) { for (int i = testlist_list.size() - 2; i >= 0; i--) {
auto dest = std::move(visitTestlist(testlist_list[i])); auto dest = visitTestlist(testlist_list[i]);
RawVarible *ptr_dest_single = std::any_cast<RawVarible>(&dest); RawVarible *ptr_dest_single = std::any_cast<RawVarible>(&dest);
std::vector<std::any> *ptr_dest_tuple = std::vector<std::any> *ptr_dest_tuple =
std::any_cast<std::vector<std::any>>(&dest); std::any_cast<std::vector<std::any>>(&dest);
@ -170,11 +169,9 @@ std::any EvalVisitor::visitAugassign(Python3Parser::AugassignContext *ctx) {
} }
std::any EvalVisitor::visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) { std::any EvalVisitor::visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) {
if (ctx->break_stmt()) return std::move(visitBreak_stmt(ctx->break_stmt())); if (ctx->break_stmt()) return visitBreak_stmt(ctx->break_stmt());
if (ctx->continue_stmt()) if (ctx->continue_stmt()) return visitContinue_stmt(ctx->continue_stmt());
return std::move(visitContinue_stmt(ctx->continue_stmt())); if (ctx->return_stmt()) return visitReturn_stmt(ctx->return_stmt());
if (ctx->return_stmt())
return std::move(visitReturn_stmt(ctx->return_stmt()));
throw FatalError("Unknown flow statement", 10); throw FatalError("Unknown flow statement", 10);
return NoneType(); return NoneType();
} }
@ -190,49 +187,49 @@ std::any EvalVisitor::visitContinue_stmt(
std::any EvalVisitor::visitReturn_stmt(Python3Parser::Return_stmtContext *ctx) { std::any EvalVisitor::visitReturn_stmt(Python3Parser::Return_stmtContext *ctx) {
if (!ctx->testlist()) return FlowType(RETURN, std::vector<std::any>()); if (!ctx->testlist()) return FlowType(RETURN, std::vector<std::any>());
std::any val = std::move(visitTestlist(ctx->testlist())); std::any val = visitTestlist(ctx->testlist());
val = std::move(DeQuate(val, Variables)); val = DeQuate(val, Variables);
std::vector<std::any> *val_ptr = std::any_cast<std::vector<std::any>>(&val); std::vector<std::any> *val_ptr = std::any_cast<std::vector<std::any>>(&val);
if (val_ptr) return FlowType(RETURN, *val_ptr); if (val_ptr) return FlowType(RETURN, *val_ptr);
std::vector<std::any> tmp; std::vector<std::any> tmp;
tmp.push_back(val); tmp.push_back(val);
// std::cerr << "ready to send return value" << Any2String(val) << std::endl; // std::cerr << "ready to send return value" << Any2String(val) << std::endl;
return std::move(FlowType(RETURN, tmp)); return FlowType(RETURN, tmp);
} }
std::any EvalVisitor::visitCompound_stmt( std::any EvalVisitor::visitCompound_stmt(
Python3Parser::Compound_stmtContext *ctx) { Python3Parser::Compound_stmtContext *ctx) {
if (ctx->if_stmt()) return std::move(visitIf_stmt(ctx->if_stmt())); if (ctx->if_stmt()) return visitIf_stmt(ctx->if_stmt());
if (ctx->while_stmt()) return std::move(visitWhile_stmt(ctx->while_stmt())); if (ctx->while_stmt()) return visitWhile_stmt(ctx->while_stmt());
if (ctx->funcdef()) return std::move(visitFuncdef(ctx->funcdef())); if (ctx->funcdef()) return visitFuncdef(ctx->funcdef());
throw FatalError("Unknown compound statement", 11); throw FatalError("Unknown compound statement", 11);
return NoneType(); return NoneType();
} }
std::any EvalVisitor::visitIf_stmt(Python3Parser::If_stmtContext *ctx) { std::any EvalVisitor::visitIf_stmt(Python3Parser::If_stmtContext *ctx) {
const auto &test_list = ctx->test(); auto test_list = ctx->test();
const auto &suite_list = ctx->suite(); auto suite_list = ctx->suite();
if (test_list.size() - suite_list.size() != -1 && if (test_list.size() - suite_list.size() != -1 &&
test_list.size() - suite_list.size() != 0) test_list.size() - suite_list.size() != 0)
throw InterpretException("test and suite doesn't match in If_stmt", 12); throw InterpretException("test and suite doesn't match in If_stmt", 12);
for (int i = 0; i < test_list.size(); i++) for (int i = 0; i < test_list.size(); i++)
if (Any2Bool(DeQuate(visitTest(test_list[i]), Variables))) if (Any2Bool(DeQuate(visitTest(test_list[i]), Variables)))
return std::move(visitSuite(suite_list[i])); return visitSuite(suite_list[i]);
if (test_list.size() - suite_list.size() == -1) if (test_list.size() - suite_list.size() == -1)
return std::move(visitSuite(suite_list[suite_list.size() - 1])); return visitSuite(suite_list[suite_list.size() - 1]);
return NoneType(); return NoneType();
} }
std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) { std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
const auto &test = ctx->test(); auto test = ctx->test();
const auto &suite = ctx->suite(); auto suite = ctx->suite();
while (Any2Bool(DeQuate(visitTest(test), Variables))) { while (Any2Bool(DeQuate(visitTest(test), Variables))) {
auto res = std::move(visitSuite(suite)); auto res = visitSuite(suite);
FlowType *res_ptr = std::any_cast<FlowType>(&res); FlowType *res_ptr = std::any_cast<FlowType>(&res);
if (res_ptr) { if (res_ptr) {
if (res_ptr->Status == BREAK) break; if (res_ptr->Status == BREAK) break;
if (res_ptr->Status == CONTINUE) continue; if (res_ptr->Status == CONTINUE) continue;
if (res_ptr->Status == RETURN) return std::move(*res_ptr); if (res_ptr->Status == RETURN) return *res_ptr;
} }
} }
return NoneType(); return NoneType();
@ -240,31 +237,31 @@ std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
std::any EvalVisitor::visitSuite(Python3Parser::SuiteContext *ctx) { std::any EvalVisitor::visitSuite(Python3Parser::SuiteContext *ctx) {
if (ctx->simple_stmt()) return visitSimple_stmt(ctx->simple_stmt()); if (ctx->simple_stmt()) return visitSimple_stmt(ctx->simple_stmt());
const auto &stmt_list = ctx->stmt(); auto stmt_list = ctx->stmt();
std::any res; std::any res;
for (int i = 0; i < stmt_list.size(); i++) { for (int i = 0; i < stmt_list.size(); i++) {
res = std::move(visitStmt(stmt_list[i])); res = visitStmt(stmt_list[i]);
FlowType *res_ptr = std::any_cast<FlowType>(&res); FlowType *res_ptr = std::any_cast<FlowType>(&res);
if (res_ptr) return std::move(res); if (res_ptr) return res;
} }
return std::move(res); return res;
} }
std::any EvalVisitor::visitTestlist(Python3Parser::TestlistContext *ctx) { std::any EvalVisitor::visitTestlist(Python3Parser::TestlistContext *ctx) {
const auto &test_list = ctx->test(); auto test_list = ctx->test();
if (test_list.size() == 1) return std::move(visitTest(test_list[0])); if (test_list.size() == 1) return visitTest(test_list[0]);
std::vector<std::any> res; std::vector<std::any> res;
for (auto item : test_list) { for (auto item : test_list) {
res.push_back(visitTest(item)); res.push_back(visitTest(item));
} }
return std::move(res); return res;
} }
std::any EvalVisitor::visitTest(Python3Parser::TestContext *ctx) { std::any EvalVisitor::visitTest(Python3Parser::TestContext *ctx) {
return std::move(visitOr_test(ctx->or_test())); return visitOr_test(ctx->or_test());
} }
std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) { std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
const auto &or_list = ctx->and_test(); auto or_list = ctx->and_test();
if (or_list.size() == 1) return std::move(visitAnd_test(or_list[0])); if (or_list.size() == 1) return visitAnd_test(or_list[0]);
for (auto or_item : or_list) { for (auto or_item : or_list) {
if (Any2Bool(DeQuate(visitAnd_test(or_item), Variables))) return true; if (Any2Bool(DeQuate(visitAnd_test(or_item), Variables))) return true;
} }
@ -272,8 +269,8 @@ std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
} }
std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) { std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
const auto &not_list = ctx->not_test(); auto not_list = ctx->not_test();
if (not_list.size() == 1) return std::move(visitNot_test(not_list[0])); if (not_list.size() == 1) return visitNot_test(not_list[0]);
for (auto not_item : not_list) { for (auto not_item : not_list) {
if (!Any2Bool(DeQuate(visitNot_test(not_item), Variables))) return false; if (!Any2Bool(DeQuate(visitNot_test(not_item), Variables))) return false;
} }
@ -281,19 +278,19 @@ std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
} }
std::any EvalVisitor::visitNot_test(Python3Parser::Not_testContext *ctx) { std::any EvalVisitor::visitNot_test(Python3Parser::Not_testContext *ctx) {
if (!ctx->NOT()) return std::move(visitComparison(ctx->comparison())); if (!ctx->NOT()) return visitComparison(ctx->comparison());
return !Any2Bool(DeQuate(visitNot_test(ctx->not_test()), Variables)); return !Any2Bool(DeQuate(visitNot_test(ctx->not_test()), Variables));
} }
std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) { std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
const auto &arith_expr_list = ctx->arith_expr(); auto arith_expr_list = ctx->arith_expr();
auto last_val = std::move(visitArith_expr(arith_expr_list[0])); auto last_val = visitArith_expr(arith_expr_list[0]);
if (arith_expr_list.size() == 1) return std::move(last_val); if (arith_expr_list.size() == 1) return last_val;
last_val = std::move(DeQuate(last_val, Variables)); last_val = DeQuate(last_val, Variables);
auto op_list = ctx->comp_op(); auto op_list = ctx->comp_op();
for (int i = 0; i < op_list.size(); i++) { for (int i = 0; i < op_list.size(); i++) {
auto cur = std::move(visitArith_expr(arith_expr_list[i + 1])); auto cur = visitArith_expr(arith_expr_list[i + 1]);
cur = std::move(DeQuate(cur, Variables)); cur = DeQuate(cur, Variables);
bool ok = false; bool ok = false;
if (op_list[i]->GREATER_THAN()) if (op_list[i]->GREATER_THAN())
ok = Greater(last_val, cur); ok = Greater(last_val, cur);
@ -310,7 +307,7 @@ std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
else else
throw InterpretException("visitComparison: Unknown operator", 13); throw InterpretException("visitComparison: Unknown operator", 13);
if (!ok) return false; if (!ok) return false;
last_val = std::move(cur); last_val = cur;
} }
return true; return true;
} }
@ -320,14 +317,14 @@ std::any EvalVisitor::visitComp_op(Python3Parser::Comp_opContext *ctx) {
} }
std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) { std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
const auto &term_list = ctx->term(); auto term_list = ctx->term();
auto ans = std::move(visitTerm(term_list[0])); auto ans = visitTerm(term_list[0]);
if (term_list.size() == 1) return std::move(ans); if (term_list.size() == 1) return ans;
const auto &op_list = ctx->addorsub_op(); auto op_list = ctx->addorsub_op();
ans = std::move(DeQuate(ans, Variables)); ans = DeQuate(ans, Variables);
for (int i = 0; i < op_list.size(); i++) { for (int i = 0; i < op_list.size(); i++) {
auto cur = visitTerm(term_list[i + 1]); auto cur = visitTerm(term_list[i + 1]);
cur = std::move(DeQuate(cur, Variables)); cur = DeQuate(cur, Variables);
if (op_list[i]->ADD()) if (op_list[i]->ADD())
SelfAdd(ans, cur); SelfAdd(ans, cur);
else if (op_list[i]->MINUS()) else if (op_list[i]->MINUS())
@ -335,7 +332,7 @@ std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
else else
throw FatalError("visitArith_expr: Unknown operator", 15); throw FatalError("visitArith_expr: Unknown operator", 15);
} }
return std::move(ans); return ans;
} }
std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) { std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
@ -343,14 +340,14 @@ std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
} }
std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) { std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
const auto &factor_list = ctx->factor(); auto factor_list = ctx->factor();
auto ans = std::move(visitFactor(factor_list[0])); auto ans = visitFactor(factor_list[0]);
if (factor_list.size() == 1) return std::move(ans); if (factor_list.size() == 1) return ans;
auto op_list = ctx->muldivmod_op(); auto op_list = ctx->muldivmod_op();
ans = std::move(DeQuate(ans, Variables)); ans = DeQuate(ans, Variables);
for (int i = 0; i < op_list.size(); i++) { for (int i = 0; i < op_list.size(); i++) {
auto cur = std::move(visitFactor(factor_list[i + 1])); auto cur = visitFactor(factor_list[i + 1]);
cur = std::move(DeQuate(cur, Variables)); cur = DeQuate(cur, Variables);
if (op_list[i]->STAR()) if (op_list[i]->STAR())
SelfMul(ans, cur); SelfMul(ans, cur);
else if (op_list[i]->DIV()) else if (op_list[i]->DIV())
@ -362,7 +359,7 @@ std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
else else
throw FatalError("visitTerm: Unknown operator", 17); throw FatalError("visitTerm: Unknown operator", 17);
} }
return std::move(ans); return ans;
} }
std::any EvalVisitor::visitMuldivmod_op( std::any EvalVisitor::visitMuldivmod_op(
@ -371,47 +368,45 @@ std::any EvalVisitor::visitMuldivmod_op(
} }
std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) { std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) {
if (ctx->atom_expr()) return std::move(visitAtom_expr(ctx->atom_expr())); if (ctx->atom_expr()) return visitAtom_expr(ctx->atom_expr());
std::any res = std::move(visitFactor(ctx->factor())); std::any res = visitFactor(ctx->factor());
res = std::move(DeQuate(res, Variables)); res = DeQuate(res, Variables);
if (ctx->MINUS()) res = std::move(Neg(res)); if (ctx->MINUS()) res = Neg(res);
return std::move(res); return res;
} }
std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) { std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) {
if (!ctx->trailer()) return std::move(visitAtom(ctx->atom())); if (!ctx->trailer()) return visitAtom(ctx->atom());
std::string func_name = std::move(ctx->atom()->NAME()->getText()); std::string func_name = ctx->atom()->NAME()->getText();
std::vector<ParaArguItemType> args = std::vector<ParaArguItemType> args =
std::move(std::any_cast<std::vector<ParaArguItemType>>( std::any_cast<std::vector<ParaArguItemType>>(
std::move(visitTrailer(ctx->trailer())))); visitTrailer(ctx->trailer()));
return std::move(Functions.CallFunction(func_name, args, Variables)); return Functions.CallFunction(func_name, args, Variables);
} }
std::any EvalVisitor::visitTrailer(Python3Parser::TrailerContext *ctx) { std::any EvalVisitor::visitTrailer(Python3Parser::TrailerContext *ctx) {
if (!ctx->arglist()) return std::vector<ParaArguItemType>(); if (!ctx->arglist()) return std::vector<ParaArguItemType>();
return std::move(visitArglist(ctx->arglist())); return visitArglist(ctx->arglist());
} }
std::any EvalVisitor::visitArglist(Python3Parser::ArglistContext *ctx) { std::any EvalVisitor::visitArglist(Python3Parser::ArglistContext *ctx) {
const auto &argument_list = ctx->argument(); auto argument_list = ctx->argument();
std::vector<ParaArguItemType> resolved_args; std::vector<ParaArguItemType> resolved_args;
for (auto item : argument_list) { for (auto item : argument_list) {
resolved_args.push_back( resolved_args.push_back(
std::any_cast<ParaArguItemType>(visitArgument(item))); std::any_cast<ParaArguItemType>(visitArgument(item)));
} }
return std::move(resolved_args); return resolved_args;
} }
std::any EvalVisitor::visitArgument(Python3Parser::ArgumentContext *ctx) { std::any EvalVisitor::visitArgument(Python3Parser::ArgumentContext *ctx) {
const auto & arg_list = ctx->test(); auto arg_list = ctx->test();
if (arg_list.size() != 1 && arg_list.size() != 2) if (arg_list.size() != 1 && arg_list.size() != 2)
throw FatalError("visitArgument: arg_list.size()!=1&&arg_list!=2", 19); throw FatalError("visitArgument: arg_list.size()!=1&&arg_list!=2", 19);
if (arg_list.size() == 1) if (arg_list.size() == 1)
return std::move( return ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables));
ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables)));
else else
return std::move( return ParaArguItemType(arg_list[0]->getText(),
ParaArguItemType(arg_list[0]->getText(), DeQuate(visitTest(arg_list[1]), Variables));
DeQuate(visitTest(arg_list[1]), Variables)));
} }
std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) { std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
if (ctx->NONE()) if (ctx->NONE())
@ -427,9 +422,9 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
else else
return std::stod(num); return std::stod(num);
} else if (ctx->test()) } else if (ctx->test())
return std::move(visitTest(ctx->test())); return visitTest(ctx->test());
else if (ctx->NAME()) { else if (ctx->NAME()) {
return std::move(RawVarible(ctx->getText())); return RawVarible(ctx->getText());
} else { } else {
auto string_lists = ctx->STRING(); auto string_lists = ctx->STRING();
std::string res; std::string res;
@ -438,6 +433,6 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
res.append(tmp, 1, tmp.size() - 2); res.append(tmp, 1, tmp.size() - 2);
} }
// std::cerr<<"[Log] The string is : "<<res<<std::endl; // std::cerr<<"[Log] The string is : "<<res<<std::endl;
return std::move(res); return res;
} }
} }

12
src/names.cpp
View File

@ -56,7 +56,7 @@ std::any FucntionContainer::CallFunction(const std::string &name,
is_first = false; is_first = false;
double *value_ptr = std::any_cast<double>(&args[i].value); double *value_ptr = std::any_cast<double>(&args[i].value);
if (!value_ptr) { if (!value_ptr) {
std::string buf = std::move(Any2String(args[i].value)); std::string buf = Any2String(args[i].value);
std::cout << buf; std::cout << buf;
} else } else
std::cout << std::fixed << std::setprecision(6) << *value_ptr; std::cout << std::fixed << std::setprecision(6) << *value_ptr;
@ -67,10 +67,10 @@ std::any FucntionContainer::CallFunction(const std::string &name,
if (args.size() != 1) if (args.size() != 1)
throw InterpretException( throw InterpretException(
"CallFunction: str() should take exactly one argument", 23); "CallFunction: str() should take exactly one argument", 23);
return std::move(Any2String(args[0].value)); return Any2String(args[0].value);
} else if (name == "int") { } else if (name == "int") {
if (args.size() == 1) { if (args.size() == 1) {
return std::move(Any2Int(args[0].value)); return Any2Int(args[0].value);
} else { } else {
throw InterpretException( throw InterpretException(
"CallFunction: int() should take exactly one argument", 24); "CallFunction: int() should take exactly one argument", 24);
@ -128,7 +128,7 @@ std::any FucntionContainer::CallFunction(const std::string &name,
args_with_data.insert(func.para_list[i].name); args_with_data.insert(func.para_list[i].name);
} }
EvalVisitor vis; EvalVisitor vis;
std::any res = std::move(vis.visit(func.code_address)); std::any res = vis.visit(func.code_address);
Variables.DestroyFrame(); Variables.DestroyFrame();
// std::cerr << "function called " << std::endl; // std::cerr << "function called " << std::endl;
FlowType *flow = std::any_cast<FlowType>(&res); FlowType *flow = std::any_cast<FlowType>(&res);
@ -136,9 +136,9 @@ std::any FucntionContainer::CallFunction(const std::string &name,
if (flow->ReturnValueLists.size() == 0) if (flow->ReturnValueLists.size() == 0)
return NoneType(); return NoneType();
else if (flow->ReturnValueLists.size() == 1) else if (flow->ReturnValueLists.size() == 1)
return std::move(flow->ReturnValueLists[0]); return flow->ReturnValueLists[0];
else else
return std::move(flow->ReturnValueLists); return flow->ReturnValueLists;
} }
// std::cerr<<"Return value isn't FlowType"<<std::endl; // std::cerr<<"Return value isn't FlowType"<<std::endl;
return NoneType(); return NoneType();

62
src/utils.cpp
View File

@ -23,11 +23,11 @@ inline ZYM::int2048 Any2Int(const std::any &value) {
} else if (auto ptr = std::any_cast<bool>(&value)) } else if (auto ptr = std::any_cast<bool>(&value))
return std::move(ZYM::int2048((long long)(*ptr))); return std::move(ZYM::int2048((long long)(*ptr)));
else if (auto ptr = std::any_cast<std::string>(&value)) { else if (auto ptr = std::any_cast<std::string>(&value)) {
std::string str = std::move(*ptr); std::string str = *ptr;
size_t dot_position = str.find('.'); size_t dot_position = str.find('.');
if (dot_position != std::string::npos) { if (dot_position != std::string::npos) {
std::string integer_part = std::move(str.substr(0, dot_position)); std::string integer_part = str.substr(0, dot_position);
str = std::move(integer_part); str = integer_part;
} }
return std::move(ZYM::int2048(str)); return std::move(ZYM::int2048(str));
} else if (auto ptr = std::any_cast<NoneType>(&value)) } else if (auto ptr = std::any_cast<NoneType>(&value))
@ -103,7 +103,7 @@ std::string Any2String(const std::any &value) {
else else
throw FatalError("Any2String: unknown type", 31); throw FatalError("Any2String: unknown type", 31);
std::getline(buf, res); std::getline(buf, res);
return std::move(res); return res;
} }
/** /**
@ -148,14 +148,14 @@ bool Any2Bool(const std::any &value) {
std::any DeQuate(std::any val, VariableContainer &Variables) { std::any DeQuate(std::any val, VariableContainer &Variables) {
if (auto ptr = std::any_cast<std::vector<std::any>>(&val)) { if (auto ptr = std::any_cast<std::vector<std::any>>(&val)) {
for (int i = 0; i < ptr->size(); i++) for (int i = 0; i < ptr->size(); i++)
(*ptr)[i] = std::move(DeQuate((*ptr)[i], Variables)); (*ptr)[i] = DeQuate((*ptr)[i], Variables);
return std::move(*ptr); return *ptr;
} else if (auto ptr = std::any_cast<RawVarible>(&val)) { } else if (auto ptr = std::any_cast<RawVarible>(&val)) {
return std::move(Variables.ReadVariable(ptr->name)); return Variables.ReadVariable(ptr->name);
} else if (std::any_cast<double>(&val) || std::any_cast<ZYM::int2048>(&val) || } else if (std::any_cast<double>(&val) || std::any_cast<ZYM::int2048>(&val) ||
std::any_cast<bool>(&val) || std::any_cast<std::string>(&val) || std::any_cast<bool>(&val) || std::any_cast<std::string>(&val) ||
std::any_cast<NoneType>(&val)) std::any_cast<NoneType>(&val))
return std::move(val); return val;
else else
return NoneType(); return NoneType();
// throw FatalError("DeQuate: unknown type"); // throw FatalError("DeQuate: unknown type");
@ -211,8 +211,8 @@ int ConverToSameArithType(std::any &a, std::any &b,
case 1: case 1:
break; break;
case 2: case 2:
a = std::move(Any2Int(a)); a = Any2Int(a);
b = std::move(Any2Int(b)); b = Any2Int(b);
break; break;
case 3: case 3:
a = Any2Float(a); a = Any2Float(a);
@ -249,17 +249,17 @@ std::any Add(std::any a, std::any b) {
std::string *ptr_b_string = std::any_cast<std::string>(&b); std::string *ptr_b_string = std::any_cast<std::string>(&b);
if ((ptr_a_string != nullptr ? 1 : 0) + (ptr_b_string != nullptr ? 1 : 0) == if ((ptr_a_string != nullptr ? 1 : 0) + (ptr_b_string != nullptr ? 1 : 0) ==
2) 2)
return std::move((*ptr_a_string) + (*ptr_b_string)); return (*ptr_a_string) + (*ptr_b_string);
if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
return std::move(ZYM::int2048(int(*ptr_a_bool) + int(*ptr_b_bool))); return ZYM::int2048(int(*ptr_a_bool) + int(*ptr_b_bool));
else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr)) else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
return std::move((*ptr_a_int2048) + (*ptr_b_int2048)); return (*ptr_a_int2048) + (*ptr_b_int2048);
else if ((ptr_a_float != nullptr) && (ptr_b_float != nullptr)) { else if ((ptr_a_float != nullptr) && (ptr_b_float != nullptr)) {
double tmp = (*ptr_a_float) + (*ptr_b_float); double tmp = (*ptr_a_float) + (*ptr_b_float);
if (tmp > -1e-8 && tmp < 0) tmp = 0; if (tmp > -1e-8 && tmp < 0) tmp = 0;
return tmp; return tmp;
} else if ((ptr_a_string != nullptr) || (ptr_b_string != nullptr)) } else if ((ptr_a_string != nullptr) || (ptr_b_string != nullptr))
return std::move(Any2String(a) + Any2String(b)); return Any2String(a) + Any2String(b);
else else
throw FatalError("Add: Type Error", 38); throw FatalError("Add: Type Error", 38);
} }
@ -290,9 +290,9 @@ std::any Sub(std::any a, std::any b) {
double *ptr_a_float = std::any_cast<double>(&a); double *ptr_a_float = std::any_cast<double>(&a);
double *ptr_b_float = std::any_cast<double>(&b); double *ptr_b_float = std::any_cast<double>(&b);
if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
return std::move(ZYM::int2048(int(*ptr_a_bool) - int(*ptr_b_bool))); return ZYM::int2048(int(*ptr_a_bool) - int(*ptr_b_bool));
else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr)) else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
return std::move((*ptr_a_int2048) - (*ptr_b_int2048)); return (*ptr_a_int2048) - (*ptr_b_int2048);
else if ((ptr_a_float != nullptr) && (ptr_b_float != nullptr)) { else if ((ptr_a_float != nullptr) && (ptr_b_float != nullptr)) {
double tmp = (*ptr_a_float) - (*ptr_b_float); double tmp = (*ptr_a_float) - (*ptr_b_float);
if (tmp > -1e-8 && tmp < 0) tmp = 0; if (tmp > -1e-8 && tmp < 0) tmp = 0;
@ -345,20 +345,20 @@ std::any Mul(std::any a, std::any b) {
ptr_b_string = std::any_cast<std::string>(&b); ptr_b_string = std::any_cast<std::string>(&b);
} }
if (Less(b, ZYM::int2048(0))) { if (Less(b, ZYM::int2048(0))) {
b = std::move(Neg(b)); b = Neg(b);
ptr_b_bool = std::any_cast<bool>(&b); ptr_b_bool = std::any_cast<bool>(&b);
ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b); ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b);
ptr_b_float = std::any_cast<double>(&b); ptr_b_float = std::any_cast<double>(&b);
ptr_b_string = std::any_cast<std::string>(&b); ptr_b_string = std::any_cast<std::string>(&b);
} }
if (ptr_b_float != nullptr) { if (ptr_b_float != nullptr) {
b = std::move(Any2Int(*ptr_b_float)); b = Any2Int(*ptr_b_float);
ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b); ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b);
goto st; goto st;
} }
if (ptr_b_bool != nullptr) { if (ptr_b_bool != nullptr) {
if (*ptr_b_bool) { if (*ptr_b_bool) {
return std::move(*ptr_a_string); return *ptr_a_string;
} else { } else {
return std::string(""); return std::string("");
} }
@ -370,7 +370,7 @@ std::any Mul(std::any a, std::any b) {
st:; st:;
std::string res; std::string res;
for (int i = 0; i < (*ptr_b_int2048); i++) res += *ptr_a_string; for (int i = 0; i < (*ptr_b_int2048); i++) res += *ptr_a_string;
return std::move(res); return res;
} }
} }
if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
@ -449,9 +449,9 @@ std::any Divv(std::any a, std::any b) {
if (tmp > -1e-8 && tmp < 0) tmp = 0; if (tmp > -1e-8 && tmp < 0) tmp = 0;
return tmp; return tmp;
} else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr)) { } else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr)) {
return std::move((*ptr_a_int2048) / (*ptr_b_int2048)); return (*ptr_a_int2048) / (*ptr_b_int2048);
} else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) { } else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) {
return ZYM::int2048(int(*ptr_a_bool) / int(*ptr_b_bool)); return ZYM::int2048(int(*ptr_a_bool) / int(*ptr_b_bool));
} else } else
throw FatalError("Divv: Type Error", 48); throw FatalError("Divv: Type Error", 48);
} }
@ -486,40 +486,40 @@ std::any Mod(std::any a, std::any b) {
if (tmp > -1e-8 && tmp < 0) tmp = 0; if (tmp > -1e-8 && tmp < 0) tmp = 0;
return tmp; return tmp;
} else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr)) } else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
return std::move((*ptr_a_int2048) % (*ptr_b_int2048)); return (*ptr_a_int2048) % (*ptr_b_int2048);
else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
return std::move(ZYM::int2048(int(*ptr_a_bool) % int(*ptr_b_bool))); return ZYM::int2048(int(*ptr_a_bool) % int(*ptr_b_bool));
else else
throw FatalError("Mod: Type Error", 52); throw FatalError("Mod: Type Error", 52);
} }
std::any &SelfAdd(std::any &a, std::any b) { std::any &SelfAdd(std::any &a, std::any b) {
a = std::move(Add(a, b)); a = Add(a, b);
return a; return a;
} }
std::any &SelfSub(std::any &a, std::any b) { std::any &SelfSub(std::any &a, std::any b) {
a = std::move(Sub(a, b)); a = Sub(a, b);
return a; return a;
} }
std::any &SelfMul(std::any &a, std::any b) { std::any &SelfMul(std::any &a, std::any b) {
a = std::move(Mul(a, b)); a = Mul(a, b);
return a; return a;
} }
std::any &SelfDiv(std::any &a, std::any b) { std::any &SelfDiv(std::any &a, std::any b) {
a = std::move(Div(a, b)); a = Div(a, b);
return a; return a;
} }
std::any &SelfDivv(std::any &a, std::any b) { std::any &SelfDivv(std::any &a, std::any b) {
a = std::move(Divv(a, b)); a = Divv(a, b);
return a; return a;
} }
std::any &SelfMod(std::any &a, std::any b) { std::any &SelfMod(std::any &a, std::any b) {
a = std::move(Mod(a, b)); a = Mod(a, b);
return a; return a;
} }
@ -542,7 +542,7 @@ std::any Neg(std::any a) {
if (ptr_a_bool != nullptr) if (ptr_a_bool != nullptr)
return ZYM::int2048(-(*ptr_a_bool)); return ZYM::int2048(-(*ptr_a_bool));
else if (ptr_a_int2048 != nullptr) else if (ptr_a_int2048 != nullptr)
return std::move(-(*ptr_a_int2048)); return -(*ptr_a_int2048);
else if (ptr_a_float != nullptr) else if (ptr_a_float != nullptr)
return -(*ptr_a_float); return -(*ptr_a_float);
else else