From b497bf063716f29aa223991d6ab3692d950d7519 Mon Sep 17 00:00:00 2001 From: dsh Date: Sun, 15 Nov 2026 16:03:45 +0800 Subject: [PATCH] examples: the desk calculator -- 12 34 + . -> > 0046 The five stage drivers are now one program. examples/calc.r8asm is a two register desk calculator: digits build a number, + - * / set the pending operator, . prints the accumulator (`> 0046` + newline) and , clears it. EOF (the 0 that inp returns when the input runs out) erases the loop counter, so the loop ends and the tape simply runs off its end. in 12 34 + . out 62 32 48 48 52 54 10 (> 0046) 314777 steps in 2047 3 / . out 62 32 48 54 56 50 10 (> 0682) 362281 in 7 6 * . out 62 32 48 48 52 50 10 (> 0042) 299352 in 9 4 - . out 62 32 48 48 48 53 10 (> 0005) 292030 both of the first two in one session 659759 steps 62585 characters, under ROT-8-viz's 65536 for the first time in this series, so the whole calculator can be cross-checked against the reference machine later. tape_run and derive agree, r8forge_examples_test passes all 16 examples, ctest 8/8. Four deliberate departures from docs/calc.md, each forced by a measurement: * settle before loading the new operand, and `.` settles too -- the literal order printed 0034 for 12 34 + . because the space arrives before the + and overwrites A; * the operator is one-hot (1 2 4 8) so settlement is four flat mutually exclusive biz blocks; * the loop quota is refilled each round (clb_ones can only make _CELL_SIZE ones, 11 here) instead of a fixed 128; * three cell moves worth ~24k of tape: clb_undigits scratch 35..45 -> 5..15 (next to the window it decodes), result/display target 0 -> 20 (adjacent scratch makes the %synth blocks shorter), 35..45 reused as one shot flags. Also found a trap worth remembering: a biz body that ended with `.tp B1; set_0` (condition cell is FLAG) has net displacement +2, and only on the skipped path does it desynchronise every later .tp -- the symptom was `-` and `,` sending the tape into the weeds. Net displacement 0 on both paths, always. --- AGENTS.md | 2 +- README.md | 2 +- SPEC.md | 2 +- examples/calc.r8asm | 510 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 513 insertions(+), 3 deletions(-) create mode 100644 examples/calc.r8asm diff --git a/AGENTS.md b/AGENTS.md index f66a6b0..e23523d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -32,7 +32,7 @@ cmake --build build --config Release # 当前基线:都通过,别弄坏(`ctest --test-dir build -j 4` 一次跑完 8 条,约 9 秒) r8forge asm/test.r8asm # 64513 字符(每个标准宏至少一次 + 每个语言特性) r8forge_byte_op_test # 21 项(divmod 16384 组、digits 2048、undigits 4096) -r8forge_examples_test # 15 个 example + asm/test.r8asm,核对头部 `; out`/`; in` +r8forge_examples_test # 16 个 example + asm/test.r8asm,核对头部 `; out`/`; in` r8forge_macro_docs_test # 48 macros in 22 files r8forge_synth_test examples/full_add.r8asm # all eight combinations ok r8forge_derive verify_loop.r8asm -1 0=5 # out 5 0 diff --git a/README.md b/README.md index 1f8e22f..f833155 100644 --- a/README.md +++ b/README.md @@ -84,7 +84,7 @@ src/r8asm.cc 汇编器实现 src/synth.cc 真值表 -> 搜索 asm/ 标准库(48 个宏,含 8 个 %synth 合成块) drv/ 单点验证驱动(喂固定输入跑一个宏,看 out/stat) -examples/ 15 个能跑的例程:每组宏一份 + %synth 的几种写法 + 一个交互例程 +examples/ 16 个能跑的例程:每组宏一份 + %synth 的几种写法 + 一个交互例程 tests/ 汇编器 / 虚拟机 / 字节级 / 例程 / 文档格式 自检 docs/ 设计笔记(长文) .r8forge_cache/ 合成结果缓存(已入库) diff --git a/SPEC.md b/SPEC.md index 1e0eb8b..2cbfa88 100644 --- a/SPEC.md +++ b/SPEC.md @@ -750,7 +750,7 @@ r8forge_tape_run t.rot8 # 打印 out 和步数 |---|---|---| | `r8forge_byte_op_test` | 21 个测试项 = 20 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§7.6、§7.7、§7.9、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举、`clb_divmod` 8 个除数 × 全部 2048 个被除数 = 16384 组全穷举、`clb_digits` 全部 2048 个值全穷举、`clb_undigits` 2048 个值 × 干净/高位垃圾 2 种 = 4096 组全穷举),任一不符即退出码非 0 | | `r8forge_synth_test examples/full_add.r8asm` | `%synth` 端到端:汇编 + 跑 8 种输入 | `all eight combinations ok` | -| `r8forge_examples_test` | `examples/` 里全部 15 个程序(10 组宏例程 + 4 个 `%synth` 例子 + 1 个交互例程,见 §10.3)**加上 `asm/test.r8asm`**(§10.2) | **按返回值**:每个头部 `; out ...` 与实跑 `out` 逐项相等,缺这一行也算失败;写了 `; in ...` 的先把那串字符喂给 `inp` | +| `r8forge_examples_test` | `examples/` 里全部 16 个程序(10 组宏例程 + 4 个 `%synth` 例子 + 交互例程 + 计算器,见 §10.3)**加上 `asm/test.r8asm`**(§10.2) | **按返回值**:每个头部 `; out ...` 与实跑 `out` 逐项相等,缺这一行也算失败;写了 `; in ...` 的先把那串字符喂给 `inp` | | `r8forge verify_clb_bit_add_nc.r8asm` | 4 cell 加法切片(进位进→出) | 单点:`0+0+Ci` | | `r8forge verify_clb_bit_inc_nc.r8asm` | 3 cell 自增切片 | 单点 | | `r8forge_derive verify_loop.r8asm -1 0=N` | 动态循环:`N=0..11` 时循环体跑 `N` 次(`A = N`、`C = 0`) | 逐值 `out` | diff --git a/examples/calc.r8asm b/examples/calc.r8asm new file mode 100644 index 0000000..4bbedcf --- /dev/null +++ b/examples/calc.r8asm @@ -0,0 +1,510 @@ +; in 12 34 + . +; out 62 32 48 48 52 54 10 +; +; calc —— 桌上计算器 stage 5(docs/calc.md §3 第 5 步):把前面四块拼成一条常驻 +; 纸带。两个寄存器 A(累加器)和 P(待结算的操作数),没有栈:`inp` 一个字符、 +; 分派、算、`out` 全都在一条 `loop`/`endloop` 里,所以三者各只展开一次。 +; +; 命令协议(docs/calc.md §1): +; '0'..'9' 攒进 4 位 ASCII 窗口(REG..REG+3,高位在低地址,见 stage 2) +; '*' '+' '-' '/' 把运算符记到 OP +; '.' 结算还没消费的 OP、显示 A、再把 A 留在 P 里 +; ',' 清 A、P、OP +; 空格/CR 等 只当数字的终止符 +; 0(EOF) erase 主循环配额,跳出循环,纸带自然跑完 +; +; 验证(r8forge_derive 和 r8forge_tape_run 两份实现逐项一致): +; build/Release/r8forge.exe examples/calc.r8asm > calc.rot8 ; 62585 字符 +; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 + ." +; -> out 62 32 48 48 52 54 10 314777 步 "> 0046\n" +; build/Release/r8forge_tape_run.exe calc.rot8 -i "2047 3 / ." +; -> out 62 32 48 54 56 50 10 362281 步 "> 0682\n" +; build/Release/r8forge_tape_run.exe calc.rot8 -i "7 6 * ." +; -> out 62 32 48 48 52 50 10 299352 步 "> 0042\n" +; build/Release/r8forge_tape_run.exe calc.rot8 -i "9 4 - ." +; -> out 62 32 48 48 48 53 10 292030 步 "> 0005\n" +; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 + . 2047 3 / ." +; -> out 62 32 48 48 52 54 10 62 32 48 54 56 50 10 (14 个数,659759 步) +; +; "9 4 - ." 这一行和交接说明里写的 `out 62 32 48 48 53 48 10`("> 0050")差两位: +; 9 - 4 = 5,stage 3 的显示把它打成 "0005"(48 48 48 53),所以这里给的是实测值。 +; 0050 是 54 - 4 之类的答案,看着像那条期望值抄错了行(或者当年那份实现把窗口 +; 挪错了一格);其余四条和 BEHAVIOUR 里的三个例子都逐项对得上。 +; +; ------------------------------------------------------------ 四处不得不改的 +; +; (1) 结算顺序。按 docs/calc.md 的字面顺序(先把窗口 undigits 进 P,再把"旧 OP" +; 作用到 A 和 P 上),"12 34 + ." 会打出 0034:终结 "34" 的那个空格比 '+' 先到, +; 那会儿 OP 还是 0,结算成 A = P = 34,"12" 被盖掉;等 '+' 真到了,后面已经没有 +; 下一个数来触发结算。两寄存器的机器要给出 46,结算只能发生在**新操作数落地 +; 之前**(用旧的 P),并且 '.' 必须先把还没消费的 OP 结算掉。所以实际的规则是: +; +; flush(非数字字符 + HAVE 置位):先 A = A op_old P(OP=0 -> A = P),OP 归 0, +; **然后**才 P = clb_undigits(窗口); +; '.':强制走一次 flush(把待结算的 OP 结掉),再 P = A,再显示 A。 +; +; 这样 "12 34 +"、"12 34 + 5 * ."(= 230)、"12 34 + . 5 * ."(= 230)都对。 +; 代价:不打运算符、连着打两个数再 '.'("12 34 .")显示的是 A 里的 12 而不是 +; 刚打完的 34 —— 两格寄存器分不清"新操作数"和"要显示的数",这是这套状态自己 +; 的边界(协议里没有这种输入)。 +; +; (2) OP 的编码是 one-hot(1 加、2 减、4 乘、8 除、0 无),不是 0..4。结算因此是 +; 四条**互斥的单层 biz**(谁命中谁结算,再把"没有运算符"那个默认标志清掉), +; 不用写 if/else 嵌套 —— 嵌套的 `biz`/`rnz` 身体一旦净位移不为 0 就会把后面所有 +; `.tp` 指错格(AGENTS.md 第 2 条),这里用扁平分派就是为了不踩它。 +; +; (3) 循环配额。SPEC §7.5 的 clb_ones 只保证 A <= _CELL_SIZE,11 位的 cell 里最多 +; 11 个 1 —— 计划里的"128 个 1"造不出来。所以配额造满 11 个,循环体每轮用 +; `.tp CNT; rol; set_1` 把刚吃掉的那个 1 补回去(配额一直是全 1),EOF 一到 +; erase CNT,`endloop` 的 rnz 看到最低位是 0 就退出去。循环次数因此不再有 11 的 +; 上限,纸带长度却和次数无关(loop 的记账法见 SPEC §5.1)。 +; +; (4) 内存地图。calc_op 那张表,三处挪动,都是为了把纸带压进 65536: +; * clb_undigits 的 11 格草稿从 35..45 挪到 5..15,和 clb_digits 的草稿区 +; 叠着放。原表那样放时 REG(1..4)和草稿隔着 30 格,clb_undigits 里的 +; .tp 行走把这条宏从 9.6k 撑到 27k 字符。两套草稿本来就不会同时活着 +; (显示前会整块擦),叠在一起是免费的。 +; * 四个运算的落点和显示目标从 cell 0 挪到 20,紧挨着 A、P、共用草稿块。 +; `%synth` 的块是按"参数相邻"搜索出来的,落点放在 0 时每个位级块都要跨 +; 20 多格走过去,四个运算从 9.5k 涨到 16.7k 字符。 +; * 换出来的 35..45 当一次性分派标志;0 号格放 '\n' 的常量(显示时离 REG 近)。 +; +; 实测:这条纸带 62585 字符(`r8forge examples/calc.r8asm` 的输出长度),在 +; ROT-8-viz 的 INS_SIZE(65536) 以内,可以拿过去做可视化/第二意见;表头的 +; `; in` / `; out` 就是 r8forge_examples_test 用的那一组。 +%include "asm/lib.r8asm" +%include "asm/digits.r8asm" ; clb_digits(顺带带进 divmod / add_ip / raw_sub / raw_or) +%include "asm/undigits.r8asm" ; clb_undigits(顺带带进 mul / raw_add_nc) +%include "asm/raw_sub_nc.r8asm" ; clb_sub_nc +%include "asm/mul.r8asm" ; clb_mul +%include "asm/divmod.r8asm" ; clb_divmod +%include "asm/ones.r8asm" ; clb_ones +%include "asm/add_ip.r8asm" ; clb_nonzero / clb_add_ip +%include "asm/not_ip.r8asm" ; clb_not_ip + +; Macro load +; %1: Cell operand +; %2: Count value +; +; 先把整格清干净,再 `.xor` 上常数(`.xor` 是异或,不清格就变成和旧值异或)。 +%macro load 2 +erase %1 +.tp %1 +.xor %2 +%endmacro + +; Macro clb_zero_small +; %this: Cell operand +; +; 把只占第 0..3 位的小格(0..15)清成 0:四轮 set_0+ror 正好把四位各扫一遍。 +; 比 erase(44 字符)短;前提是第 4 位以上本来就是 0 —— OP 就是这种格子。 +%macro clb_zero_small 0 +%rep 4 + set_0 + ror +%endrep +%endmacro + +; ---- 内存地图(calc_op 那张表,挪过三处,见文件开头第 (4) 条)---- +.var NL 0 ; '\n' = 10(0 号格空出来放它:显示时离 REG 最近) +.var REG 1 ; REG..REG+3:4 位 ASCII 数字窗口,也是 clb_digits 的输出 +.var D3 REG+0 ; 窗口最高位 +.var D0 REG+3 ; 窗口最低位:新数字写这里 +.var S 5 ; S..S+12:clb_digits 的 13 格草稿(显示前整块擦) +.var SU 5 ; SU..SU+10:clb_undigits 的 11 格草稿,和上面那块叠着放 +.var BUF 16 ; copy 的缓冲格(每份 copy 前擦一遍;也在 S 区尾部) +.var FO0 17 ; "这一轮没有运算符"的默认标志(也在 S 区尾部) +.var GT 18 ; '>' = 62 +.var SP 19 ; ' ' = 32 +.var RES 20 ; 四个运算的落点 + 显示目标:clb_digits 会吃掉它 +.var A 21 ; 累加器:add/sub 的 A、mul 的 MC、divmod 的 N +.var P 22 ; 待结算的操作数:add/sub 的 B、mul 的 MUL、divmod 的 D +.var SC 23 ; SC..SC+6:四个运算共用的 7 格草稿 +.var MCi SC+0 ; 进位格:add/sub 的 Ci = mul 的 Ci = divmod 的 S+0 +.var PH SC+1 ; mul 的 PH +.var MCA SC+2 ; mul 的 MCA +.var MS SC+3 ; mul 的 S +.var MT SC+4 ; mul 的 T +.var MF SC+5 ; mul 的 F = divmod 的 buf +.var MNR SC+6 ; mul 的 NR +.var R 30 ; divmod 的余数(只在调用期间有意义) +.var C 31 ; 当前字符 +.var HAVE 32 ; 正在攒一个数 +.var OP 33 ; 待结算的运算符,one-hot:1 加、2 减、4 乘、8 除、0 无 +.var CNT 34 ; 主循环配额(11 个 1,每轮补回来) +.var T 46 ; 分派临时:t = C - 0x2A +; ---- 一次性分派标志:原来 clb_undigits 的草稿区(35..45),现在空出来了 ---- +.var FLAG 35 ; 命令树里 if/else 的"这一支走 else"标志 +.var B0 36 ; 命令树分派用的 0/1 位 +.var B1 37 +.var B2 38 +.var NEWOP 39 ; 命令解析出来的新 OP(flush 之后才搬进 OP) +.var WANT 40 ; 这一轮要显示 +.var RESET 41 ; 这一轮要清 A、P、OP +.var NONDIG 42 ; 这一轮不是数字(要走命令/终止符那一支) +.var ISCMD 43 ; 这一轮真的是六个命令字符之一 +; ---- 结算时把 OP 的四位搬进这四个 0/1 格(和命令树的 B0..B2 复用,不冲突: +; 命令树跑完才轮到结算)---- +.var F1 B0 ; OP 的 bit0:加 +.var F2 B1 ; bit1:减 +.var F3 B2 ; bit2:乘 +.var F4 44 ; bit3:除 + +; ================================ 开机 ================================ +; 三个常量格和空窗口只造一次。 +load GT 62 +load SP 32 +load NL 10 +%for k 4 + load REG + k 48 +%endfor + +; 主循环配额:11 个 1(11 位 cell 能造的上限),循环体每轮补回来。 +; clb_ones 要求 A <= _CELL_SIZE;这里 A 就是 11,正好是满格。 +.tp T +.xor 11 +clb_ones T CNT SC+1 SC+2 + +; ================================ 主循环 ================================ +loop CNT + ; ---- 续配额:loop 已经吃掉一个 1 并转了一格,转回来再补一个 ---- + ; CNT 进来是全 1;set_0+ror 之后是 0b0111...1,rol 回去成 0b111...0, + ; set_1 补成 0b111...1 —— 配额又满了,下一轮照旧。 + .tp CNT + rol + set_1 + + ; ---- 读一个字符 ---- + .tp C + inp + + ; ---- EOF:字符 0 就是输入用完了 ---- + ; clb_nonzero 给出"整格非零",clb_not_ip 把最低位取反 -> (C == 0)。 + ; 条件格借 R(divmod 的余数,这里闲着),clb_nonzero 的草稿格借 SC+0。 + .tp MCi + set_0 ; 草稿格只要求最低位干净 + clb_nonzero C R MCi ; R 的最低位 = (C != 0),C 保持原样 + clb_not_ip R ; R 的最低位 = (C == 0) + .tp R + biz + erase CNT ; 配额清零 -> endloop 的 rnz 不再跳回 + erase HAVE ; 输入完了,攒了一半的数不用再结算 + .tp R + set_0 ; 吃掉条件(biz/rnz 是循环对) + rnz + + ; ---- 是不是数字:bit4 == 1(和 stage 1 一样的一次 ror×4 + biz)---- + .tp NONDIG + set_1 ; 默认"不是数字";数字那一支会把它清掉 + .tp C + %rep 4 + ror + %endrep + .tp C + biz + ; ---- 数字:窗口整体右移一格,新字符落在 REG+3 ---- + ; 低地址是高位(stage 2 的约定):REG+0 <- REG+1 <- REG+2 <- REG+3 <- C, + ; 从高到低搬,先搬低地址那一格(它的源还没被盖掉)。 + %rep 7 + ror ; 4 + 7 = 11,转回原字符 + %endrep + .tp BUF + erase BUF + .tp REG + 1 + copy REG + 0 BUF ; REG+0 <- REG+1 + .tp BUF + erase BUF + .tp REG + 2 + copy REG + 1 BUF ; REG+1 <- REG+2 + .tp BUF + erase BUF + .tp REG + 3 + copy REG + 2 BUF ; REG+2 <- REG+3 + .tp BUF + erase BUF + .tp C + copy REG + 3 BUF ; REG+3 <- C(新数字) + + .tp C + set_0 ; 吃掉条件位(C 不用再留) + .tp HAVE + set_1 ; HAVE = 1 + .tp NONDIG + set_0 ; 是数字 -> 不走命令/终止符那一支 + .tp C ; 身体回到条件格(净位移 0) + rnz + ; 非数字:把 C 转回原字符(数字那一支已经转回来过,再转 7 次对它没意义, + ; 它死了;这段在纸带上只出现一次)。 + .tp C + %rep 7 + ror + %endrep + + ; ---- 非数字:命令解析 + flush + 命令动作 ---- + .tp NONDIG + biz + ; 一次性标志先清掉(不是 '.' 时不会有整块擦,得自己清) + .tp ISCMD + set_0 + .tp WANT + set_0 + .tp RESET + set_0 + + ; ---- 1) 命令解析:t = C - 0x2A,进位出 Ci = (C >= 0x2A) ---- + ; 先把"新 OP"算进 NEWOP,旧 OP 留给 flush 结算(见文件开头第 (1) 条)。 + load SC + 2 42 + .tp SC + 1 + set_0 + .tp SC + 1 + set_1 ; 进位入 = 1 -> S = C - 42 + clb_sub_nc C SC + 2 T SC + 1 + .tp SC + 1 + biz ; Ci=1 -> C >= 0x2A:可能是六个命令之一 + .tp ISCMD + set_1 + ; 剥 t 的三位(t 死了,随便破坏) + .tp B0 + set_0 + .tp B1 + set_0 + .tp B2 + set_0 + .tp T + clb_bit_mov B0 + .tp T + ror + clb_bit_mov B1 + .tp T + ror + clb_bit_mov B2 + ; ---- 六路判决:t = 0 '*'、1 '+'、2 ','、3 '-'、4 '.'、5 '/' ---- + .tp FLAG + set_1 + .tp B2 + biz ; bit2 = 1 -> t 在 {4,5} + .tp FLAG + set_1 + .tp B0 + biz ; t == 5 -> '/' + load NEWOP 8 + .tp FLAG + set_0 + .tp B0 + set_0 + rnz + .tp FLAG + biz ; t == 4 -> '.' + load NEWOP 0 + .tp WANT + set_1 + .tp HAVE + set_1 ; 强制走一次 flush,把待结算的 OP 结掉 + .tp FLAG + set_0 + rnz + .tp B2 + set_0 + rnz + .tp FLAG + biz ; bit2 = 0 -> t 在 {0,1,2,3} + .tp FLAG + set_1 + .tp B1 + biz ; bit1 = 1 -> t 在 {2,3} + .tp FLAG + set_1 + .tp B0 + biz ; t == 3 -> '-' + load NEWOP 2 + .tp FLAG + set_0 + .tp B0 + set_0 + rnz + .tp FLAG + biz ; t == 2 -> ',' + load NEWOP 0 + .tp RESET + set_1 + .tp FLAG + set_0 + rnz + .tp B1 + set_0 + rnz + .tp FLAG + biz ; bit1 = 0 -> t 在 {0,1} + .tp FLAG + set_1 + .tp B0 + biz ; t == 1 -> '+' + load NEWOP 1 + .tp FLAG + set_0 + .tp B0 + set_0 + rnz + .tp FLAG + biz ; t == 0 -> '*' + load NEWOP 4 + .tp FLAG + set_0 + rnz + .tp FLAG ; 这一支的条件格是 FLAG,身体必须回到 FLAG + set_0 + rnz + .tp FLAG + set_0 + rnz + .tp SC + 1 + set_0 ; 吃掉条件(回到条件格) + rnz + + ; ---- 2) flush:把攒着的数换出来,先把旧 OP 结算掉 ---- + .tp HAVE + biz + ; ---- 2a) 结算旧 OP:A = A op_old P(OP=0 -> A = P),结果落 RES ---- + ; OP 是 one-hot,四位各搬一个 0/1 格(clb_bit_mov 会吃掉源的那一位)。 + .tp OP + clb_bit_mov F1 + .tp OP + ror + clb_bit_mov F2 + .tp OP + ror + clb_bit_mov F3 + .tp OP + ror + clb_bit_mov F4 + .tp FO0 + set_1 ; 默认:没有运算符 -> A = P + ; 共用草稿块整块擦(mul 要求 7 格全干净;add/sub 只用 SC+0,也要 0) + %for k 7 + erase SC + k + %endfor + ; 四条互斥的单层判决:命中就结算,并清掉"没有运算符"那个默认标志。 + .tp F1 + biz + clb_add_nc A P RES MCi + .tp FO0 + set_0 + .tp F1 + set_0 + rnz + .tp F2 + biz + .tp MCi + set_1 ; 进位入 = 1 -> S = A - P + clb_sub_nc A P RES MCi + .tp FO0 + set_0 + .tp F2 + set_0 + rnz + .tp F3 + biz + clb_mul A P RES PH MCA MS MCi MT MF MNR + .tp FO0 + set_0 + .tp F3 + set_0 + rnz + .tp F4 + biz + clb_divmod A P RES R SC + .tp FO0 + set_0 + .tp F4 + set_0 + rnz + .tp FO0 + biz + ; OP == 0:只剩搬运 A = P(先写 RES,下面统一搬进 A) + .tp BUF + erase BUF + .tp P + copy RES BUF + .tp FO0 + set_0 + rnz + + ; ---- 2b) RES -> A ---- + .tp BUF + erase BUF + .tp RES + copy A BUF + + ; ---- 2c) 旧 OP 消费掉了 ---- + .tp OP + clb_zero_small + + ; ---- 2d) P = 窗口里的数,窗口复位成 "0000" ---- + clb_undigits REG P SU + %for k 4 + load REG + k 48 + %endfor + + ; ---- 2e) HAVE = 0 ---- + .tp HAVE + set_0 + rnz + + ; ---- 3) 是命令才换 OP ---- + .tp ISCMD + biz + .tp BUF + erase BUF + .tp NEWOP + copy OP BUF + .tp ISCMD + set_0 + rnz + + ; ---- 4) ',' 清 A、P(OP 上一步已经归 0)---- + .tp RESET + biz + .tp A + erase A + .tp P + erase P + .tp RESET + set_0 + rnz + + ; ---- 5) '.' 显示 A ---- + .tp WANT + biz + ; 累加器回到 P:下一轮 flush 的"旧操作数"就是它 + .tp BUF + erase BUF + .tp A + copy P BUF + ; clb_digits 进场要求 REG 和 S 干净(第一遍靠开机,之后每遍都擦) + %for k 4 + erase REG + k + %endfor + %for k 13 + erase S + k + %endfor + output GT + output SP + clb_digits RES REG S + output REG + 0 + output REG + 1 + output REG + 2 + output REG + 3 + output NL + ; 窗口复位:clb_digits 把四位数字写进 REG 了 + %for k 4 + load REG + k 48 + %endfor + .tp WANT + set_0 ; 身体回到条件格(WANT 也可能已被整块擦成 0) + rnz + + ; ---- 身体回到条件格 NONDIG(净位移 0)---- + .tp NONDIG + set_0 + rnz +endloop CNT