term: a line-editing terminal -- buffer, backspace and command dispatch

examples/term.r8asm was a per-character echo (prompt, echo, backspace erase,
newline, EOF).  It is now a small shell: a 4 character line buffer, a backspace
that really removes a character, and Enter -- or EOF, for a half typed line --
commits the line and dispatches on its first character.  'l' prints the length,
'r' prints the buffer backwards, 'q' quits, anything else is ignored.

The header session "lhi" exercises the whole chain: EOF commits the pending
line, so examples_test sees the '3'.  Three more sessions are documented in the
header: "rab" gives NUL+'b'+'a'+'r', "lab<BS>" gives '2' (the backspace really
dropped the 'b'), and "lhi<NL>rxy<NL>" prints '3' then the reversed second
line.

Three things ate most of the debugging time; all three are written up in the
file:

* "else" needs a flag cell.  biz enters when the low bit is set, so "if not A
  then B" cannot be inferred from "the last test missed": set FLAG=1 before the
  test, clear it in the matched branch, look at FLAG afterwards.  And biz tests
  the CURRENT dp cell, so the order has to be "set FLAG, then .tp to the
  condition cell, then biz" -- the wrong order made every character look like
  a commit key.
* clb_sub_nc eats its operands, so the echo and the append both work from the
  copy CE.  The first version appended C (already zeroed by the comparison),
  which left the line buffer empty: 'l' printed 0 and 'r' printed four NULs.
* the cell layout dominates the tape.  copy / clb_sub_nc / clb_nonzero all emit
  .tp internally, some of them inside %rep _CELL_SIZE, so a 20 cell gap costs
  a couple of thousand characters: putting the constants at 22..28 gave 33067
  characters, packing the hot cells into 0..27 gives 21721.

The buffer is left aligned with a length counter -- appending needs a dispatch
on LEN, but backspace is just LEN-- -- and 'r' prints all four cells instead of
dispatching on the length, which costs a NUL for the unused cells and is
documented.

tests/widths.ps1 now also checks term.r8asm at every width (its expected
stream is width independent, which is what makes it a good second program for
the matrix), and TODO/AGENTS/README record the item as done.
This commit is contained in:
dsh committed 2026-11-18 21:58:29 +08:00
1 parent 4eec72953a
commit c417304140
5 files changed
+377 -108

No files matched your search

+17 -2
View File
@@ -20,6 +20,9 @@ PowerShell 的编码坑、git 身份和 push 提权、临时目录抽风……
(`examples/calc.r8asm`)。加、减、乘按二补码天然正确,没有改。
* **计算器是 3 格 RPN 栈**(64983 字符):数字压栈、运算符立刻算(弹二压一)、`.` 显示
栈顶但不动栈。旧的两寄存器版算不了嵌套(`1 2 + 3 4 * + .` 打 `0007`,现在 `0015`)。
* **`examples/term.r8asm` 是行编辑终端**(21721 字符):4 格行缓冲 + 退格编辑 + 回车/EOF
提交 + 按行首字符分派命令(`l` 长度、`r` 反着打、`q` 退出)。表头那组 `in lhi` 就能
测到整条分派链(EOF 会把没提交的行也提交掉)。
* 全绿基线(这台机器约 1 分钟;命令见下)。
* 另一个仓库 `../ROT-8-viz`(fork `dsh/ROT-8-viz`,分支 `main`)是权威虚拟机 +
可视化:**默认 I/O 是串行 ASCII**(cell ≥ 8 位),数值 I/O 用 `-n` / `--numbers`,
@@ -127,7 +130,7 @@ powershell -File tests\widths.ps1 # 位宽矩阵:每个位宽一
* **字节级程序"跑不动"先怀疑虚拟机**:仓库里曾有三份解释器把 `biz` 写成整格零判断,于是
所有字节级程序看起来都在死循环 —— 别再把库判成坏的。
## 刚做完的两件大事:有符号数、RPN 栈
## 刚做完的三件大事:有符号数、RPN 栈、终端纸带
二补码、`-0042` 显示、截断除法、静默溢出,约定在 SPEC §5.4、实现在 §7.10。
`clb_digits_signed` / `clb_divmod_signed` 都是包装(真活还是 `clb_digits` /
@@ -143,11 +146,23 @@ powershell -File tests\widths.ps1 # 位宽矩阵:每个位宽一
(`1 2 + 3 4 * + .` 打 `0007`,现在是 `0015`)。**栈深只有 3 格是纸带逼出来的**:
一格一次 `copy`(约 500 字符),4 格就顶上 65536 了。挪栈的**次序不能反**(从高往低搬)。
`examples/term.r8asm` 又是另一种东西:**行缓冲(左对齐 + LEN)+ 退格编辑 + 回车/EOF 提交
+ 命令分派**(`l` 长度、`r` 反着打、`q` 退出)。三条硬教训:
* **"else" 必须用标志格写**:`biz` 只在最低位是 1 时进身体,"没命中就做 B"不能靠推断 ——
先 `set_1` 一个 FLAG,命中那支清 0,出块再看。而且 `biz` 的条件格是**当前 dp**,
所以顺序必须是"先 set FLAG、再 `.tp` 到条件格、再 biz"(写反了就是每轮都命中)。
* **被减数会被吃掉**:分类用的 `clb_sub_nc` 吃操作数,所以回显/追加都要用副本 CE;
拿 C 当追加源的那一版,行缓冲永远是空的。
* **热单元格要挨着排**:`copy`/`clb_sub_nc`/`clb_nonzero` 内部都有 `.tp`,有的还在
`%rep _CELL_SIZE` 里 —— 常数格排到 22..28 时整条纸带 33k,挤进 0..27 就回到 21.7k。
## 下一步
候选、想清楚但没做的优化、以及工具侧的小尾巴都收在 [`TODO.md`](TODO.md);
`SPEC.md` §12 是"别试"的结论,不是待办。眼下最靠前的是 TODO 里的"交互计算":
终端纸带(行缓冲 + 命令分派)、迷你 `printf`,以及栈要不要再深一格。
迷你 `printf`(做完终端纸带之后用处要重新评估)、把终端纸带接上计算器(卡在纸带预算)、
以及栈要不要再深一格。
## 索引
+2 -2
View File
@@ -145,6 +145,6 @@ ctest --test-dir build -C Release -j 4 --output-on-failure # 上面这些一次
* [`AGENTS.md`](AGENTS.md) —— 工作手册:构建/自检命令、硬规则、坑、当前交接。
* [`docs/divmod.md`](docs/divmod.md) —— `clb_divmod` 的移位-恢复除法:每轮状态、坑、实测。
* [`docs/byte-ops.md`](docs/byte-ops.md) —— 字节级库的设计推理与教训。
* [`TODO.md`](TODO.md) —— 还没做的事:终端纸带(行编辑 + 命令分派)、迷你 `printf`、
纸带优化器、`--profile`、缓存体检、CI。
* [`TODO.md`](TODO.md) —— 还没做的事:迷你 `printf`、把终端纸带接上计算器、纸带优化器、
`--profile`、缓存体检、CI。
* [`docs/calc.md`](docs/calc.md) —— 桌上计算器:命令协议、3 格 RPN 栈、分阶段计划。
+8 -6
View File
@@ -9,22 +9,24 @@
纸带、**有符号数三步走**(`clb_digits_signed` / `clb_divmod_signed` / 计算器的一元负号,
契约在 SPEC §5.4、实现在 §7.10,穷举在 `r8forge_byte_op_test` 的 `test_digits_signed` 2048
个值 和 `test_divmod_signed` 4202 组)、**RPN 栈**(3 格栈 + 运算符立刻算 + `.` 真 peek,
`examples/calc.r8asm` 现在是真 RPN:`1 2 + 3 4 * + .` = `0015`)。
`examples/calc.r8asm` 现在是真 RPN:`1 2 + 3 4 * + .` = `0015`)、**终端纸带**(行缓冲 +
退格编辑 + 命令分派,`examples/term.r8asm` 21721 字符:`lhi` 打 3、`rab` 反着打、退格真能
删掉一个字符、`<NL>` 和 EOF 都提交)。
## 交互计算(下一步)
* **终端纸带**:提示符 + 逐字符回显 + 行编辑(退格打印 `\b \b`)+ 命令分派。零件都在
`drv/calc_*`(分派、数字攒取、显示、四则)和 `examples/term.r8asm`(提示符、回显、
退格、换行补提示符、EOF 收摊)——缺的是"行缓冲 + 落行 + 命令分派"。
验收用头部 `; in` 喂一整段会话,`examples_test` 会自动跑。
* **迷你 `printf`**:`clb_puts` 和 `load` 已经有了(`examples/hello.r8asm` 能打一整句),还缺
`%d` / `%c` / `%s` 的格式化 —— 那需要"格式串 + 参数表"的约定,比 puts 复杂一档。
没有间接寻址,所以格式串在汇编期长度固定(像 `clb_puts` 的 LEN),参数表要靠
"第 k 个参数"的分派树;`%d` 直接是 `clb_digits_signed`,`%c` 是一条 `out`,
`%s` 得再约定"串 + 长度"两格。
`%s` 得再约定"串 + 长度"两格。**不过 `examples/term.r8asm` 做完之后,这条的
用处要重新评估**(它原本是给终端纸带打格式化输出用的)。
* **栈再深一点**:现在是 3 格(`64983` 字符,离 65536 只剩 553)。4 格要多花一次
push 的 `copy`(约 500)—— 要么先省掉别处的 500 字符,要么认了 65500+ 的纸带。3 格
已经够 `1 2 + 3 4 * +` 这种两层的嵌套;真要写长表达式就得再想办法。
* **终端纸带接上计算器**:`term.r8asm` 有行编辑、`calc.r8asm` 有 RPN 引擎,两者合起来
就是一个"能改错"的交互计算器。卡在纸带上:计算器只剩 553 字符,而退格要把行缓冲
挪一格(一次 `copy`,约 500)再加分类,塞不进去。真要做得先给计算器腾出 ~1.5k。
## 工具
+341 -98
View File
@@ -1,87 +1,109 @@
; in hi
; out 62 32 104 105 10
; in lhi
; out 62 32 108 104 105 10 51 10 62 32 10
;
; term —— 终端纸带:开机打一个提示符 `> `,之后每读到一个字符就原样回显;
; 换行(10)时补打下一行的提示符,退格(8)时打"空格 + 退格"把屏幕上那个
; 字符擦掉;读到 0(EOF)就收摊,最后补一个换行。
; term —— 终端纸带 v2:行编辑 + 命令分派。
;
; 纸带 3467 字符(`r8forge examples/term.r8asm` 在 11 位下的输出长度,远在
; ROT-8-viz 的 INS_SIZE(65536) 以内);表头这一组 `in hi` 跑 4737 步
; (r8forge_examples_test 报的数),out 就是 "> hi\n"(62 32 104 105 10)。
; 屏幕上看起来是这样(`r8forge_tape_run t.rot8 -i "lhi"`:打完字就 EOF,EOF 会把
; 没提交的半截行也提交掉):
;
; 另外两组只换 `-i`,纸带不变(r8forge_derive 和 r8forge_tape_run 两份实现
; 逐项一致;每组末尾是 r8forge_tape_run 报的步数):
; -i "hi<10>ok" -> out 62 32 104 105 10 62 32 111 107 10 11042 步
; "> hi\n> ok\n":换行补了第二行那个提示符
; -i "h<8>i" -> out 62 32 104 8 32 8 105 10 6772 步
; 字符流是 "> h" + 8 + 32 + 8 + "i" + 换行 —— 8 是回显出来的
; 退格,紧跟的 32 8 是"空格 + 退格"的擦除,屏幕上那个 h 被
; 擦掉,最后一行看着是 "> i"
; (<10> 是行尾那个换行、<8> 是真的退格字符;表头只能写一组 `in`,
; 因为 r8forge_examples_test 只跑第一组,其余两组靠上面那条命令复现。)
; > lhi
; 3
; >
;
; 结构:全部串在一个 `loop CNT` / `endloop CNT` 里,所以每轮只有一份代码:
; 协议:
; '0'..'9' / 字母 / 其它可打印字符 回显,并追加进 4 格行缓冲
; 退格(8) 回显它,再打"空格 + 退格"擦掉屏幕上那个字符,
; 行长减一(缓冲不用挪,长度就是"删掉")
; 回车(10) 提交这一行:换行、执行命令、换行、打下一行提示符
; 0(EOF) 有半截行就先提交,然后收摊
;
; loop CNT
; 续配额:rol + set_1 (CNT 一直是 _CELL_SIZE 个 1)
; inp -> C
; F = (C != 0),G = (C == 0) (clb_nonzero 各一次,G 再 flb)
; biz G:C == 0 -> erase CNT (endloop 的 rnz 这一圈之后就退出)
; biz F:C != 0 -> 回显
; output C
; T = C - 8 (clb_sub_nc;BS 被吃,紧跟 load BS 8 补回)
; biz:C == 8 -> output SP; output BS (空格 + 退格 = 擦字符)
; T 再减 2 -> C - 10,biz:C == 10 -> clb_puts GT 2
; 收尾:output NL
; 命令按行首字符分派(其余字符是参数,只有 'r' 用得上):
; 'l' 打这一行的长度('0' + LEN,一个字符)
; 'r' 把 4 格缓冲**反着**打一遍
; 'q' 退出(清掉主循环配额,这一圈之后纸带跑完)
; 其它 什么都不做
;
; 两个标志:`clb_nonzero` 给出的是"C != 0"(0/1),而 `biz` 是**最低位为 1
; 才进身体**(`[` = 最低位 0 就跳到配对的 `]` 之后,见 AGENTS.md)。
; 所以 F 直接就是"回显"那一支的条件;EOF 那一支要"C == 0",把同一个测试
; 再做一份、把最低位 `flb` 一下,G 就是 (C == 0) —— 这就是两个标志格的用处。
; ---- 五个不得不这么写的地方 ----
;
; 三处 `dp` 记账(AGENTS.md "语义上会咬人的几条" 第 2 条:条件块的身体必须
; 回到它自己的条件 cell,净位移 0),也是 `biz` 的两条配套规矩:
; * 每个 `biz` 前面都 `.tp` 到条件格,身体最后一句 `.tp` 再指回去;
; * 身体进入时最低位是 1,所以**身体里必须把它清掉**(`set_0`),否则
; 收口的 `rnz` 看到 1 又跳回来,身体跑不完;
; * clb_nonzero / clb_sub_nc / clb_dec_ip 都是 `.anchor` 宏,返回时 dp 回到
; 调用点,所以调用完要自己 `.tp F` 再到 `biz`。
; (1) 行缓冲是**左对齐 + 长度**,不是右对齐的滑动窗口。追加要写进 LB+LEN 那一格,
; 而这台机器没有间接寻址,只能把 LEN 的低两位剥出来当分派位(clb_bit_mov 两次),
; 四个分支各写一个固定地址(LB+0..LB+3);LEN == 4 时这一行满了,新字符丢掉。
; 反过来"右对齐 + 每次整体挪一格"虽然追加只花一次 copy,但退格要把整行挪回去、
; 打印还得先算起点,两处都要分派 —— 左对齐这边退格只是 LEN 减一,便宜得多。
;
; 两个"借":回显那一支的判决拿 F 当标志(clb_nonzero 会先把它 set_0,
; 最后统一清掉,正好也是外层 `biz F` 的条件格),G 当它的草稿格 —— G 在
; 那一支里本来就是 0,clb_nonzero 只动最低位、结束又归 0,所以外层的
; `biz G` 不会被打乱。T 在主循环每轮开头 `set_0` 一下(草稿格只要求最低位
; 干净,calc.r8asm 里同样的写法),因为上一轮它留着 C - 10。
; (2) 回显和追加都要一个**没被吃掉的字符**。分类用的 clb_sub_nc 会把 C 吃干净,
; 所以每轮先抄一份 CE:判退格拿 C 去减(吃掉 C 没关系),回显和追加都用 CE。
; 第一版拿 C 当追加的源,于是行缓冲永远是空的 —— 'l' 打 0、'r' 打一片 NUL。
;
; 内存地图只有 9 格:C 0、CNT 1、F 2、G 3、T 4、GT 5、SP 6、NL 7、BS 8。
; GT 和 SP 挨着,所以 `clb_puts GT 2` 正好打出 "> "。
; 尺寸都按位宽写(配额是 `%rep _CELL_SIZE`,用到的宏都位宽无关),但表头上
; 这两个数只在默认 11 位下量过;换位宽要重新汇编再量一遍。
; (3) **else 要拿标志格写**。`biz` 只在最低位是 1 时进身体,"不是 A 就做 B"不能靠
; "上一个测试没命中"来推断:两个互斥分支各用一个 FLAG 格 —— 先把 FLAG 置 1
; (默认走 else),命中那一支清 0,出了块再看 FLAG。这里踩过第二个坑:`biz` 的
; 条件格是**当前 dp 那一格**,而 `.tp FLAG; set_1` 会把 dp 挪走,所以顺序必须是
; "先 set FLAG,再 .tp 到条件格,再 biz"。
;
; (4) 命令分派把 LB0 抄进 CMD 再减 'l'(108),不动行缓冲 —— 'r' 还要打它。
; 三条命令刚好落在 t = 0('l')、5('q')、6('r'):t == 0 一条,剩下的看 bit2 是
; 不是 1(q/r),再看 bit0 分 q 和 r。
;
; (5) 地址要挨着排。copy / clb_sub_nc / clb_nonzero 内部都有 `.tp`,而且有的在
; `%rep _CELL_SIZE` 里面 —— 一个格差 20 步,一次 copy 就多花两三千字符。第一版
; 把常数格排到 22..28,整条纸带 33k;把热单元格挤进 0..27 之后是现在的 21721。
;
; ---- 反着打为什么会有 NUL ----
;
; 'r' 固定打 LB+3、LB+2、LB+1、LB+0 四格,不按 LEN 收口:不这么写就要为 1/2/3/4
; 四种长度各写一份输出,多花六百多个字符。代价是长度不足 4 的行,反着打出来的
; 前几格是 0(NUL,终端上什么都看不见)。每次提交之后 LB..LB+3 会整块擦掉,所以
; "超出 LEN 的格子是 0"这个前提一直成立。要知道真实长度就用 'l'。
;
; 纸带 21721 字符(`r8forge examples/term.r8asm` 在 11 位下的输出长度),表头那组
; 会话 22249 步。全部位宽无关(宏里只有 _CELL_SIZE),但这两个数只在 11 位下量过。
;
; 另外两组会话(只换 `-i`,纸带不变;<BS> 是 8、<NL> 是 10):
; "lab<BS>" -> "> lab" + <BS> 空格 <BS> + 换行 + '2' —— 退格真把 'b' 删掉了,
; 所以 'l' 打的是 2 而不是 3
; "lhi<NL>rxy<NL>" -> 两行都提交:'3'、然后反着打的 "rxy"(前面带一个 NUL)
%include "asm/lib.r8asm"
%include "asm/raw_sub_nc.r8asm" ; clb_sub_nc(顺带 not_ip / raw_add_nc / clb_add_nc)
%include "asm/add_ip.r8asm" ; clb_nonzero(顺带 dec_ip / inc_ip / clb_dec_ip)
%include "asm/add_ip.r8asm" ; clb_nonzero / clb_inc_ip / clb_dec_ip
; ---- 内存地图 ----
.var C 0 ; 本轮读到的字符(inp 写进来,低 7 位)
.var CNT 1 ; 主循环配额:_CELL_SIZE 个 1,每轮补回去
.var F 2 ; 标志:C != 0;回显那一支里也拿它当内层判决的标志
.var G 3 ; 标志:C == 0(EOF);内层拿它当草稿
.var T 4 ; 草稿:clb_nonzero 的第三格、减法的差
.var GT 5 ; '>' = 62
.var SP 6 ; ' ' = 32
.var NL 7 ; '\n' = 10
.var BS 8 ; 退格 = 8
; ---- 内存地图(热单元格挨着排,见文件开头第 (5) 条)----
.var C 0 ; 本轮读到的字符(inp 写进来,低 7 位)
.var T 1 ; 草稿:减法结果 / clb_nonzero 的第三格
.var F 2 ; 外层标志:C != 0
.var LEN 3 ; 这一行打了几个字符(0..4)
.var H 4 ; 内层标志
.var BS 5 ; 常量 8(退格)
.var MCi 6 ; 进位格:clb_add_nc / clb_sub_nc 的 Ci
.var G 7 ; 标志:C == 0(EOF);也当草稿
.var CE 8 ; C 的副本(回显 / 追加用,分类不会碰它)
.var BUF 9 ; copy 缓冲
.var LB 10 ; LB..LB+13:4 格行缓冲,左对齐
.var CT 14 ; 临时:LEN 的副本 / 命令号的位分派
.var CMD 15 ; 行首字符副本(分派用,不动 LB0)
.var C48 16 ; 常量 48('0')
.var DD 17 ; '0' + LEN
.var GT 18 ; '>' = 62
.var SP 19 ; ' ' = 32
.var NL 20 ; '\n' = 10
.var C108 21 ; 常量 108('l':命令分派的基)
.var B0 22 ; 分派位 0
.var B1 23 ; 分派位 1
.var FLAG 24 ; 一次性判断的"走 else"标志
.var FLAG2 25 ; 同上(要嵌套两层)
.var COMMIT 26 ; 这一轮要提交
.var CNT 27 ; 主循环配额(_CELL_SIZE 个 1,每轮补回来)
; ================================ 开机 ================================
; 四个常量格只造一次。GT、SP 相邻,clb_puts GT 2 就是 "> "。
load GT 62
load SP 32
load NL 10
load BS 8
clb_puts GT 2
load C48 48
load C108 108
clb_puts GT 2 ; 第一行的提示符 "> "
; 主循环配额:_CELL_SIZE 个 1。11 位下正好整格全 1,bit0 天然是 1,所以
; 不像 N < _CELL_SIZE 那样还要补一个 rol(SPEC §5.1 末尾那个坑)。
; 主循环配额:_CELL_SIZE 个 1。11 位下正好整格全 1,bit0 天然是 1,不用补 rol。
.tp CNT
%rep _CELL_SIZE
set_1
@@ -90,9 +112,7 @@ clb_puts GT 2
; ================================ 主循环 ================================
loop CNT
; ---- 续配额:loop 已经吃掉一个 1 又转了一格,这里 rol 回去再补一个 ----
; CNT 进来是全 1;set_0+ror 之后是 0b0111...1,rol 回去成 0b111...0,
; set_1 补成 0b111...1 —— 配额又满了,下一轮照旧。
; ---- 续配额:每轮把吃掉的那个 1 补回去 ----
.tp CNT
rol
set_1
@@ -101,56 +121,279 @@ loop CNT
.tp C
inp
; ---- 两个标志 ----
; ---- 两个标志:F = (C != 0)、G = (C == 0) ----
.tp T
set_0 ; clb_nonzero 的草稿格只要求最低位干净(上一轮留着 C - 10)
clb_nonzero C F T ; F 的最低位 = (C != 0),C 保持原样
clb_nonzero C G T ; 同一个测试再做一份(T 已被上一次调用清回 0)
set_0
clb_nonzero C F T
clb_nonzero C G T
.tp G
flb ; G 的最低位 = (C == 0)
flb
; ---- EOF:C == 0 -> G 的最低位是 1,biz 进得去 ----
; ---- EOF:C == 0 ----
.tp G
biz
erase CNT ; 配额清零 -> endloop 的 rnz 这一圈之后不再跳回
erase CNT ; 配额清零 -> endloop 的 rnz 这一圈之后不再跳回
; 还有半截行就先提交(表头那组会话就靠这个把 "lhi" 送上分派台)
.tp T
set_0
clb_nonzero LEN H T ; H = (LEN != 0)
.tp H
biz
.tp COMMIT
set_1
.tp H
flb ; 吃掉条件
rnz
.tp G
set_0 ; 清掉条件(进来时是 1),dp 也落回条件格
set_0 ; 吃掉条件
rnz
; ---- 回显:C != 0 -> F 的最低位是 1,biz 进得去 ----
; ---- C != 0:回显 / 退格 / 提交 / 追加 ----
.tp F
biz
output C
; (1) CE = C:分类的减法会把 C 吃干净,回显和追加都用 CE
.tp BUF
erase BUF
.tp C
copy CE BUF
; ---- 退格? T = C - 8,等零就是退格 ----
.tp F
set_1 ; 进位入 = 1 -> S = A - B
clb_sub_nc C BS T F ; T = C - 8;C、BS 都被吃干净
load BS 8 ; 常量格补回来:下面 output BS 还要用
clb_nonzero T F G ; F 的最低位 = (C != 8);草稿借 G(它是 0,结束还是 0)
.tp F
flb ; F 的最低位 = (C == 8)
biz
output SP ; 先打空格再打退格:屏幕上那个字符就被擦掉了
output BS
.tp F
; (2) 退格? T = C - 8
.tp MCi
set_1 ; 进位入 = 1 -> S = A - B
clb_sub_nc C BS T MCi ; C、BS 被吃
load BS 8 ; 常量格补回来
clb_nonzero T H G ; H = (T != 0)
.tp FLAG
set_1 ; 默认:不是退格
.tp H
flb ; H = (C == 8)
biz ; ---- 退格 ----
output CE ; 屏幕上先回显那个退格
output SP
output BS ; "空格 + 退格" = 擦掉一个字符
.tp T
set_0
clb_nonzero LEN H T ; H = (LEN != 0)
.tp H
biz
clb_dec_ip LEN T ; 缓冲不用挪:长度减一就把它"删掉"了
.tp H
flb ; 吃掉条件
rnz
.tp FLAG
set_0
.tp H
set_0 ; 吃掉 (C == 8) 的条件
rnz
; ---- 换行? T 再减 2 就是 C - 10,等零就是换行 ----
; (3) 回车(10)? T 再减 2 就是 C - 10
clb_dec_ip T G
clb_dec_ip T G
clb_nonzero T F G ; F 的最低位 = (C != 10)
.tp F
flb ; F 的最低位 = (C == 10)
biz
clb_puts GT 2 ; 下一行的提示符
.tp F
clb_nonzero T H G ; H = (T != 0)
.tp FLAG2
set_1 ; 默认:不是回车
.tp H
flb ; H = (C == 10)
biz ; ---- 回车:提交 ----
.tp COMMIT
set_1
.tp FLAG2
set_0
.tp H
set_0 ; 吃掉条件
rnz
; (4) 既不是退格也不是回车:回显 + 追加到 LB+LEN
.tp FLAG
biz
.tp FLAG2
biz
output CE ; 回显
; LEN 的低两位剥进 B0、B1,bit2 留在 CT
.tp BUF
erase BUF
.tp LEN
copy CT BUF
.tp B0
set_0
.tp B1
set_0
.tp CT
clb_bit_mov B0
.tp CT
ror
clb_bit_mov B1
; CT 剩下的最低位就是 LEN 的 bit2:LEN == 4 时满行,丢掉
.tp CT
biz
.tp CT
set_0
.tp CT
rnz
; ---- 四位分派:写进 LB + (B1 B0) ----
.tp FLAG
set_1 ; 默认:不是 LEN == 2
.tp B1
biz
.tp FLAG2
set_1
.tp B0
biz ; LEN == 3
.tp BUF
erase BUF
.tp CE
copy LB + 3 BUF
.tp FLAG2
set_0
.tp B0
set_0
rnz
.tp FLAG2
biz ; LEN == 2
.tp BUF
erase BUF
.tp CE
copy LB + 2 BUF
.tp FLAG2
set_0
rnz
.tp FLAG
set_0
.tp B1
set_0
rnz
.tp FLAG
biz ; LEN ∈ {0,1}
.tp FLAG2
set_1
.tp B0
biz ; LEN == 1
.tp BUF
erase BUF
.tp CE
copy LB + 1 BUF
.tp FLAG2
set_0
.tp B0
set_0
rnz
.tp FLAG2
biz ; LEN == 0
.tp BUF
erase BUF
.tp CE
copy LB + 0 BUF
.tp FLAG2
set_0
rnz
.tp FLAG
set_0
rnz
.tp LEN
clb_inc_ip LEN T
.tp FLAG2
set_0 ; 吃掉 (不是回车) 的条件
rnz
.tp FLAG
set_0 ; 吃掉 (不是退格) 的条件
rnz
.tp F
set_0 ; 清掉回显那一支的条件(也把 dp 落回 F)
set_0 ; 吃掉 (C != 0) 的条件
rnz
; ---- 提交:换行、执行命令、换行、打提示符、清行 ----
.tp COMMIT
biz
output NL
; ---- 空行没有命令可执行(也顺手挡住 CMD == 0 落进 'r' 那一支)----
.tp T
set_0
clb_nonzero LEN FLAG T ; FLAG = (LEN != 0)
.tp FLAG
biz
; ---- 命令分派:T = 行首字符 - 'l' ----
.tp BUF
erase BUF
.tp LB
copy CMD BUF ; CMD = LB0(不动行缓冲)
.tp MCi
set_1
clb_sub_nc CMD C108 T MCi
load C108 108
clb_nonzero T H G ; H = (T != 0)
.tp FLAG
set_1 ; 默认:不是 'l'
.tp H
flb ; H = (T == 0)
biz ; ---- 'l':长度 ----
.tp BUF
erase BUF
.tp LEN
copy CT BUF
.tp MCi
set_0 ; 进位入 = 0 -> 纯加法
clb_add_nc CT C48 DD MCi ; DD = '0' + LEN
load C48 48
output DD
.tp FLAG
set_0
.tp H
set_0
rnz
; ---- 剩下的只有 'q'(t = 5)和 'r'(t = 6):bit2 是 1 才是这两个 ----
.tp FLAG
biz
.tp BUF
erase BUF
.tp T
copy CT BUF
.tp B0
set_0
.tp CT
clb_bit_mov B0 ; B0 = t 的 bit0
.tp CT
ror
.tp CT
ror ; t 的 bit2 转到最低位
biz ; bit2 == 1 -> 'q' 或 'r'
.tp FLAG2
set_1 ; 默认:不是 'q'
.tp B0
biz ; bit0 == 1 -> 'q'(t = 5)
erase CNT ; 退出:这一圈之后纸带跑完
.tp FLAG2
set_0
.tp B0
set_0
rnz
.tp FLAG2
biz ; 'r'(t = 6):反着打 4 格
output LB + 3
output LB + 2
output LB + 1
output LB + 0
.tp FLAG2
set_0
rnz
.tp CT
set_0 ; 吃掉条件
rnz
.tp FLAG
set_0
rnz
.tp FLAG
set_0 ; 吃掉 (LEN != 0) 的条件
rnz
output NL
clb_puts GT 2 ; 下一行的提示符 "> "
; ---- 清行:LB..LB+3 擦掉,LEN 归零 ----
%for k 4
erase LB + k
%endfor
.tp LEN
erase LEN
.tp COMMIT
set_0 ; 吃掉条件
rnz
endloop CNT
+9
View File
@@ -52,6 +52,15 @@ foreach ($w in ($Widths.Split(",") | ForEach-Object { [int]$_.Trim() })) {
if ($got -ne $want) { Write-Host " calc FAILED: want '$want' got '$got'"; $failed += $w }
else { Write-Host " calc ok: $want" }
# The terminal tape: prompt, echo, EOF-commit and the 'l' command. None of
# these numbers depend on the cell width (the length is printed as '0'+LEN),
# so the expected stream is the same at every width -- which is exactly what
# makes it a good second program for the matrix.
$termWant = "out 62 32 108 104 105 10 51 10 62 32 10"
$termGot = (& $derive "examples/term.r8asm" 0 -i "lhi" 2>$null | Out-String).Trim()
if ($termGot -ne $termWant) { Write-Host " term FAILED: want '$termWant' got '$termGot'"; $failed += $w }
else { Write-Host " term ok: $termWant" }
if (Test-Path $viz) {
# The viz only speaks serial ASCII when a cell is at least 8 bits wide
# (bit 7 doubles as the 7E1 parity/stop bit; below that it prints one