Files
dsh c417304140 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.
2026-11-18 21:58:29 +08:00

402 lines
15 KiB
Plaintext
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
; in lhi
; out 62 32 108 104 105 10 51 10 62 32 10
;
; term —— 终端纸带 v2:行编辑 + 命令分派。
;
; 屏幕上看起来是这样(`r8forge_tape_run t.rot8 -i "lhi"`:打完字就 EOF,EOF 会把
; 没提交的半截行也提交掉):
;
; > lhi
; 3
; >
;
; 协议:
; '0'..'9' / 字母 / 其它可打印字符 回显,并追加进 4 格行缓冲
; 退格(8) 回显它,再打"空格 + 退格"擦掉屏幕上那个字符,
; 行长减一(缓冲不用挪,长度就是"删掉")
; 回车(10) 提交这一行:换行、执行命令、换行、打下一行提示符
; 0(EOF) 有半截行就先提交,然后收摊
;
; 命令按行首字符分派(其余字符是参数,只有 'r' 用得上):
; 'l' 打这一行的长度('0' + LEN,一个字符)
; 'r' 把 4 格缓冲**反着**打一遍
; 'q' 退出(清掉主循环配额,这一圈之后纸带跑完)
; 其它 什么都不做
;
; ---- 五个不得不这么写的地方 ----
;
; (1) 行缓冲是**左对齐 + 长度**,不是右对齐的滑动窗口。追加要写进 LB+LEN 那一格,
; 而这台机器没有间接寻址,只能把 LEN 的低两位剥出来当分派位(clb_bit_mov 两次),
; 四个分支各写一个固定地址(LB+0..LB+3);LEN == 4 时这一行满了,新字符丢掉。
; 反过来"右对齐 + 每次整体挪一格"虽然追加只花一次 copy,但退格要把整行挪回去、
; 打印还得先算起点,两处都要分派 —— 左对齐这边退格只是 LEN 减一,便宜得多。
;
; (2) 回显和追加都要一个**没被吃掉的字符**。分类用的 clb_sub_nc 会把 C 吃干净,
; 所以每轮先抄一份 CE:判退格拿 C 去减(吃掉 C 没关系),回显和追加都用 CE。
; 第一版拿 C 当追加的源,于是行缓冲永远是空的 —— 'l' 打 0、'r' 打一片 NUL。
;
; (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 / clb_inc_ip / clb_dec_ip
; ---- 内存地图(热单元格挨着排,见文件开头第 (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,每轮补回来)
; ================================ 开机 ================================
load GT 62
load SP 32
load NL 10
load BS 8
load C48 48
load C108 108
clb_puts GT 2 ; 第一行的提示符 "> "
; 主循环配额:_CELL_SIZE 个 1。11 位下正好整格全 1,bit0 天然是 1,不用补 rol。
.tp CNT
%rep _CELL_SIZE
set_1
ror
%endrep
; ================================ 主循环 ================================
loop CNT
; ---- 续配额:每轮把吃掉的那个 1 补回去 ----
.tp CNT
rol
set_1
; ---- 读一个字符(读空是 0)----
.tp C
inp
; ---- 两个标志:F = (C != 0)、G = (C == 0) ----
.tp T
set_0
clb_nonzero C F T
clb_nonzero C G T
.tp G
flb
; ---- EOF:C == 0 ----
.tp G
biz
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 ; 吃掉条件
rnz
; ---- C != 0:回显 / 退格 / 提交 / 追加 ----
.tp F
biz
; (1) CE = C:分类的减法会把 C 吃干净,回显和追加都用 CE
.tp BUF
erase BUF
.tp C
copy CE BUF
; (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
; (3) 回车(10)? T 再减 2 就是 C - 10
clb_dec_ip T G
clb_dec_ip T G
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 ; 吃掉 (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
; ---- 收尾:最后的换行 ----
output NL