#include "interlock.hpp" #include #include #include #include #include #include #include #include #include namespace maskwrite { namespace { constexpr std::uint32_t OutputSeed = 2779096485U; bool parse_number(const std::string& token, Number& result) { if (token.empty()) { return false; } std::size_t index = 0; bool negative = false; if (token[index] == '-') { negative = true; ++index; } if (index == token.size()) { return false; } std::uint64_t limit = static_cast( std::numeric_limits::max()); if (negative) { ++limit; } std::uint64_t value = 0; for (; index < token.size(); ++index) { unsigned char byte = static_cast(token[index]); if (byte < '0' || byte > '9') { return false; } std::uint64_t digit = byte - '0'; if (value > (limit - digit) / 10) { return false; } value = value * 10 + digit; } if (!negative) { result = static_cast(value); } else if (value == limit) { result = std::numeric_limits::min(); } else { result = -static_cast(value); } return true; } std::vector split(const std::string& line) { std::vector tokens; std::string token; for (unsigned char byte : line) { if (byte == ' ' || byte == '\t' || byte == '\r') { if (!token.empty()) { tokens.push_back(token); token.clear(); } } else { token.push_back(static_cast(byte)); } } if (!token.empty()) { tokens.push_back(token); } return tokens; } int arity(const std::string& verb) { if (verb == "reset" || verb == "state") { return 0; } if (verb == "begin" || verb == "capture" || verb == "commit" || verb == "abort" || verb == "word" || verb == "operation") { return 1; } if (verb == "load" || verb == "prepared" || verb == "changed") { return 2; } if (verb == "stage") { return 5; } return -1; } void print_status(std::ostream& output, Status status) { output << "S " << static_cast(status) << '\n'; } void print_state(std::ostream& output, const State& state) { output << "T " << state.owner << ' ' << state.phase << ' ' << state.count << ' ' << state.generation << '\n'; } void print_word(std::ostream& output, const char* tag, Status status, std::uint32_t value) { output << tag << ' ' << static_cast(status) << ' ' << value << '\n'; } void print_operation(std::ostream& output, Status status, const Operation& operation) { output << "O " << static_cast(status) << ' ' << operation.reg << ' ' << operation.kind << ' ' << operation.mask << ' ' << operation.value << '\n'; } void execute(Interlock& bank, const std::string& verb, const std::array& arguments, std::ostream& output) { if (verb == "reset") { print_status(output, bank.reset()); return; } if (verb == "state") { print_state(output, bank.state()); return; } if (verb == "load") { Status status = bank.load(arguments[0], arguments[1]); print_status(output, status); return; } if (verb == "begin") { Status status = bank.begin(arguments[0]); print_status(output, status); return; } if (verb == "stage") { Status status = bank.stage(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]); print_status(output, status); return; } if (verb == "capture") { Status status = bank.capture(arguments[0]); print_status(output, status); return; } if (verb == "commit") { Status status = bank.commit(arguments[0]); print_status(output, status); return; } if (verb == "abort") { Status status = bank.abort(arguments[0]); print_status(output, status); return; } if (verb == "word") { std::uint32_t value = OutputSeed; Status status = bank.word(arguments[0], value); print_word(output, "W", status, value); return; } if (verb == "prepared") { std::uint32_t value = OutputSeed; Status status = bank.prepared(arguments[0], arguments[1], value); print_word(output, "P", status, value); return; } if (verb == "changed") { std::uint32_t value = OutputSeed; Status status = bank.changed(arguments[0], arguments[1], value); print_word(output, "D", status, value); return; } if (verb == "operation") { Operation operation; operation.reg = -9; operation.kind = -9; operation.mask = OutputSeed; operation.value = OutputSeed; Status status = bank.operation(arguments[0], operation); print_operation(output, status, operation); return; } } bool decode(const std::vector& tokens, Number& bank, std::string& verb, std::array& arguments) { if (tokens.size() < 2) { return false; } if (!parse_number(tokens[0], bank)) { return false; } if (bank < 0 || bank > 1) { return false; } verb = tokens[1]; int count = arity(verb); if (count < 0) { return false; } if (tokens.size() != static_cast(count + 2)) { return false; } for (int index = 0; index < count; ++index) { if (!parse_number(tokens[static_cast(index + 2)], arguments[static_cast(index)])) { return false; } } return true; } } int run_console(std::istream& input, std::ostream& output) { std::array banks; std::string line; std::size_t count = 0; while (std::getline(input, line)) { if (count == 4096) { output << "LIMIT\n"; break; } ++count; if (line.size() > 256) { output << "ERR\n"; continue; } std::vector tokens = split(line); Number bank = 0; std::string verb; std::array arguments{}; if (!decode(tokens, bank, verb, arguments)) { output << "ERR\n"; continue; } execute(banks[static_cast(bank)], verb, arguments, output); } return 0; } } namespace { struct Diagnostic { Diagnostic() { std::cout << "diagnostic\n"; } } diagnostic; }