examples/term.r8asm is the "type at it and it answers" program: it prints "> ", then
echoes every character the machine reads, prints a fresh prompt after each newline,
and answers a backspace with space + backspace so the cursor erases the glyph.
EOF (the 0 that inp returns when the input is gone) erases the loop quota, so the
loop ends and the tape runs off its end after one final newline.
tape 3467 characters, 4743 steps for a two line session (the calculator is 62585)
Measured (derive and tape_run, then the reference machine's serial output):
in hi out 62 32 104 105 10 "> hi\n"
in hi<LF>ok out 62 32 104 105 10 62 32 111 107 10 two prompts
in h<BS>i out 62 32 104 8 32 8 105 10 the 8 32 8 pair
All three character streams agree with ROT-8-viz byte for byte (bar CRLF).
r8forge_examples_test passes all 18 examples.
One thing worth recording: my brief for this said "a body entered on LSB==0 needs no
clear" -- that is backwards, `[` *jumps* on LSB==0, so bodies are entered on LSB==1.
Following it inverted the dispatch (EOF fired with C=0x68) and it took a
`tape_run --trace` to see it; the file now documents the real rule next to the loop.
159 lines
7.4 KiB
Plaintext
159 lines
7.4 KiB
Plaintext
; in hi
|
||
; out 62 32 104 105 10
|
||
;
|
||
; term —— 终端纸带:开机打一个提示符 `> `,之后每读到一个字符就原样回显;
|
||
; 换行(10)时补打下一行的提示符,退格(8)时打"空格 + 退格"把屏幕上那个
|
||
; 字符擦掉;读到 0(EOF)就收摊,最后补一个换行。
|
||
;
|
||
; 纸带 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)。
|
||
;
|
||
; 另外两组只换 `-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 只跑第一组,其余两组靠上面那条命令复现。)
|
||
;
|
||
; 结构:全部串在一个 `loop CNT` / `endloop CNT` 里,所以每轮只有一份代码:
|
||
;
|
||
; 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
|
||
;
|
||
; 两个标志:`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`。
|
||
;
|
||
; 两个"借":回显那一支的判决拿 F 当标志(clb_nonzero 会先把它 set_0,
|
||
; 最后统一清掉,正好也是外层 `biz F` 的条件格),G 当它的草稿格 —— G 在
|
||
; 那一支里本来就是 0,clb_nonzero 只动最低位、结束又归 0,所以外层的
|
||
; `biz G` 不会被打乱。T 在主循环每轮开头 `set_0` 一下(草稿格只要求最低位
|
||
; 干净,calc.r8asm 里同样的写法),因为上一轮它留着 C - 10。
|
||
;
|
||
; 内存地图只有 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 位下量过;换位宽要重新汇编再量一遍。
|
||
%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)
|
||
|
||
; ---- 内存地图 ----
|
||
.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
|
||
|
||
; ================================ 开机 ================================
|
||
; 四个常量格只造一次。GT、SP 相邻,clb_puts GT 2 就是 "> "。
|
||
load GT 62
|
||
load SP 32
|
||
load NL 10
|
||
load BS 8
|
||
clb_puts GT 2
|
||
|
||
; 主循环配额:_CELL_SIZE 个 1。11 位下正好整格全 1,bit0 天然是 1,所以
|
||
; 不像 N < _CELL_SIZE 那样还要补一个 rol(SPEC §5.1 末尾那个坑)。
|
||
.tp CNT
|
||
%rep _CELL_SIZE
|
||
set_1
|
||
ror
|
||
%endrep
|
||
|
||
; ================================ 主循环 ================================
|
||
loop CNT
|
||
; ---- 续配额:loop 已经吃掉一个 1 又转了一格,这里 rol 回去再补一个 ----
|
||
; CNT 进来是全 1;set_0+ror 之后是 0b0111...1,rol 回去成 0b111...0,
|
||
; set_1 补成 0b111...1 —— 配额又满了,下一轮照旧。
|
||
.tp CNT
|
||
rol
|
||
set_1
|
||
|
||
; ---- 读一个字符(读空是 0)----
|
||
.tp C
|
||
inp
|
||
|
||
; ---- 两个标志 ----
|
||
.tp T
|
||
set_0 ; clb_nonzero 的草稿格只要求最低位干净(上一轮留着 C - 10)
|
||
clb_nonzero C F T ; F 的最低位 = (C != 0),C 保持原样
|
||
clb_nonzero C G T ; 同一个测试再做一份(T 已被上一次调用清回 0)
|
||
.tp G
|
||
flb ; G 的最低位 = (C == 0)
|
||
|
||
; ---- EOF:C == 0 -> G 的最低位是 1,biz 进得去 ----
|
||
.tp G
|
||
biz
|
||
erase CNT ; 配额清零 -> endloop 的 rnz 这一圈之后不再跳回
|
||
.tp G
|
||
set_0 ; 清掉条件(进来时是 1),dp 也落回条件格
|
||
rnz
|
||
|
||
; ---- 回显:C != 0 -> F 的最低位是 1,biz 进得去 ----
|
||
.tp F
|
||
biz
|
||
output C
|
||
|
||
; ---- 退格? 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
|
||
set_0
|
||
rnz
|
||
|
||
; ---- 换行? 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
|
||
set_0
|
||
rnz
|
||
|
||
.tp F
|
||
set_0 ; 清掉回显那一支的条件(也把 dp 落回 F)
|
||
rnz
|
||
endloop CNT
|
||
|
||
; ---- 收尾:最后的换行 ----
|
||
output NL
|