Files
r8asm_rev-fork/include/r8asm/r8asm.hh
T
starcells 3f3e431d64 r8asm: say what is wrong instead of dying or lying
A typo used to end in one of three ways: std::out_of_range aborting the
process (unknown macro, unknown directive), a silent 0 (unknown name used
as an address, which quietly mis-assembles), or a silent empty tape (a
file or %include that could not be opened).  All four now go through
ast::fail(), print a line on stderr, set the error flag and make the CLI
exit with 1.  Names that are reported repeatedly are only printed once.

While here: import_file set the cell size *after* parsing, so the
%include handler read main_tree.CELL_SIZE before it had ever been set and
handed 0 to included files.  It worked by accident because the top-level
call ran again at the end.  Moved it before the parse.

r8asm_test.cc came from the working tree (argv instead of a hard-coded
path); it now also checks the arguments and the error flag.
2026-11-05 22:49:54 +08:00

201 lines
5.1 KiB
C++

#pragma once
#include <cstddef>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
class r8asm {
using data = int16_t;
using parameter_index = uint8_t;
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 {
STRING,
OPERATOR,
MACROCALL,
ROT8,
DIRECTIVE,
PARAMETER,
BUILTIN,
LPAREN,
RPAREN,
LQUOTE,
RQUOTE,
ENDL,
};
struct token {
token_t type;
std::string value;
};
struct token_line {
line_number number;
std::vector<token> tokens;
};
struct token_stream {
std::string filename;
std::vector<token_line> lines;
const std::set<std::string> raw_rot8_ins = {"stp", "btp", "ror", "flb",
"biz", "rnz", "out", "inp"};
token_stream(const std::string &filename) {
this->filename = filename;
std::ifstream file(filename);
if (!file.is_open()) {
ok = false;
return;
}
std::stringstream buf;
buf << file.rdbuf();
lines = lex(buf.str());
}
std::vector<token_line> lex(const std::string &char_stream);
bool ok = true; // false when the file could not be read
};
enum class ast_node_t {
CONSTANT,
PARAMETER,
VARIABLE,
OPERATOR,
BUILTIN,
MACROCALL,
REPEAT,
ROT8,
CODEBLOCK,
STRING,
};
struct ast_node {
ast_node_t type;
std::string value;
std::vector<ast_node> children;
};
class ast {
public:
ast_node root = {r8asm::ast_node_t::CODEBLOCK, "", {}};
size_t CELL_SIZE;
// I know template class is the most elegant solution of CELL_SIZE
// but I can't be bother to add that.
// The assembler has no exceptions: anything that cannot be assembled
// sets this flag and says why on stderr.
bool error = false;
void fail(const std::string &message) {
std::cerr << "r8asm: " << message << std::endl;
error = true;
}
private:
addr dataptr = 0;
std::vector<std::map<std::string, general_data>> scopes;
std::map<std::string, ast_node> macros;
std::set<std::string> reported; // keep a typo from being printed n times
enum class builtin_t {
ANCHOR,
TP,
XOR,
LOOP,
ENDLOOP,
VAR,
};
const std::map<std::string, builtin_t> builtin_map = {
{"builtin_anchor", builtin_t::ANCHOR},
{"builtin_tp", builtin_t::TP},
{"builtin_xor", builtin_t::XOR},
{"builtin_loop", builtin_t::LOOP},
{"builtin_endloop", builtin_t::ENDLOOP},
{"builtin_var", builtin_t::VAR},
};
enum class rot8_t {
STP, // Step Tape Pointer,'>'
BTP, // Back Tape Pointer,'<'
ROR, // ROtate Right,'-'
FLB, // Flip Last Bit,'+'
BIZ, // Branch If Zero,'['
RNZ, // Return Not Zero,']'
OUT, // OUTput byte,'.'
INP, // INPut byte,','
};
const std::map<std::string, rot8_t> 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},
{"rot8_out", rot8_t::OUT}, {"rot8_inp", rot8_t::INP},
};
general_data expand_node_to_data(const ast_node &node);
std::string expand_node_to_string(const ast_node &node);
public:
enum class operator_t {
ADD,
SUB,
MUL,
DIV,
XOR,
AND,
OR,
NOT,
};
const std::map<std::string, operator_t> 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},
};
const std::map<operator_t, precedence_t> op_precedence_map = {
{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 &macro_name, const ast_node &node);
void set_cell_size(size_t cell_size);
};
ast main_tree;
enum class directive_t {
MACRO,
ENDMACRO,
REP,
ENDREP,
INCLUDE,
};
std::map<std::string, directive_t> directive_keywords = {
{"macro", directive_t::MACRO},
{"endmacro", directive_t::ENDMACRO},
{"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);
public:
std::string export_rot8();
bool import_file(const std::string &filename, size_t cell_size);
// True once anything (a missing file, an unknown name, ...) has failed.
bool failed() const { return main_tree.error; }
};