Files
R8Forge/tests/byte_op_test.cc
T
dsh 026ad82455 The nc macros take a real carry in, they do not seed it themselves
They used to write the carry cell themselves -- set_0 inside clb_add_nc, set_1
inside clb_inc_nc / clb_neg_nc / clb_sub_nc -- which made the parameter a lie: a
cell the caller passes and the callee overwrites is not a carry input, it is a
scratch cell wearing a carry's name.  It also ruled out the thing a carry is for:
multi byte arithmetic.  The carry out of the low byte could not be handed to the
high byte, because the high byte's call would zero (or one) it first.

Now the macros only read it, and the caller decides:

    clb_add_nc A B S Ci     S = A + B + Ci      Ci = 0 plain add, or chained
    clb_inc_nc A S Ci       S = A + Ci          Ci = 1 gives A + 1
    clb_neg_nc A S Ci       S = ~A + Ci         Ci = 1 gives -A, Ci = 0 gives ~A
    clb_sub_nc A B S Ci     S = A + ~B + Ci     Ci = 1 gives A - B, Ci = 0 A-B-1

which also turns the negate into two operations for free: two's complement
negation at Ci=1 and the ones' complement (~A) at Ci=0.  The second one has its
own driver and test now (drv/raw_not_nc_byte.r8asm).

The drivers set the bit explicitly before the call, which is where that
instruction belongs -- the tapes end up the same length as before (688/430/468/725
instead of 693/433/471/730: one setup instruction moved out of the macro).

All nine byte level operations still pass, and the docs (AGENTS.md, README.md and
the four file headers) now state the carry in contract instead of describing a
constant.
2026-11-07 09:12:47 +08:00

337 lines
11 KiB
C++

// Runs the byte level library macros over every input pair on a ROT-8 machine.
//
// r8forge_byte_op_test [repo root]
//
// The machine below follows the reference implementation in ROT-8-viz
// (src/rot8.c): `biz` jumps when the LOW BIT of the cell is 0 and `rnz` jumps
// back when it is 1, so `set_0` (= [-]) clears the low bit of whatever is in
// the cell. Reading `[`/`]` as a Brainfuck style "is the cell zero" test makes
// every one of these programs look like an endless loop -- which is exactly the
// mistake three interpreters in this repo used to make.
#include "r8forge/r8asm.hh"
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
namespace {
struct machine {
std::vector<uint8_t> cells = std::vector<uint8_t>(256, 0);
std::vector<uint8_t> out;
size_t dp = 0;
size_t steps = 0;
bool finished = true; // false: the step limit ran out
static uint8_t ror(uint8_t v) { return uint8_t((v >> 1) | (v << 7)); }
void run(const std::string &tape, size_t limit) {
for (size_t pc = 0; pc < tape.size(); pc++) {
if (++steps > limit) {
finished = false;
return;
}
switch (tape[pc]) {
case '>':
dp = (dp + 1) % cells.size();
break;
case '<':
dp = (dp + cells.size() - 1) % cells.size();
break;
case '-': // flb
cells[dp] ^= 1;
break;
case '+': // ror
cells[dp] = ror(cells[dp]);
break;
case '[': // biz: branch when the low bit is zero
if ((cells[dp] & 1) == 0) {
int depth = 1;
while (depth) {
pc++;
if (tape[pc] == '[')
depth++;
else if (tape[pc] == ']')
depth--;
}
}
break;
case ']': // rnz: return when the low bit is one
if ((cells[dp] & 1) == 1) {
int depth = 1;
while (depth) {
pc--;
if (tape[pc] == ']')
depth++;
else if (tape[pc] == '[')
depth--;
}
}
break;
case '.':
out.push_back(cells[dp]);
break;
default: // ',' (input) is not modelled
break;
}
}
}
};
std::string assemble(const std::string &file) {
r8asm assembler;
if (!assembler.import_file(file, 8) || assembler.failed()) {
std::cerr << "could not assemble " << file << "\n";
std::exit(1);
}
return assembler.export_rot8();
}
int failures = 0;
void report(const std::string &name, int a, int b, const machine &m,
const std::string &want) {
if (failures++ < 5) {
std::cerr << " WRONG " << name << " a=" << a << " b=" << b << " out";
for (uint8_t v : m.out)
std::cerr << " " << int(v);
std::cerr << " want " << want << " finished=" << m.finished
<< " steps=" << m.steps << "\n";
}
}
// raw_and / raw_or / raw_xor: both operands are preserved, the result is third.
int test_bitop(const std::string &file, const char *name, int op) {
const std::string tape = assemble(file);
std::cout << name << ": " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.cells[2] = uint8_t(b); // B
m.run(tape, 100'000);
const int want = op == 0 ? (a & b) : op == 1 ? (a | b) : (a ^ b);
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == a &&
m.out[1] == b && m.out[2] == want;
if (!ok) {
bad++;
if (bad <= 3)
report(name, a, b, m,
std::to_string(a) + " " + std::to_string(b) + " " +
std::to_string(want));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// raw_add: out is A, B, Ci, S, Co.
int test_add(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "raw_add: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint8_t(a);
m.cells[2] = uint8_t(b);
m.run(tape, 100'000);
const int sum = a + b;
const bool ok = m.finished && m.out.size() == 5 && m.out[0] == a &&
m.out[1] == b && m.out[2] == 0 &&
m.out[3] == (sum & 0xff) && m.out[4] == (sum >> 8);
if (!ok) {
bad++;
if (bad <= 3)
report("raw_add", a, b, m,
std::to_string(a) + " " + std::to_string(b) + " 0 " +
std::to_string(sum & 0xff) + " " +
std::to_string(sum >> 8));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// raw_inc: out is A, Ci, S, Co; S = A + Ci.
int test_inc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "raw_inc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int ci = 0; ci < 2; ci++) {
machine m;
m.cells[0] = uint8_t(a);
m.cells[2] = uint8_t(ci);
m.run(tape, 100'000);
const int sum = a + ci;
const bool ok = m.finished && m.out.size() == 4 && m.out[0] == a &&
m.out[1] == ci && m.out[2] == (sum & 0xff) &&
m.out[3] == (sum >> 8);
if (!ok) {
bad++;
if (bad <= 3)
report("raw_inc", a, ci, m,
std::to_string(a) + " " + std::to_string(ci) + " " +
std::to_string(sum & 0xff) + " " +
std::to_string(sum >> 8));
}
}
std::cout << " " << (bad ? "FAILED" : "all 512 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_add_nc: out is A, B, S, Ci. This one eats both operands, so A and B have
// to come back zero -- that is what lets it use the 4 cell slice.
int test_add_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_add_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.cells[2] = uint8_t(b); // B
m.run(tape, 100'000);
const int sum = a + b;
const bool ok = m.finished && m.out.size() == 4 && m.out[0] == 0 &&
m.out[1] == 0 && m.out[2] == (sum & 0xff) &&
m.out[3] == (sum >> 8);
if (!ok) {
bad++;
if (bad <= 3)
report("clb_add_nc", a, b, m,
"0 0 " + std::to_string(sum & 0xff) + " " +
std::to_string(sum >> 8));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_inc_nc: out is A, S, Ci.
int test_inc_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_inc_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.run(tape, 100'000);
const int sum = a + 1;
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == (sum & 0xff) && m.out[2] == (sum >> 8);
if (!ok) {
bad++;
if (bad <= 3)
report("clb_inc_nc", a, 1, m,
"0 " + std::to_string(sum & 0xff) + " " +
std::to_string(sum >> 8));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_neg_nc: out is A, S, Ci; S = -A, A is eaten.
int test_neg_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_neg_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.run(tape, 100'000);
const int neg = (256 - a) & 0xff;
const int carry = a == 0 ? 1 : 0; // -0 is 0 but it does carry out
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == neg && m.out[2] == carry;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_neg_nc", a, 0, m,
"0 " + std::to_string(neg) + " " + std::to_string(carry));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_sub_nc: out is A, B, S, Ci; S = A - B and Ci = 1 means no borrow.
int test_sub_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_sub_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.cells[2] = uint8_t(b); // B
m.run(tape, 100'000);
const int diff = (a - b) & 0xff;
const int no_borrow = a >= b ? 1 : 0;
const bool ok = m.finished && m.out.size() == 4 && m.out[0] == 0 &&
m.out[1] == 0 && m.out[2] == diff && m.out[3] == no_borrow;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_sub_nc", a, b, m,
"0 0 " + std::to_string(diff) + " " +
std::to_string(no_borrow));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// Same macro with its carry in at 0 is the ones' complement: S = ~A.
int test_not_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_neg_nc (carry 0): " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint8_t(a); // A
m.run(tape, 100'000);
const int inv = (~a) & 0xff;
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == inv && m.out[2] == 0;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_neg_nc/0", a, 0, m, "0 " + std::to_string(inv) + " 0");
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
} // namespace
int main(int argc, char **argv) {
const std::string root = argc > 1 ? argv[1] : ".";
const std::string drv = root + "/drv/";
const int bad = test_add(drv + "raw_add_byte.r8asm") +
test_bitop(drv + "raw_and_byte.r8asm", "raw_and", 0) +
test_bitop(drv + "raw_or_byte.r8asm", "raw_or", 1) +
test_bitop(drv + "raw_xor_byte.r8asm", "raw_xor", 2) +
test_inc(drv + "raw_inc_byte.r8asm") +
test_add_nc(drv + "raw_add_nc_byte.r8asm") +
test_inc_nc(drv + "raw_inc_nc_byte.r8asm") +
test_neg_nc(drv + "raw_neg_nc_byte.r8asm") +
test_not_nc(drv + "raw_not_nc_byte.r8asm") +
test_sub_nc(drv + "raw_sub_nc_byte.r8asm");
std::cout << (bad ? "FAILED\n" : "byte level library ok\n");
return bad ? 1 : 0;
}