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;
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::vector<ParaArguItemType> paraVec =
std::any_cast<std::vector<ParaArguItemType>>(
visitParameters(ctx->parameters()));
std::string name = std::move(ctx->NAME()->getText());
std::string name = ctx->NAME()->getText();
Functions.AddFunction(name, FunctionItem(ctx->suite(), paraVec));
return NoneType();
}
@ -28,13 +28,13 @@ std::any EvalVisitor::visitParameters(Python3Parser::ParametersContext *ctx) {
if (!ctx->typedargslist())
return std::vector<ParaArguItemType>();
else
return std::move(visitTypedargslist(ctx->typedargslist()));
return visitTypedargslist(ctx->typedargslist());
}
std::any EvalVisitor::visitTypedargslist(
Python3Parser::TypedargslistContext *ctx) {
const auto &tfpdef_list = ctx->tfpdef();
const auto &default_value_list = ctx->test();
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());
@ -44,37 +44,36 @@ std::any EvalVisitor::visitTypedargslist(
res.emplace_back(tfpdef_list[i]->NAME()->getText(),
DeQuate(visitTest(default_value_list[i - lenght_delta]),
Variables));
return std::move(res);
return res;
}
std::any EvalVisitor::visitTfpdef(Python3Parser::TfpdefContext *ctx) {
return std::move(ctx->NAME()->getText());
return ctx->NAME()->getText();
}
std::any EvalVisitor::visitStmt(Python3Parser::StmtContext *ctx) {
if (ctx->compound_stmt())
return std::move(visitCompound_stmt(ctx->compound_stmt()));
return std::move(visitSimple_stmt(ctx->simple_stmt()));
if (ctx->compound_stmt()) return visitCompound_stmt(ctx->compound_stmt());
return visitSimple_stmt(ctx->simple_stmt());
}
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) {
if (ctx->expr_stmt())
return std::move(visitExpr_stmt(ctx->expr_stmt()));
return visitExpr_stmt(ctx->expr_stmt());
else
return std::move(visitFlow_stmt(ctx->flow_stmt()));
return visitFlow_stmt(ctx->flow_stmt());
}
std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
if (!ctx->augassign() && !ctx->ASSIGN(0))
return std::move(visitTestlist(ctx->testlist(0)));
return visitTestlist(ctx->testlist(0));
if (ctx->augassign()) {
auto left_value = std::move(visitTestlist(ctx->testlist(0)));
auto right_value = std::move(visitTestlist(ctx->testlist(1)));
right_value = std::move(DeQuate(right_value, Variables));
auto left_value = visitTestlist(ctx->testlist(0));
auto right_value = visitTestlist(ctx->testlist(1));
right_value = 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);
@ -84,7 +83,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
"augassign",
1);
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())
SelfAdd(old_val, right_value);
else if (ctx->augassign()->SUB_ASSIGN())
@ -109,7 +108,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
if (!ptr_var)
throw InterpretException(
"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())
SelfAdd(old_val,
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();
}
const auto &testlist_list = ctx->testlist();
auto val = std::move(visitTestlist(testlist_list[testlist_list.size() - 1]));
val = std::move(DeQuate(val, Variables));
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 = std::move(visitTestlist(testlist_list[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);
@ -170,11 +169,9 @@ std::any EvalVisitor::visitAugassign(Python3Parser::AugassignContext *ctx) {
}
std::any EvalVisitor::visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) {
if (ctx->break_stmt()) return std::move(visitBreak_stmt(ctx->break_stmt()));
if (ctx->continue_stmt())
return std::move(visitContinue_stmt(ctx->continue_stmt()));
if (ctx->return_stmt())
return std::move(visitReturn_stmt(ctx->return_stmt()));
if (ctx->break_stmt()) return visitBreak_stmt(ctx->break_stmt());
if (ctx->continue_stmt()) return visitContinue_stmt(ctx->continue_stmt());
if (ctx->return_stmt()) return visitReturn_stmt(ctx->return_stmt());
throw FatalError("Unknown flow statement", 10);
return NoneType();
}
@ -190,49 +187,49 @@ std::any EvalVisitor::visitContinue_stmt(
std::any EvalVisitor::visitReturn_stmt(Python3Parser::Return_stmtContext *ctx) {
if (!ctx->testlist()) return FlowType(RETURN, std::vector<std::any>());
std::any val = std::move(visitTestlist(ctx->testlist()));
val = std::move(DeQuate(val, Variables));
std::any val = visitTestlist(ctx->testlist());
val = DeQuate(val, Variables);
std::vector<std::any> *val_ptr = std::any_cast<std::vector<std::any>>(&val);
if (val_ptr) return FlowType(RETURN, *val_ptr);
std::vector<std::any> tmp;
tmp.push_back(val);
// 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(
Python3Parser::Compound_stmtContext *ctx) {
if (ctx->if_stmt()) return std::move(visitIf_stmt(ctx->if_stmt()));
if (ctx->while_stmt()) return std::move(visitWhile_stmt(ctx->while_stmt()));
if (ctx->funcdef()) return std::move(visitFuncdef(ctx->funcdef()));
if (ctx->if_stmt()) return visitIf_stmt(ctx->if_stmt());
if (ctx->while_stmt()) return visitWhile_stmt(ctx->while_stmt());
if (ctx->funcdef()) return visitFuncdef(ctx->funcdef());
throw FatalError("Unknown compound statement", 11);
return NoneType();
}
std::any EvalVisitor::visitIf_stmt(Python3Parser::If_stmtContext *ctx) {
const auto &test_list = ctx->test();
const auto &suite_list = ctx->suite();
auto test_list = ctx->test();
auto suite_list = ctx->suite();
if (test_list.size() - suite_list.size() != -1 &&
test_list.size() - suite_list.size() != 0)
throw InterpretException("test and suite doesn't match in If_stmt", 12);
for (int i = 0; i < test_list.size(); i++)
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)
return std::move(visitSuite(suite_list[suite_list.size() - 1]));
return visitSuite(suite_list[suite_list.size() - 1]);
return NoneType();
}
std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
const auto &test = ctx->test();
const auto &suite = ctx->suite();
auto test = ctx->test();
auto suite = ctx->suite();
while (Any2Bool(DeQuate(visitTest(test), Variables))) {
auto res = std::move(visitSuite(suite));
auto res = visitSuite(suite);
FlowType *res_ptr = std::any_cast<FlowType>(&res);
if (res_ptr) {
if (res_ptr->Status == BREAK) break;
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();
@ -240,31 +237,31 @@ std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
std::any EvalVisitor::visitSuite(Python3Parser::SuiteContext *ctx) {
if (ctx->simple_stmt()) return visitSimple_stmt(ctx->simple_stmt());
const auto &stmt_list = ctx->stmt();
auto stmt_list = ctx->stmt();
std::any res;
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);
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) {
const auto &test_list = ctx->test();
if (test_list.size() == 1) return std::move(visitTest(test_list[0]));
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 std::move(res);
return res;
}
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) {
const auto &or_list = ctx->and_test();
if (or_list.size() == 1) return std::move(visitAnd_test(or_list[0]));
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;
}
@ -272,8 +269,8 @@ std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
}
std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
const auto &not_list = ctx->not_test();
if (not_list.size() == 1) return std::move(visitNot_test(not_list[0]));
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;
}
@ -281,19 +278,19 @@ std::any EvalVisitor::visitAnd_test(Python3Parser::And_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));
}
std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
const auto &arith_expr_list = ctx->arith_expr();
auto last_val = std::move(visitArith_expr(arith_expr_list[0]));
if (arith_expr_list.size() == 1) return std::move(last_val);
last_val = std::move(DeQuate(last_val, Variables));
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;
last_val = DeQuate(last_val, Variables);
auto op_list = ctx->comp_op();
for (int i = 0; i < op_list.size(); i++) {
auto cur = std::move(visitArith_expr(arith_expr_list[i + 1]));
cur = std::move(DeQuate(cur, Variables));
auto cur = visitArith_expr(arith_expr_list[i + 1]);
cur = DeQuate(cur, Variables);
bool ok = false;
if (op_list[i]->GREATER_THAN())
ok = Greater(last_val, cur);
@ -310,7 +307,7 @@ std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
else
throw InterpretException("visitComparison: Unknown operator", 13);
if (!ok) return false;
last_val = std::move(cur);
last_val = cur;
}
return true;
}
@ -320,14 +317,14 @@ std::any EvalVisitor::visitComp_op(Python3Parser::Comp_opContext *ctx) {
}
std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
const auto &term_list = ctx->term();
auto ans = std::move(visitTerm(term_list[0]));
if (term_list.size() == 1) return std::move(ans);
const auto &op_list = ctx->addorsub_op();
ans = std::move(DeQuate(ans, Variables));
auto term_list = ctx->term();
auto ans = visitTerm(term_list[0]);
if (term_list.size() == 1) return ans;
auto op_list = ctx->addorsub_op();
ans = DeQuate(ans, Variables);
for (int i = 0; i < op_list.size(); i++) {
auto cur = visitTerm(term_list[i + 1]);
cur = std::move(DeQuate(cur, Variables));
cur = DeQuate(cur, Variables);
if (op_list[i]->ADD())
SelfAdd(ans, cur);
else if (op_list[i]->MINUS())
@ -335,7 +332,7 @@ std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
else
throw FatalError("visitArith_expr: Unknown operator", 15);
}
return std::move(ans);
return ans;
}
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) {
const auto &factor_list = ctx->factor();
auto ans = std::move(visitFactor(factor_list[0]));
if (factor_list.size() == 1) return std::move(ans);
auto factor_list = ctx->factor();
auto ans = visitFactor(factor_list[0]);
if (factor_list.size() == 1) return ans;
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++) {
auto cur = std::move(visitFactor(factor_list[i + 1]));
cur = std::move(DeQuate(cur, Variables));
auto cur = visitFactor(factor_list[i + 1]);
cur = DeQuate(cur, Variables);
if (op_list[i]->STAR())
SelfMul(ans, cur);
else if (op_list[i]->DIV())
@ -362,7 +359,7 @@ std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
else
throw FatalError("visitTerm: Unknown operator", 17);
}
return std::move(ans);
return ans;
}
std::any EvalVisitor::visitMuldivmod_op(
@ -371,47 +368,45 @@ std::any EvalVisitor::visitMuldivmod_op(
}
std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) {
if (ctx->atom_expr()) return std::move(visitAtom_expr(ctx->atom_expr()));
std::any res = std::move(visitFactor(ctx->factor()));
res = std::move(DeQuate(res, Variables));
if (ctx->MINUS()) res = std::move(Neg(res));
return std::move(res);
if (ctx->atom_expr()) return visitAtom_expr(ctx->atom_expr());
std::any res = visitFactor(ctx->factor());
res = DeQuate(res, Variables);
if (ctx->MINUS()) res = Neg(res);
return res;
}
std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) {
if (!ctx->trailer()) return std::move(visitAtom(ctx->atom()));
std::string func_name = std::move(ctx->atom()->NAME()->getText());
if (!ctx->trailer()) return visitAtom(ctx->atom());
std::string func_name = ctx->atom()->NAME()->getText();
std::vector<ParaArguItemType> args =
std::move(std::any_cast<std::vector<ParaArguItemType>>(
std::move(visitTrailer(ctx->trailer()))));
return std::move(Functions.CallFunction(func_name, args, Variables));
std::any_cast<std::vector<ParaArguItemType>>(
visitTrailer(ctx->trailer()));
return Functions.CallFunction(func_name, args, Variables);
}
std::any EvalVisitor::visitTrailer(Python3Parser::TrailerContext *ctx) {
if (!ctx->arglist()) return std::vector<ParaArguItemType>();
return std::move(visitArglist(ctx->arglist()));
return visitArglist(ctx->arglist());
}
std::any EvalVisitor::visitArglist(Python3Parser::ArglistContext *ctx) {
const auto &argument_list = ctx->argument();
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 std::move(resolved_args);
return resolved_args;
}
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)
throw FatalError("visitArgument: arg_list.size()!=1&&arg_list!=2", 19);
if (arg_list.size() == 1)
return std::move(
ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables)));
return ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables));
else
return std::move(
ParaArguItemType(arg_list[0]->getText(),
DeQuate(visitTest(arg_list[1]), Variables)));
return ParaArguItemType(arg_list[0]->getText(),
DeQuate(visitTest(arg_list[1]), Variables));
}
std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
if (ctx->NONE())
@ -427,9 +422,9 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
else
return std::stod(num);
} else if (ctx->test())
return std::move(visitTest(ctx->test()));
return visitTest(ctx->test());
else if (ctx->NAME()) {
return std::move(RawVarible(ctx->getText()));
return RawVarible(ctx->getText());
} else {
auto string_lists = ctx->STRING();
std::string res;
@ -438,6 +433,6 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
res.append(tmp, 1, tmp.size() - 2);
}
// 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;
double *value_ptr = std::any_cast<double>(&args[i].value);
if (!value_ptr) {
std::string buf = std::move(Any2String(args[i].value));
std::string buf = Any2String(args[i].value);
std::cout << buf;
} else
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)
throw InterpretException(
"CallFunction: str() should take exactly one argument", 23);
return std::move(Any2String(args[0].value));
return Any2String(args[0].value);
} else if (name == "int") {
if (args.size() == 1) {
return std::move(Any2Int(args[0].value));
return Any2Int(args[0].value);
} else {
throw InterpretException(
"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);
}
EvalVisitor vis;
std::any res = std::move(vis.visit(func.code_address));
std::any res = vis.visit(func.code_address);
Variables.DestroyFrame();
// std::cerr << "function called " << std::endl;
FlowType *flow = std::any_cast<FlowType>(&res);
@ -136,9 +136,9 @@ std::any FucntionContainer::CallFunction(const std::string &name,
if (flow->ReturnValueLists.size() == 0)
return NoneType();
else if (flow->ReturnValueLists.size() == 1)
return std::move(flow->ReturnValueLists[0]);
return flow->ReturnValueLists[0];
else
return std::move(flow->ReturnValueLists);
return flow->ReturnValueLists;
}
// std::cerr<<"Return value isn't FlowType"<<std::endl;
return NoneType();

60
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))
return std::move(ZYM::int2048((long long)(*ptr)));
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('.');
if (dot_position != std::string::npos) {
std::string integer_part = std::move(str.substr(0, dot_position));
str = std::move(integer_part);
std::string integer_part = str.substr(0, dot_position);
str = integer_part;
}
return std::move(ZYM::int2048(str));
} else if (auto ptr = std::any_cast<NoneType>(&value))
@ -103,7 +103,7 @@ std::string Any2String(const std::any &value) {
else
throw FatalError("Any2String: unknown type", 31);
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) {
if (auto ptr = std::any_cast<std::vector<std::any>>(&val)) {
for (int i = 0; i < ptr->size(); i++)
(*ptr)[i] = std::move(DeQuate((*ptr)[i], Variables));
return std::move(*ptr);
(*ptr)[i] = DeQuate((*ptr)[i], Variables);
return *ptr;
} 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) ||
std::any_cast<bool>(&val) || std::any_cast<std::string>(&val) ||
std::any_cast<NoneType>(&val))
return std::move(val);
return val;
else
return NoneType();
// throw FatalError("DeQuate: unknown type");
@ -211,8 +211,8 @@ int ConverToSameArithType(std::any &a, std::any &b,
case 1:
break;
case 2:
a = std::move(Any2Int(a));
b = std::move(Any2Int(b));
a = Any2Int(a);
b = Any2Int(b);
break;
case 3:
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);
if ((ptr_a_string != nullptr ? 1 : 0) + (ptr_b_string != nullptr ? 1 : 0) ==
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))
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))
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)) {
double tmp = (*ptr_a_float) + (*ptr_b_float);
if (tmp > -1e-8 && tmp < 0) tmp = 0;
return tmp;
} else if ((ptr_a_string != nullptr) || (ptr_b_string != nullptr))
return std::move(Any2String(a) + Any2String(b));
return Any2String(a) + Any2String(b);
else
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_b_float = std::any_cast<double>(&b);
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))
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)) {
double tmp = (*ptr_a_float) - (*ptr_b_float);
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);
}
if (Less(b, ZYM::int2048(0))) {
b = std::move(Neg(b));
b = Neg(b);
ptr_b_bool = std::any_cast<bool>(&b);
ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b);
ptr_b_float = std::any_cast<double>(&b);
ptr_b_string = std::any_cast<std::string>(&b);
}
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);
goto st;
}
if (ptr_b_bool != nullptr) {
if (*ptr_b_bool) {
return std::move(*ptr_a_string);
return *ptr_a_string;
} else {
return std::string("");
}
@ -370,7 +370,7 @@ std::any Mul(std::any a, std::any b) {
st:;
std::string res;
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))
@ -449,7 +449,7 @@ std::any Divv(std::any a, std::any b) {
if (tmp > -1e-8 && tmp < 0) tmp = 0;
return tmp;
} 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)) {
return ZYM::int2048(int(*ptr_a_bool) / int(*ptr_b_bool));
} else
@ -486,40 +486,40 @@ std::any Mod(std::any a, std::any b) {
if (tmp > -1e-8 && tmp < 0) tmp = 0;
return tmp;
} 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))
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
throw FatalError("Mod: Type Error", 52);
}
std::any &SelfAdd(std::any &a, std::any b) {
a = std::move(Add(a, b));
a = Add(a, b);
return a;
}
std::any &SelfSub(std::any &a, std::any b) {
a = std::move(Sub(a, b));
a = Sub(a, b);
return a;
}
std::any &SelfMul(std::any &a, std::any b) {
a = std::move(Mul(a, b));
a = Mul(a, b);
return a;
}
std::any &SelfDiv(std::any &a, std::any b) {
a = std::move(Div(a, b));
a = Div(a, b);
return a;
}
std::any &SelfDivv(std::any &a, std::any b) {
a = std::move(Divv(a, b));
a = Divv(a, b);
return a;
}
std::any &SelfMod(std::any &a, std::any b) {
a = std::move(Mod(a, b));
a = Mod(a, b);
return a;
}
@ -542,7 +542,7 @@ std::any Neg(std::any a) {
if (ptr_a_bool != nullptr)
return ZYM::int2048(-(*ptr_a_bool));
else if (ptr_a_int2048 != nullptr)
return std::move(-(*ptr_a_int2048));
return -(*ptr_a_int2048);
else if (ptr_a_float != nullptr)
return -(*ptr_a_float);
else