583 lines
18 KiB
C++
583 lines
18 KiB
C++
#include "r8asm/r8asm.hh"
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <iostream>
|
|
#include <list>
|
|
#include <stack>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
r8asm::general_data r8asm::ast::expand_node_to_data(const ast_node &node) {
|
|
general_data to_return = 0;
|
|
switch (node.type) {
|
|
case ast_node_t::CONSTANT:
|
|
to_return = std::stoi(node.value);
|
|
break;
|
|
case ast_node_t::PARAMETER:
|
|
to_return = scopes.back().at('%' + node.value);
|
|
break;
|
|
case ast_node_t::VARIABLE:
|
|
for (auto i = scopes.rbegin(); i != scopes.rend(); i++) {
|
|
auto tmp = i->find(node.value);
|
|
if (tmp != i->end()) {
|
|
to_return = tmp->second;
|
|
break;
|
|
}
|
|
// TODO: VAR NOT FOUND
|
|
}
|
|
break;
|
|
case ast_node_t::OPERATOR: {
|
|
switch (operator_map.at(node.value)) {
|
|
case operator_t::ADD:
|
|
to_return = expand_node_to_data(node.children[0]) +
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::SUB:
|
|
to_return = expand_node_to_data(node.children[0]) -
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::MUL:
|
|
to_return = expand_node_to_data(node.children[0]) *
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::DIV:
|
|
to_return = expand_node_to_data(node.children[0]) /
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::XOR:
|
|
to_return = expand_node_to_data(node.children[0]) ^
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::AND:
|
|
to_return = expand_node_to_data(node.children[0]) &
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::OR:
|
|
to_return = expand_node_to_data(node.children[0]) |
|
|
expand_node_to_data(node.children[1]);
|
|
break;
|
|
case operator_t::NOT:
|
|
to_return = ~expand_node_to_data(node.children[0]);
|
|
break;
|
|
case operator_t::NEG:
|
|
to_return = -expand_node_to_data(node.children[0]);
|
|
break;
|
|
default:;
|
|
break;
|
|
}
|
|
break;
|
|
};
|
|
|
|
default:
|
|
std::cerr << "ERROR: THIS NODE SHOULD NOT BE EXPANDED TO DATA!!!"
|
|
<< std::endl;
|
|
break;
|
|
}
|
|
return to_return;
|
|
}
|
|
|
|
std::string r8asm::ast::expand_node_to_string(const ast_node &node) {
|
|
return node.value;
|
|
}
|
|
|
|
#define EMPTY_CODEBLOCK \
|
|
{ \
|
|
r8asm::ast_node_t::CODEBLOCK, "", {} \
|
|
}
|
|
|
|
// TODO: FILL THE BLANK
|
|
#define ROT8_NODE(INS) \
|
|
{ \
|
|
r8asm::ast_node_t::ROT8, std::string("rot8_") + INS, {} \
|
|
}
|
|
r8asm::ast_node r8asm::ast::expand_node_to_ins(const ast_node &node) {
|
|
ast_node to_return = EMPTY_CODEBLOCK;
|
|
switch (node.type) {
|
|
case ast_node_t::ROT8: {
|
|
/*
|
|
ROT8
|
|
value: rot8_ins
|
|
*/
|
|
to_return.children = {node};
|
|
switch (rot8_map.at(node.value)) {
|
|
case rot8_t::STP:
|
|
dataptr++;
|
|
break;
|
|
case rot8_t::BTP:
|
|
dataptr--;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} break;
|
|
case ast_node_t::REPEAT: {
|
|
/*
|
|
REPEAT
|
|
children[0]: count
|
|
children[1]: codeblock
|
|
*/
|
|
for (data count = expand_node_to_data(node.children[0]); count > 0; count--)
|
|
for (const auto &i : expand_node_to_ins(node.children[1]).children)
|
|
to_return.children.push_back(i);
|
|
} break;
|
|
case ast_node_t::MACROCALL: {
|
|
/*
|
|
MACROCALL
|
|
value: macro_name
|
|
children: arguments
|
|
*/
|
|
|
|
std::map<std::string, general_data> tmp_scope = {};
|
|
for (auto i = 0; i < node.children.size(); i++)
|
|
tmp_scope.insert_or_assign('%' + std::to_string(i + 1),
|
|
// %1 in macro means children[0]
|
|
expand_node_to_data(node.children[i]));
|
|
scopes.push_back(tmp_scope);
|
|
for (const auto &it : expand_node_to_ins(macros.at(node.value)).children)
|
|
to_return.children.push_back(it);
|
|
scopes.pop_back();
|
|
|
|
} break;
|
|
|
|
case ast_node_t::CODEBLOCK: {
|
|
/*
|
|
CODEBLOCK
|
|
children: ins
|
|
*/
|
|
for (const auto &i : node.children)
|
|
for (const auto &ins : expand_node_to_ins(i).children)
|
|
to_return.children.push_back(ins);
|
|
} 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: {
|
|
/*
|
|
ANCHOR
|
|
children[0]: var_name
|
|
*/
|
|
scopes.back().insert_or_assign(expand_node_to_string(node.children[0]),
|
|
dataptr);
|
|
} break;
|
|
case builtin_t::TP: {
|
|
/*
|
|
TP
|
|
children[0]: destination
|
|
*/
|
|
addr destination = expand_node_to_data(node.children[0]);
|
|
if (destination > dataptr)
|
|
for (addr i = 0; i < destination - dataptr; i++)
|
|
to_return.children.push_back(ROT8_NODE("stp"));
|
|
else
|
|
for (addr i = 0; i < dataptr - destination; i++)
|
|
to_return.children.push_back(ROT8_NODE("btp"));
|
|
dataptr = destination;
|
|
// stp or btp might be created
|
|
// so dataptr must be updated at the same time.
|
|
} break;
|
|
case builtin_t::XOR: {
|
|
/*
|
|
XOR
|
|
children[0]: argument
|
|
WARNING: argument bigger than ((1<<CELL_SIZE)-1) will be cut off
|
|
e.g.
|
|
children[0] -> 5(0b101)
|
|
when define CELL_SIZE 2, only the last 2 bit will be noticed,
|
|
and 5 means 0b01(1) here.
|
|
|
|
then the node will be expanded like this:
|
|
|
|
flb
|
|
ror
|
|
ror
|
|
*/
|
|
data d = expand_node_to_data(node.children[0]);
|
|
for (auto i = 0; i < CELL_SIZE; i++) {
|
|
if (d & 1)
|
|
to_return.children.push_back(ROT8_NODE("flb"));
|
|
to_return.children.push_back(ROT8_NODE("ror"));
|
|
d >>= 1;
|
|
}
|
|
} break;
|
|
case builtin_t::LOOP: {
|
|
to_return.children.push_back(ROT8_NODE("stp"));
|
|
to_return.children.push_back(ROT8_NODE("biz"));
|
|
to_return.children.push_back(ROT8_NODE("btp"));
|
|
// >[<
|
|
} break;
|
|
case builtin_t::ENDLOOP: {
|
|
to_return.children.push_back(ROT8_NODE("stp"));
|
|
to_return.children.push_back(ROT8_NODE("flb"));
|
|
to_return.children.push_back(ROT8_NODE("rnz"));
|
|
to_return.children.push_back(ROT8_NODE("btp"));
|
|
// >-+]<
|
|
} break;
|
|
case builtin_t::VAR: {
|
|
/*
|
|
VAR
|
|
children[0]: var_name
|
|
children[1]: var_value
|
|
*/
|
|
scopes.back().insert_or_assign(expand_node_to_string(node.children[0]),
|
|
expand_node_to_data(node.children[1]));
|
|
} break;
|
|
default:
|
|
break;
|
|
};
|
|
} break;
|
|
default:;
|
|
break;
|
|
}
|
|
return to_return;
|
|
}
|
|
#undef ROT8_NODE
|
|
|
|
#define ROT8_BC_TO_CHAR(bc) ("><+-[].,"[static_cast<int>(bc)])
|
|
std::string r8asm::ast::expand_root() {
|
|
auto rot8_ins = expand_node_to_ins(root);
|
|
std::string rot8_tape = "";
|
|
for (const auto &i : rot8_ins.children)
|
|
rot8_tape += ROT8_BC_TO_CHAR(rot8_map.at(i.value));
|
|
return rot8_tape;
|
|
}
|
|
#undef ROT8_BC_TO_CHAR
|
|
|
|
std::string r8asm::export_rot8() { return main_tree.expand_root(); }
|
|
|
|
bool r8asm::ast::import_macro(const std::string ¯o_name,
|
|
const ast_node &node) {
|
|
return macros.insert_or_assign(macro_name, node).second;
|
|
}
|
|
|
|
#define POINTS_AT_DIRECTIVE(iter, TYPE) \
|
|
(iter->tokens[0].type == token_t::DIRECTIVE && \
|
|
directive_keywords.at(iter->tokens[0].value) == directive_t::TYPE)
|
|
|
|
r8asm::ast_node r8asm::parse(const token_stream &stream) {
|
|
|
|
ast_node to_return = EMPTY_CODEBLOCK;
|
|
token_stream tmp_codeblock_stream = {stream.filename};
|
|
/*
|
|
ast_node tmp_codeblock_node;
|
|
|
|
std::vector<ast_node> *destination = &to_return.children;
|
|
std::vector<ast_node> *last_destination = nullptr;*/
|
|
|
|
for (auto it = stream.lines.begin(); it < stream.lines.end(); it++) {
|
|
switch (it->tokens[0].type) {
|
|
case token_t::DIRECTIVE: {
|
|
/*
|
|
directive will be tokenized like this:
|
|
macro raw_add
|
|
0 1
|
|
|
|
or:
|
|
macro raw_add 2 + 4
|
|
0 1 2 3 4
|
|
(though [2] [3] [4] won't be used)
|
|
|
|
if it's a rep block:
|
|
rep 1 + 1
|
|
0 1 2 3
|
|
|
|
if it's a include line:
|
|
include filename
|
|
0 1
|
|
*/
|
|
switch (directive_keywords.at(it->tokens[0].value)) {
|
|
// match an entire operation (not a cut for arguments) first
|
|
case directive_t::MACRO: {
|
|
|
|
std::string macro_name = it->tokens[1].value;
|
|
|
|
tmp_codeblock_stream.lines = {};
|
|
|
|
depth_t layer = 0;
|
|
// now it points at %macro line
|
|
for (it += 1; !(POINTS_AT_DIRECTIVE(it, ENDMACRO) && (layer == 0));
|
|
it++) {
|
|
if (POINTS_AT_DIRECTIVE(it, MACRO))
|
|
layer++;
|
|
else if (POINTS_AT_DIRECTIVE(it, ENDMACRO))
|
|
layer--;
|
|
tmp_codeblock_stream.lines.push_back(*it);
|
|
}
|
|
// now it points at %endmacro line
|
|
main_tree.import_macro(macro_name, parse(tmp_codeblock_stream));
|
|
} break;
|
|
case directive_t::REP: {
|
|
|
|
// build subtree for argument of rep
|
|
token_line buffer = {it->number, {}};
|
|
for (auto token_it = it->tokens.begin() + 1; // where argument begins
|
|
token_it < it->tokens.end(); token_it++)
|
|
buffer.tokens.push_back(*token_it);
|
|
/*
|
|
REPEAT
|
|
children[0]: count
|
|
children[1]: codeblock
|
|
*/
|
|
|
|
to_return.children.push_back({r8asm::ast_node_t::REPEAT, "", {}});
|
|
to_return.children.back().children.push_back(
|
|
parse_single_arg(buffer)); // count will be pushed here.
|
|
tmp_codeblock_stream.lines = {};
|
|
|
|
depth_t layer = 0;
|
|
// now it points at %rep line
|
|
for (it += 1; !(POINTS_AT_DIRECTIVE(it, ENDREP) && (layer == 0));
|
|
it++) {
|
|
if (POINTS_AT_DIRECTIVE(it, REP))
|
|
layer++;
|
|
else if (POINTS_AT_DIRECTIVE(it, ENDREP))
|
|
layer--;
|
|
tmp_codeblock_stream.lines.push_back(*it);
|
|
}
|
|
// now it points at %endrep line
|
|
|
|
to_return.children.back().children.push_back(
|
|
parse(tmp_codeblock_stream)); // codeblock will be pushed here.
|
|
|
|
} break;
|
|
case directive_t::INCLUDE: {
|
|
std::string filename = "";
|
|
auto tp = it->tokens.begin() + 1;
|
|
// now tp points at the LQUOTE
|
|
|
|
for (tp += 1; tp->type != token_t::RQUOTE; tp++)
|
|
filename += tp->value;
|
|
// now tp points at RQUOTE
|
|
|
|
import_file(
|
|
filename); // TODO: check whether the file is open successfully
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
} break;
|
|
case token_t::BUILTIN: {
|
|
/*
|
|
BUILTIN
|
|
value: type
|
|
children: args
|
|
*/
|
|
/* like this:
|
|
builtin_var pos1 15
|
|
0 1 2
|
|
*/
|
|
to_return.children.push_back(
|
|
{r8asm::ast_node_t::BUILTIN, it->tokens[0].value, {}});
|
|
// build subtree for argument(s) of builtin
|
|
token_line buffer = {it->number, {}};
|
|
for (auto token_it = it->tokens.begin() + 1; // where argument begins
|
|
token_it < it->tokens.end(); token_it++)
|
|
buffer.tokens.push_back(*token_it);
|
|
auto args = parse_args(buffer).children;
|
|
for (const auto &arg_it : args)
|
|
to_return.children.back().children.push_back(
|
|
arg_it); // though all string args are treated as VARIABLE, I guess
|
|
// builtin_var will read children[0].value successfully.
|
|
} break;
|
|
case token_t::MACROCALL: {
|
|
/* like this:
|
|
raw_add 2 4 4 + 2 ( 4 + 4 ) pos1 pos1 + 2
|
|
0 1 ...
|
|
*/
|
|
to_return.children.push_back(
|
|
{r8asm::ast_node_t::MACROCALL, it->tokens[0].value, {}});
|
|
// build subtree for argument(s) of macro
|
|
token_line buffer = {it->number, {}};
|
|
for (auto token_it = it->tokens.begin() + 1; // where argument begins
|
|
token_it < it->tokens.end(); token_it++)
|
|
buffer.tokens.push_back(*token_it);
|
|
/*
|
|
MACROCALL
|
|
value: macro_name
|
|
children: arguments
|
|
*/
|
|
auto args = parse_args(buffer).children;
|
|
for (const auto &arg_it : args)
|
|
to_return.children.back().children.push_back(arg_it);
|
|
} break;
|
|
case token_t::ROT8: {
|
|
to_return.children.push_back(
|
|
{r8asm::ast_node_t::ROT8, it->tokens[0].value, {}});
|
|
} break;
|
|
case token_t::PREFIX_REMARK:
|
|
// ignore it.
|
|
break;
|
|
|
|
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(present_token) \
|
|
(it == line.tokens.begin() || \
|
|
((present_token->type == token_t::LPAREN || \
|
|
present_token->type == token_t::STRING || \
|
|
(present_token->type == token_t::OPERATOR && \
|
|
(present_token->value == "op_neg" || \
|
|
present_token->value == "op_not"))) && \
|
|
(!((present_token - 1)->type == token_t::OPERATOR || \
|
|
(present_token - 1)->type == token_t::LPAREN))))
|
|
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<token_line> raw_args;
|
|
std::list<token> buffer;
|
|
|
|
for (auto it = line.tokens.begin(); it != line.tokens.end(); it++) {
|
|
buffer.push_back(*it);
|
|
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
if (!buffer.empty()) {
|
|
raw_args.push_back({line.number, {}});
|
|
while (!buffer.empty()) {
|
|
raw_args.back().tokens.push_back(buffer.front());
|
|
buffer.pop_front();
|
|
}
|
|
}
|
|
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<ast_node> data_stack;
|
|
std::stack<ast_node> symbol_stack;
|
|
|
|
depth_t right_assoc_depth = 0;
|
|
|
|
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);
|
|
}
|
|
data_stack.push(parse_single_arg(buffer));
|
|
while (right_assoc_depth) {
|
|
auto unary_op = symbol_stack.top();
|
|
symbol_stack.pop();
|
|
unary_op.children.push_back(data_stack.top());
|
|
data_stack.pop();
|
|
data_stack.push(unary_op);
|
|
right_assoc_depth--;
|
|
}
|
|
} break;
|
|
case token_t::STRING: {
|
|
{
|
|
if (is_integer(it->value))
|
|
data_stack.push({r8asm::ast_node_t::CONSTANT, it->value, {}});
|
|
else
|
|
data_stack.push({r8asm::ast_node_t::VARIABLE, it->value, {}});
|
|
}
|
|
while (right_assoc_depth) {
|
|
auto unary_op = symbol_stack.top();
|
|
symbol_stack.pop();
|
|
unary_op.children.push_back(data_stack.top());
|
|
data_stack.pop();
|
|
data_stack.push(unary_op);
|
|
right_assoc_depth--;
|
|
}
|
|
} break;
|
|
case token_t::PARAMETER: {
|
|
data_stack.push({r8asm::ast_node_t::PARAMETER, (it->value), {}});
|
|
while (right_assoc_depth) {
|
|
auto unary_op = symbol_stack.top();
|
|
symbol_stack.pop();
|
|
unary_op.children.push_back(data_stack.top());
|
|
data_stack.pop();
|
|
data_stack.push(unary_op);
|
|
right_assoc_depth--;
|
|
}
|
|
} 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(it->value)) {
|
|
case ast::operator_t::NEG:
|
|
case ast::operator_t::NOT: // unary operators
|
|
{
|
|
right_assoc_depth++;
|
|
symbol_stack.push({ast_node_t::OPERATOR, it->value, {}});
|
|
} break;
|
|
default: // now all of them are binary operators
|
|
{
|
|
while ((!symbol_stack.empty()) &&
|
|
GET_PRECEDENCE(it->value) >=
|
|
GET_PRECEDENCE(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, 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 |