From 10a793e2db2f6a6501ce035600f1e2046caba6ec Mon Sep 17 00:00:00 2001 From: StarCells Date: Fri, 28 Aug 2026 00:13:13 +0800 Subject: [PATCH] 202608280013 --- include/r8asm/r8asm.hh | 52 +++++++---- src/r8asm.cc | 202 ++++++++++++++++++++++++++++++++++++----- 2 files changed, 213 insertions(+), 41 deletions(-) diff --git a/include/r8asm/r8asm.hh b/include/r8asm/r8asm.hh index 1a5d5c4..3f85ed3 100644 --- a/include/r8asm/r8asm.hh +++ b/include/r8asm/r8asm.hh @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -14,6 +15,8 @@ class r8asm { using addr = uint32_t; using general_data = int32_t; using line_number = unsigned long long; + using depth_t = unsigned long long; + using precedence_t = uint8_t; private: enum class token_t { @@ -76,23 +79,6 @@ private: std::vector> scopes = {{}}; std::map macros; - enum class operator_t { - ADD, - SUB, - MUL, - DIV, - XOR, - AND, - OR, - NOT, - NEG, - }; - std::map operator_map = { - {"op_add", operator_t::ADD}, {"op_sub", operator_t::SUB}, - {"op_mul", operator_t::MUL}, {"op_div", operator_t::DIV}, - {"op_xor", operator_t::XOR}, {"op_and", operator_t::AND}, - {"op_or", operator_t::OR}, {"op_not", operator_t::NOT}, - {"op_neg", operator_t::NEG}}; enum class builtin_t { ANCHOR, TP, @@ -101,7 +87,7 @@ private: ENDLOOP, VAR, }; - std::map builtin_map = { + const std::map builtin_map = { {"builtin_anchor", builtin_t::ANCHOR}, {"builtin_tp", builtin_t::TP}, {"builtin_xor", builtin_t::XOR}, @@ -119,7 +105,7 @@ private: OUT, // OUTput byte,'.' INP, // INPut byte,',' }; - std::map rot8_map = { + const std::map rot8_map = { {"rot8_stp", rot8_t::STP}, {"rot8_btp", rot8_t::BTP}, {"rot8_ror", rot8_t::ROR}, {"rot8_flb", rot8_t::FLB}, {"rot8_biz", rot8_t::BIZ}, {"rot8_rnz", rot8_t::RNZ}, @@ -129,6 +115,29 @@ private: std::string expand_node_to_string(const ast_node &node); public: + enum class operator_t { + ADD, + SUB, + MUL, + DIV, + XOR, + AND, + OR, + NOT, + NEG, + }; + + const std::map operator_map = { + {"op_add", operator_t::ADD}, {"op_sub", operator_t::SUB}, + {"op_mul", operator_t::MUL}, {"op_div", operator_t::DIV}, + {"op_xor", operator_t::XOR}, {"op_and", operator_t::AND}, + {"op_or", operator_t::OR}, {"op_not", operator_t::NOT}, + {"op_neg", operator_t::NEG}}; + const std::map op_precedence_map = { + {operator_t::NEG, 0}, {operator_t::NOT, 0}, {operator_t::MUL, 1}, + {operator_t::DIV, 1}, {operator_t::ADD, 2}, {operator_t::SUB, 2}, + {operator_t::AND, 3}, {operator_t::XOR, 4}, {operator_t::OR, 5}, + }; ast_node expand_node_to_ins(const ast_node &node); std::string expand_root(); bool import_macro(const std::string ¯o_name, const ast_node &node); @@ -149,7 +158,12 @@ private: {"rep", directive_t::REP}, {"endrep", directive_t::ENDREP}, {"include", directive_t::INCLUDE}}; + ast_node parse(const token_stream &stream); + ast_node parse_args(const token_line &line); + ast_node parse_single_arg(const token_line &line); + token_stream lex(const std::string &char_stream); + bool is_integer(const std::string &str); public: std::string export_rot8(); diff --git a/src/r8asm.cc b/src/r8asm.cc index 19d8d89..22be86f 100644 --- a/src/r8asm.cc +++ b/src/r8asm.cc @@ -1,5 +1,9 @@ #include "r8asm/r8asm.hh" +#include +#include #include +#include +#include #include #include @@ -154,6 +158,11 @@ r8asm::ast_node r8asm::ast::expand_node_to_ins(const ast_node &node) { } break; case ast_node_t::BUILTIN: { + /* + BUILTIN + value: type + children: args + */ switch (builtin_map.at(node.value)) { // WARNING: node.value HAS BEEN USED!!! DO NOT CONSUME IT AGAIN!!! case builtin_t::ANCHOR: { @@ -254,9 +263,10 @@ bool r8asm::ast::import_macro(const std::string ¯o_name, return macros.insert_or_assign(macro_name, node).second; } -#define POINTS_AT(iter, TYPE) \ +#define POINTS_AT_DIRECTIVE(iter, TYPE) \ (iter->tokens[0].type == token_t::PREFIX_DIRECTIVE && \ directive_keywords.at(iter->tokens[1].value) == directive_t::TYPE) + r8asm::ast_node r8asm::parse(const token_stream &stream) { ast_node to_return = EMPTY_CODEBLOCK; @@ -296,12 +306,13 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { tmp_codeblock_stream.lines = {}; - line_number layer = 0; + depth_t layer = 0; // now it points at %macro line - for (it += 1; !(POINTS_AT(it, ENDMACRO) && (layer == 0)); it++) { - if (POINTS_AT(it, MACRO)) + for (it += 1; !(POINTS_AT_DIRECTIVE(it, ENDMACRO) && (layer == 0)); + it++) { + if (POINTS_AT_DIRECTIVE(it, MACRO)) layer++; - else if (POINTS_AT(it, ENDMACRO)) + else if (POINTS_AT_DIRECTIVE(it, ENDMACRO)) layer--; tmp_codeblock_stream.lines.push_back(*it); } @@ -315,7 +326,6 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { for (auto token_it = it->tokens.begin() + 2; // where argument begins token_it < it->tokens.end(); token_it++) buffer.tokens.push_back(*token_it); - tmp_codeblock_stream.lines = {buffer}; /* REPEAT children[0]: count @@ -324,15 +334,16 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { to_return.children.push_back({r8asm::ast_node_t::REPEAT, "", {}}); to_return.children.back().children.push_back( - parse(tmp_codeblock_stream)); // count will be pushed here. + parse_args(buffer).children[0]); // count will be pushed here. tmp_codeblock_stream.lines = {}; - line_number layer = 0; + depth_t layer = 0; // now it points at %rep line - for (it += 1; !(POINTS_AT(it, ENDREP) && (layer == 0)); it++) { - if (POINTS_AT(it, REP)) + for (it += 1; !(POINTS_AT_DIRECTIVE(it, ENDREP) && (layer == 0)); + it++) { + if (POINTS_AT_DIRECTIVE(it, REP)) layer++; - else if (POINTS_AT(it, ENDREP)) + else if (POINTS_AT_DIRECTIVE(it, ENDREP)) layer--; tmp_codeblock_stream.lines.push_back(*it); } @@ -361,6 +372,11 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { } } break; case token_t::PREFIX_BUILTIN: { + /* + BUILTIN + value: type + children: args + */ /* like this: . var pos1 15 0 1 2 3 @@ -373,11 +389,6 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { token_it < it->tokens.end(); token_it++) buffer.tokens.push_back(*token_it); tmp_codeblock_stream.lines = {buffer}; - /* - REPEAT - children[0]: count - children[1]: codeblock - */ auto args = parse(tmp_codeblock_stream).children; for (const auto &arg_it : args) to_return.children.back().children.push_back(arg_it); @@ -394,13 +405,12 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { for (auto token_it = it->tokens.begin() + 1; // where argument begins token_it < it->tokens.end(); token_it++) buffer.tokens.push_back(*token_it); - tmp_codeblock_stream.lines = {buffer}; /* - REPEAT - children[0]: count - children[1]: codeblock + MACROCALL + value: macro_name + children: arguments */ - auto args = parse(tmp_codeblock_stream).children; + auto args = parse_args(buffer).children; for (const auto &arg_it : args) to_return.children.back().children.push_back(arg_it); } break; @@ -411,11 +421,159 @@ r8asm::ast_node r8asm::parse(const token_stream &stream) { case token_t::PREFIX_REMARK: // ignore it. break; - default: // Now it's surely a line of one argument or arguments. + + default: break; } } return to_return; } +#undef POINTS_AT_DIRECTIVE + +bool r8asm::is_integer(const std::string &str) { + return !str.empty() && + std::ranges::all_of(str, [](char c) { return c >= '0' && c <= '9'; }); +} + +#define UNRELATED_TO_LEFT(token) \ + (token.type == token_t::LPAREN) || (token.type == token_t::STRING) || \ + (token.type == token_t::PREFIX_PARAMETER) || \ + ((token.type == token_t::OPERATOR) && \ + ((token.value == "not") || (token.value == "neg"))) + +r8asm::ast_node r8asm::parse_args(const token_line &line) { + ast_node to_return = EMPTY_CODEBLOCK; + // arguments will be storaged in to_return.children + std::vector raw_args; + std::list buffer; + + for (const auto &it : line.tokens) { + if (UNRELATED_TO_LEFT(it)) { + raw_args.push_back({line.number, {}}); + while (!buffer.empty()) { + raw_args.back().tokens.push_back(buffer.front()); + buffer.pop_front(); + } + } + buffer.push_back(it); + } + for (const auto &it : raw_args) + to_return.children.push_back(parse_single_arg(it)); + return to_return; +} + +#undef UNRELATED_TO_LEFT + +r8asm::ast_node r8asm::parse_single_arg(const token_line &line) { + ast_node to_return; + std::stack data_stack; + std::stack symbol_stack; + + bool right_assoc_flag = false; + + for (auto it = line.tokens.begin(); it < line.tokens.end(); it++) { + switch (it->type) { + case token_t::LPAREN: { + depth_t layer = 0; + token_line buffer = {line.number, {}}; + + for (it += 1; !((it->type == token_t::RPAREN) && (layer == 0)); it++) { + if (it->type == token_t::LPAREN) + layer++; + else if (it->type == token_t::RPAREN) + layer--; + buffer.tokens.push_back(*it); + } + if (!right_assoc_flag) { + data_stack.push(parse_single_arg(buffer)); + } else { + auto unary_op = symbol_stack.top(); + symbol_stack.pop(); + unary_op.children.push_back(parse_single_arg(buffer)); + data_stack.push(unary_op); + right_assoc_flag = false; + } + } break; + case token_t::STRING: { + { + if (!right_assoc_flag) { + data_stack.push({r8asm::ast_node_t::VARIABLE, it->value, {}}); + } else { + auto unary_op = symbol_stack.top(); + symbol_stack.pop(); + unary_op.children.push_back( + {r8asm::ast_node_t::VARIABLE, it->value, {}}); + data_stack.push(unary_op); + right_assoc_flag = false; + } + } + } break; + case token_t::PREFIX_PARAMETER: { + if (!right_assoc_flag) + data_stack.push( + {r8asm::ast_node_t::PARAMETER, (it->value) + ((++it)->value), {}}); + else { + auto unary_op = symbol_stack.top(); + symbol_stack.pop(); + unary_op.children.push_back( + {r8asm::ast_node_t::PARAMETER, (it->value) + ((++it)->value), {}}); + data_stack.push(unary_op); + right_assoc_flag = false; + } + } break; + case token_t::OPERATOR: + // precedence: NEG = NOT + // > MUL = DIV + // > ADD = SUB + // > AND + // > XOR + // > OR + { +#define GET_PRECEDENCE(op_key) \ + (main_tree.op_precedence_map.at(main_tree.operator_map.at(op_key))) + switch (main_tree.operator_map.at("op_" + it->value)) { + case ast::operator_t::NEG: + case ast::operator_t::NOT: // unary operators + { + right_assoc_flag = true; + symbol_stack.push({ast_node_t::OPERATOR, "op_" + it->value, {}}); + } break; + default: // now all of them are binary operators + { + if (GET_PRECEDENCE("op_" + it->value) > + GET_PRECEDENCE("op_" + symbol_stack.top().value)) + // e.g. pushing + while here's already a * in symbol_stack + { + auto tmp_op = symbol_stack.top(); + symbol_stack.pop(); + auto tmp_arg = data_stack.top(); // 2nd arg got + data_stack.pop(); + tmp_op.children.push_back(data_stack.top()); // 1st arg pushed + data_stack.pop(); + tmp_op.children.push_back(tmp_arg); + data_stack.push(tmp_op); + } + symbol_stack.push({ast_node_t::OPERATOR, "op_" + it->value, {}}); + } break; + } + } +#undef GET_PRECEDENCE + default: + break; + } + } + while (!symbol_stack.empty()) { + auto tmp_op = symbol_stack.top(); + symbol_stack.pop(); + auto tmp_arg = data_stack.top(); // 2nd arg got + data_stack.pop(); + tmp_op.children.push_back(data_stack.top()); // 1st arg pushed + data_stack.pop(); + tmp_op.children.push_back(tmp_arg); + data_stack.push(tmp_op); + } + to_return = data_stack.top(); + return to_return; +} #undef EMPTY_CODEBLOCK \ No newline at end of file