"""Tiny8: the small 8-bit computer the network learns to BE. State = 477 bytes, every one a token for the network: [0..7] registers R0..R7 [8] PC (byte address into ROM; instructions are 2 bytes) [9] SP (stack pointer; the stack lives at the top of RAM, first push lands at 127) [10] flags: bit0 Z (result was zero), bit1 C (carry / borrow / error) [11] output pointer [12] input pointer [13..76] output tape, 64 cells (OUT writes here) [77..204] RAM, 128 bytes ---- everything above changes; everything below is read-only input ---- [205..460] ROM, 256 bytes (the program) [461..476] input tape, 16 bytes (IN reads here) One step() = one instruction. Instruction = 2 bytes: (opcode << 3 | register r), argument byte. """ import numpy as np O_R, O_PC, O_SP, O_FL, O_OP, O_IP = 0, 8, 9, 10, 11, 12 O_OUT, N_OUT = 13, 64 O_RAM, N_RAM = 77, 128 N_STATE = 205 O_ROM, N_ROM = 205, 256 O_IN, N_IN = 461, 16 N_TOK = 477 OPS = ["HALT", "LDI", "MOV", "ADD", "SUB", "ADDI", "SUBI", "MUL", "DIV", "MOD", "AND", "OR", "XOR", "SHL", "SHR", "CMP", "CMPI", "JMP", "JZ", "JNZ", "JC", "JNC", "CALL", "RET", "PUSH", "POP", "LD", "ST", "LDA", "STA", "OUT", "IN"] OP = {n: i for i, n in enumerate(OPS)} # argument kind per op: 'r' second register, 'i' immediate, 'a' ROM address, 'm' RAM address, '' none ARG = {"HALT": "", "LDI": "i", "MOV": "r", "ADD": "r", "SUB": "r", "ADDI": "i", "SUBI": "i", "MUL": "r", "DIV": "r", "MOD": "r", "AND": "r", "OR": "r", "XOR": "r", "SHL": "", "SHR": "", "CMP": "r", "CMPI": "i", "JMP": "a", "JZ": "a", "JNZ": "a", "JC": "a", "JNC": "a", "CALL": "a", "RET": "", "PUSH": "", "POP": "", "LD": "r", "ST": "r", "LDA": "m", "STA": "m", "OUT": "", "IN": ""} USES_R = {n for n in OPS if n not in ("HALT", "JMP", "JZ", "JNZ", "JC", "JNC", "CALL", "RET")} def boot(rom: bytes, inp=()): s = np.zeros(N_TOK, np.uint8) rom = bytes(rom)[:N_ROM] s[O_ROM:O_ROM + len(rom)] = np.frombuffer(rom, np.uint8) s[O_SP] = 128 inp = list(inp)[:N_IN] s[O_IN:O_IN + len(inp)] = inp return s def step(s: np.ndarray) -> np.ndarray: """Pure function: next state (ROM and input tape copied unchanged).""" n = s.copy() R = n[O_R:O_R + 8].astype(np.int64) ram = n[O_RAM:O_RAM + N_RAM] pc = int(n[O_PC]) b0, arg = int(n[O_ROM + pc]), int(n[O_ROM + ((pc + 1) & 255)]) op, r = b0 >> 3, b0 & 7 s2 = arg & 7 z, c = int(n[O_FL]) & 1, (int(n[O_FL]) >> 1) & 1 npc = (pc + 2) & 255 sp = int(n[O_SP]) name = OPS[op] def setzc(v, carry): nonlocal z, c z, c = int((v & 255) == 0), int(carry) if name == "HALT": npc = pc elif name == "LDI": R[r] = arg elif name == "MOV": R[r] = R[s2] elif name in ("ADD", "ADDI"): b = R[s2] if name == "ADD" else arg v = R[r] + b R[r] = v & 255 setzc(v, v > 255) elif name in ("SUB", "SUBI"): b = R[s2] if name == "SUB" else arg v = R[r] - b R[r] = v & 255 setzc(v, R[r] != v) # borrow elif name == "MUL": v = R[r] * R[s2] R[r] = v & 255 setzc(v, v > 255) elif name in ("DIV", "MOD"): b = R[s2] if b == 0: R[r] = 0 setzc(0, 1) else: R[r] = R[r] // b if name == "DIV" else R[r] % b setzc(R[r], 0) elif name in ("AND", "OR", "XOR"): R[r] = (R[r] & R[s2]) if name == "AND" else (R[r] | R[s2]) if name == "OR" else (R[r] ^ R[s2]) setzc(R[r], 0) elif name == "SHL": v = R[r] << 1 R[r] = v & 255 setzc(v, v > 255) elif name == "SHR": cbit = R[r] & 1 R[r] = R[r] >> 1 setzc(R[r], cbit) elif name in ("CMP", "CMPI"): b = R[s2] if name == "CMP" else arg setzc(R[r] - b, R[r] < b) elif name == "JMP": npc = arg & 254 elif name in ("JZ", "JNZ", "JC", "JNC"): cond = {"JZ": z == 1, "JNZ": z == 0, "JC": c == 1, "JNC": c == 0}[name] if cond: npc = arg & 254 elif name == "CALL": sp = (sp - 1) & 255 ram[sp & 127] = npc npc = arg & 254 elif name == "RET": npc = int(ram[sp & 127]) & 254 sp = (sp + 1) & 255 elif name == "PUSH": sp = (sp - 1) & 255 ram[sp & 127] = R[r] elif name == "POP": R[r] = ram[sp & 127] sp = (sp + 1) & 255 elif name == "LD": R[r] = ram[R[s2] & 127] elif name == "ST": ram[R[s2] & 127] = R[r] elif name == "LDA": R[r] = ram[arg & 127] elif name == "STA": ram[arg & 127] = R[r] elif name == "OUT": op_ = int(n[O_OP]) n[O_OUT + (op_ & 63)] = R[r] n[O_OP] = (op_ + 1) & 63 elif name == "IN": ip = int(n[O_IP]) R[r] = n[O_IN + (ip & 15)] n[O_IP] = (ip + 1) & 15 n[O_R:O_R + 8] = R.astype(np.uint8) n[O_PC] = npc n[O_SP] = sp n[O_FL] = z | (c << 1) return n def halted(s): pc = int(s[O_PC]) return (int(s[O_ROM + pc]) >> 3) == 0 def run(rom, inp=(), max_steps=100000): """Run to HALT; returns (final state, steps, printed numbers in order).""" s = boot(rom, inp) printed = [] for t in range(max_steps): if halted(s): return s, t, printed pc = int(s[O_PC]) if (int(s[O_ROM + pc]) >> 3) == OP["OUT"]: printed.append(int(s[O_R + (int(s[O_ROM + pc]) & 7)])) s = step(s) return s, max_steps, printed def assemble(lines): """Two-pass assembler. Lines: 'label:', 'OP r, arg' with registers r0..r7, numbers, labels, '.byte n' not supported (ROM is code only).""" labels, pc, ins = {}, 0, [] for ln in lines: ln = ln.split(";")[0].strip() if not ln: continue if ln.endswith(":"): labels[ln[:-1]] = pc continue ins.append(ln) pc += 2 if pc > N_ROM: raise ValueError(f"program too long: {pc} bytes > {N_ROM}") out = bytearray() for ln in ins: parts = ln.replace(",", " ").split() name = parts[0].upper() a = parts[1:] r = 0 if name in USES_R: r = int(a[0][1:]) a = a[1:] k = ARG[name] if k == "": v = 0 elif k == "r": v = int(a[0][1:]) else: t = a[0] v = labels[t] if t in labels else int(t, 0) out += bytes([(OP[name] << 3) | r, v & 255]) return bytes(out) def disasm(rom, pc): b0, arg = rom[pc], rom[(pc + 1) & 255] name, r = OPS[b0 >> 3], b0 & 7 k = ARG[name] s = name + (f" r{r}" if name in USES_R else "") if k == "r": s += f", r{arg & 7}" elif k: s += f", {arg}" return s