diff --git a/AGENTS.md b/AGENTS.md index b68e20f..662c888 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,6 +18,8 @@ PowerShell 的编码坑、git 身份和 push 提权、临时目录抽风…… * **有符号数已经做完**(SPEC §5.4 的约定、§7.10 的实现):`clb_digits_signed`(`-0042` 这种显示)、`clb_divmod_signed`(截断除法、余数随被除数)、计算器的一元负号 (`examples/calc.r8asm`)。加、减、乘按二补码天然正确,没有改。 +* **计算器是 3 格 RPN 栈**(64983 字符):数字压栈、运算符立刻算(弹二压一)、`.` 显示 + 栈顶但不动栈。旧的两寄存器版算不了嵌套(`1 2 + 3 4 * + .` 打 `0007`,现在 `0015`)。 * 全绿基线(这台机器约 1 分钟;命令见下)。 * 另一个仓库 `../ROT-8-viz`(fork `dsh/ROT-8-viz`,分支 `main`)是权威虚拟机 + 可视化:**默认 I/O 是串行 ASCII**(cell ≥ 8 位),数值 I/O 用 `-n` / `--numbers`, @@ -125,7 +127,7 @@ powershell -File tests\widths.ps1 # 位宽矩阵:每个位宽一 * **字节级程序"跑不动"先怀疑虚拟机**:仓库里曾有三份解释器把 `biz` 写成整格零判断,于是 所有字节级程序看起来都在死循环 —— 别再把库判成坏的。 -## 刚做完的一件大事:有符号数 +## 刚做完的两件大事:有符号数、RPN 栈 二补码、`-0042` 显示、截断除法、静默溢出,约定在 SPEC §5.4、实现在 §7.10。 `clb_digits_signed` / `clb_divmod_signed` 都是包装(真活还是 `clb_digits` / @@ -136,11 +138,16 @@ powershell -File tests\widths.ps1 # 位宽矩阵:每个位宽一 * 标志位在 `biz`/`rnz` 里必须被吃掉才能退出,所以"用完还要留"的符号位要搬到另一格 (`clb_bit_mov`),这就是为什么 `clb_divmod_signed` 要 T1、T2、F 三格。 +计算器接着换成了 **3 格 RPN 栈**(`S0` 栈顶 / `S1` / `S2`):运算符立刻算、`.` 是真 peek、 +一元负号按**栈深**判(`DEPTH == 0`)。旧的"两寄存器 + 待结算 OP"版本算不了嵌套 +(`1 2 + 3 4 * + .` 打 `0007`,现在是 `0015`)。**栈深只有 3 格是纸带逼出来的**: +一格一次 `copy`(约 500 字符),4 格就顶上 65536 了。挪栈的**次序不能反**(从高往低搬)。 + ## 下一步 候选、想清楚但没做的优化、以及工具侧的小尾巴都收在 [`TODO.md`](TODO.md); -`SPEC.md` §12 是"别试"的结论,不是待办。眼下最靠前的是 TODO 里的"交互计算":RPN 栈、 -终端纸带、迷你 `printf`。 +`SPEC.md` §12 是"别试"的结论,不是待办。眼下最靠前的是 TODO 里的"交互计算": +终端纸带(行缓冲 + 命令分派)、迷你 `printf`,以及栈要不要再深一格。 ## 索引 diff --git a/SPEC.md b/SPEC.md index 2a5833f..b69d0bf 100644 --- a/SPEC.md +++ b/SPEC.md @@ -373,7 +373,8 @@ endloop C * **溢出**:静默回绕,不显示错误(`-1024 / -1` 这种"商出了有符号范围"也一样)。 实现:§7.10 的两个包装宏(`clb_digits_signed`、`clb_divmod_signed`)+ -`examples/calc.r8asm` 里的一元负号(判据是 cell `NEED`,见那个文件开头)。 +`examples/calc.r8asm` 里的一元负号(判据是 cell `DEPTH`:栈空时 '-' 才是一元, +见那个文件开头)。 ## 6. 位级宏(一个 cell 装一位) @@ -741,9 +742,10 @@ N 被吃干净;`REG` 起 4 格、`S` 起 **13 格**必须连续且干净。纸 5. **四次取负**:|N|、|D|、R、Q 各一次,没有一次是多余的(Q 的符号靠第 3 条折成一次)。 单次 `clb_neg_ip` 是 110 字符,所以包装的 1191 里有 440 是这四次。 -配 `examples/calc.r8asm` 用时只剩"一元负号"一件:字符 45 在 cell `NEED`(在等一个新 -操作数:开头 / 刚结算 / 刚打完运算符 / 刚 `','`)时置 `NEG`、清 `ISCMD`,下一个打进 -窗口的数在 flush 里被 `clb_neg_ip` 取负。 +配 `examples/calc.r8asm` 用时只剩"一元负号"一件:字符 45 在**栈空**(cell `DEPTH` +的值为 0)时置 `NEG`、清 `ISCMD`,下一个压栈的数被 `clb_neg_ip` 取负。判据是栈深而 +不是"上一个字符是不是运算符":栈机器里 `1 2 + -` 的 '-' 是二元减法(a 弹空了就是 0, +`0 - 栈顶` 和取负同效),按"上一个是运算符"判会把那个负号悄悄吞掉。 --- diff --git a/TODO.md b/TODO.md index c54832a..8da352a 100644 --- a/TODO.md +++ b/TODO.md @@ -4,25 +4,27 @@ **从哪开始**;做完就删掉(历史在 git log 里)。`SPEC.md` §12 那张"已经确认走不通"的表是 **结论**,不是待办,别混进来。 -已经做完、从这份清单里移出去的:桌上计算器(`examples/calc.r8asm`,11 位 62624 字符、三方 -一致、位宽矩阵见 `tests/widths.ps1`)、`INP` 整格写入的语义修正、参考虚拟机支持 >64k 纸带、 -**有符号数三步走**(`clb_digits_signed` / `clb_divmod_signed` / 计算器的一元负号,契约在 -SPEC §5.4、实现在 §7.10,穷举在 `r8forge_byte_op_test` 的 `test_digits_signed` 2048 个值 -和 `test_divmod_signed` 4202 组)。 +已经做完、从这份清单里移出去的:桌上计算器(`examples/calc.r8asm`,11 位 **64983** 字符、 +三方一致、位宽矩阵见 `tests/widths.ps1`)、`INP` 整格写入的语义修正、参考虚拟机支持 >64k +纸带、**有符号数三步走**(`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`)。 ## 交互计算(下一步) - -* **RPN 栈**:现在的计算器是两寄存器(`A` 累加器 + `P` 待结算操作数),**没有栈**。 - `.tp` 是汇编期常量,所以只能做"固定 N 格 + 整体挪位"的假栈:每次 push ≈ N 个 `copy` - (约 500 字符/格)。65536 的纸带预算下 **16 深**可行(~12k 字符),4 深最划算;理论上 - 259 格内存能到 200 层,但一次 push 要 10 万字符,不现实。起点:把 `calc.r8asm` 的 `A/P` - 换成 4 格窗口先跑通,再看要不要 16。 * **终端纸带**:提示符 + 逐字符回显 + 行编辑(退格打印 `\b \b`)+ 命令分派。零件都在 - `drv/calc_*`(分派、数字攒取、显示、四则)——缺的是"长驻循环 + 落行 + 会话结束"。 + `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` 得再约定"串 + 长度"两格。 +* **栈再深一点**:现在是 3 格(`64983` 字符,离 65536 只剩 553)。4 格要多花一次 + push 的 `copy`(约 500)—— 要么先省掉别处的 500 字符,要么认了 65500+ 的纸带。3 格 + 已经够 `1 2 + 3 4 * +` 这种两层的嵌套;真要写长表达式就得再想办法。 ## 工具 diff --git a/docs/calc.md b/docs/calc.md index 5d2d7b5..d1c94c7 100644 --- a/docs/calc.md +++ b/docs/calc.md @@ -1,12 +1,15 @@ # 桌上计算器(RPN)设计与分阶段计划 -目标:`examples/calc.r8asm` —— 一条**长驻**的纸带,跑了就是一个计算器: +目标:`examples/calc.r8asm` —— 一条**长驻**的纸带,跑了就是一个 RPN 计算器 +(3 格栈,`S0` 是栈顶;有符号数): ``` > 12 34 + . -46 -> 2047 3 / . -682 +0046 +> 1 2 + 3 4 * + . +0015 +> -5 2 * . +-0010 > , ``` @@ -18,9 +21,9 @@ | 输入 | 动作 | |---|---| | `'0'..'9'` | 攒进 4 位数字缓冲(遇到终止符一次性 `clb_undigits` 换成整数,压栈) | -| `'*'` `'+'` `'-'` `'/'` | 弹两个、算、压回;`'-'` 在"还在等操作数"时是一元负号(§7) | -| `'.'` | 打印栈顶(`clb_digits_signed` + 4 个 `output`) | -| `','` | 清栈 | +| `'*'` `'+'` `'-'` `'/'` | 弹两个、算、压回;`'-'` 在**栈空**时是一元负号(§7) | +| `'.'` | 打印栈顶,**不动栈**(`clb_digits_signed` + 4 个 `output`) | +| `','` | 清栈(内容和深度一起归零) | | 其它(空格/回车) | 忽略(作为数字的终止符) | | **0**(EOF) | `erase` 掉循环计数器,主循环结束,纸带自然跑完 | @@ -34,17 +37,12 @@ t = C - 0x2A ; 命令: 0..5 数字: 6..15 ## 2. 内存地图 -| cell | 用途 | -|---|---| -| 0 | `C`:当前字符 | -| 1 | `T`:分派/临时 | -| 2..3 | `A`、`B`:运算操作数 | -| 4 | `HAVE`:栈里有没有数(0/1) | -| 5 | `CNT`:主循环计数器(开机造 W 个 1) | -| 6..9 | 数字缓冲 `D0..D3`(ASCII,右对齐) | -| 10..12 | 栈指针之外的栈深度标志?——v1 固定 4 深,见 §4 | -| 16..26 | 库草稿(`mul`/`divmod`/`digits`/`undigits` 的 S) | -| 32..43 | **常量区**(开机造一次):`TEN`(10)、`'0'`(48)、`11 个 1`、`2047`、`~10` | +## 2. 内存地图 + +这张表是**设计时的草图**(stage 1 那会儿的格号)。真的地图在 `examples/calc.r8asm` +的 `.var` 段里,比这张表细得多(每个格都有注释:栈、窗口、运算草稿、一次性标志、 +带符号数的三格)。两处已经对不上了,照文件走:`A`/`B` 现在是栈的 `S1`/`S0`, +"栈深度标志"是 `DEPTH`(0..3)。 ## 3. 分阶段计划(每步都能单点验证) @@ -59,15 +57,28 @@ t = C - 0x2A ; 命令: 0..5 数字: 6..15 5. **`examples/calc.r8asm`**:主循环 + EOF 退出 + `; in`/`; out` 头部,进 `examples_test`。 6. **有符号数**(做完,见 §7):显示换 `clb_digits_signed`、除法换 `clb_divmod_signed`、 加一元负号。`3 5 - .` → `-0002`、`-5 2 * .` → `-0010`、`-7 -2 / .` → `0003`。 +7. **RPN 栈**(做完,见 §4):3 格栈 + 运算符立刻算 + '.' 真 peek。`1 2 + 3 4 * + .` → `0015`。 -## 4. 栈:v1 固定 4 深,不用指针 +## 4. 栈:3 格,不用指针(做完) -`.tp` 是汇编期常量,没有间接寻址,所以**不要**做动态栈指针。v1 就用 4 个固定格 `S0..S3`: -压栈 = 整体往高地址挪一格(`copy` 从高到低,3 格),弹栈 = 反向。深度超过 4 就不管 -(压第 5 个覆盖最底下的,像老式计算器)。 +`.tp` 是汇编期常量、没有间接寻址,所以**不要**做动态栈指针。实际落地的是 3 个固定格 +`S0..S2`(`S0` = 栈顶): -代价:每次压/弹 3 个 `copy` ≈ 1.5k 字符纸带 + 每字符几百步。如果觉得贵,v0 可以只做两格 -(`A`、`B`),先把 `12+34=` 跑通,再加栈。 + push(新数) : S2 <- S1 ; S1 <- S0 ; 新数直接 clb_undigits 进 S0 + op(a=S1,b=S0): 算进 RES ; 然后 S1 <- S2 ; S2 清掉 ; RES -> S0 + '.' : 只显示 S0(真 peek,"1 2 3 . . ." 连打三次 3) + ',' : S0、S1、S2 和 DEPTH 一起清零 + +挪动的**次序不能反**(从高往低搬,否则还没搬的源被新值盖掉)。代价:push 2 次 `copy` +(~1k 字符)、一次运算 2 次 `copy` —— 这也是为什么是 3 格而不是计划里的 16:簿记下来 +一格一次 copy(~500 字符),16 格光 push 就要 8k,这条纸带直接冲到 7 万以上。 + +3 格够算 `1 2 + 3 4 * +`(最深用到 3);超过了就把最底下那个挤掉,跟老式计算器一样。 +**深度是要数的**(`DEPTH`:push +1、算一次 -1),一元负号的判据就是 `DEPTH == 0`。 +数深度的减法要挡住下溢(空栈再算一次会绕成全 1,之后的 '-' 就判错了)。 + +和旧的两寄存器版本(`A` 累加器 + `P` 待结算操作数)比,栈买到的是**嵌套**: +旧版 `1 2 + 3 4 * + .` 打 `0007`(第二个运算符把第一个覆盖了),现在打 `0015`。 ## 5. 步数预算(按 11 位实测的每例代价) @@ -79,9 +90,9 @@ t = C - 0x2A ; 命令: 0..5 数字: 6..15 | `/`(`clb_divmod_signed`) | ≤ 35,202(`byte_op_test` 全扫的最坏值;无符号版是 31,579) | | 打印(`clb_digits_signed`) | ≤ 117,606(`byte_op_test` 2048 个值的最坏值;无符号版 119,431) | -一行 `12 34 + .` 实测 **280,645** 步(有符号之前是 314,777 之类,`examples/calc.r8asm` -的头部写着这一轮的全部实测值)。`examples_test` 的上限是 2000 万步,所以会话控制在 -十几行以内(或把打印换成"里程表"版本,见下)。 +一行 `12 34 + .` 实测 **246,142** 步(换栈之前是 280,645 —— 少了"结算旧 OP"那一段; +`examples/calc.r8asm` 的头部写着这一轮的全部实测值)。`examples_test` 的上限是 +2000 万步,所以会话控制在十几行以内(或把打印换成"里程表"版本,见下)。 ## 6. 已知的坑(都在库里踩过) @@ -95,24 +106,27 @@ t = C - 0x2A ; 命令: 0..5 数字: 6..15 约定在 SPEC §5.4、宏在 SPEC §7.10。计算器这边只动三处: -1. **显示**:`clb_digits` → `clb_digits_signed`(负数自己打 '-',然后打 |A| 的定宽四位)。 +1. **显示**:`clb_digits` → `clb_digits_signed`(负数自己打 '-',然后打 |栈顶| 的定宽四位)。 2. **除法**:`clb_divmod` → `clb_divmod_signed`(截断、余数随被除数)。加、减、乘不用动, 二补码的模 2^W 运算天然对。 -3. **一元负号**:这是唯一需要新状态的地方。判据是 cell `NEED`: +3. **一元负号**:判据是 cell `DEPTH`(栈深): - > `NEED = 1` 表示"在等一个新操作数"(表达式开头 / 刚结算完 / 刚打完运算符 / 刚 `','`)。 - > 这时字符 45 是一元负号:置 `NEG`、清 `ISCMD`(第 3 步据此这一轮不改 `OP`);下一个 - > 打进窗口的数在 flush 里被 `clb_neg_ip` 取负。`NEED = 0` 说明 P 里已经有一个数等着 - > 结算,45 就是二元减号。 + > `DEPTH == 0`(空栈)时字符 45 是一元负号:置 `NEG`、清 `ISCMD`(第 3 步据此这一轮 + > 不算);下一个压栈的数在 step 2 里被 `clb_neg_ip` 取负。`DEPTH != 0` 时它就是 + > 二元减号。注意 `a` 弹空了就是 0,`0 - 栈顶` 正好等于取负 —— 所以栈深只有 1 时 + > '-' 的两义性没有实际后果。 **为什么不用"`HAVE == 0` 就当作一元负号"**(最初的计划就是那样):`HAVE` 只表示"正在攒 -数字",打完运算符之后它也是 0,于是 `2 * -5 .` 里的负号会被判成二元减号,`OP` 被改成 -2(减),结果错。`NEED` 多出来的信息就是"这个位置本来该出现一个操作数"。 +数字",打完运算符之后它也是 0,于是 `2 * -5` 里的负号会被判成二元减号,结果错。 + +**为什么也不用"上一个字符是运算符"**(两寄存器版本就是这么写的):栈机器里 +`1 2 + -` 的 '-' 是二元减法(拿栈顶去减那个"弹空了的 0"),按"上一个是运算符"判会把它 +当一元负号、那个负号就被吞掉了。所以判据必须是**栈的状态**(深度),不是输入的历史。 **作废的旧例子**:`2047 3 / .` → `0682` 是无符号时代的。有符号之后 2047 的位型是 -1, `-1/3` 截断成 0,现在打 `> 0000`;要 341 就写 `1023 3 / .`。能打的整数范围从 0..2047 变成 **-1024..1023**。 实测(`r8forge_tape_run`):`3 5 - .` → `> -0002`、`-5 2 * .` → `> -0010`、 -`-7 -2 / .` → `> 0003`、`-1024 2 / .` → `> -0512`、`0 3 - .` → `> -0003`。 -纸带 59519 → **62624** 字符(两套包装宏 + 判据,约 +3.1k)。 +`-7 -2 / .` → `> 0003`、`-1024 2 / .` → `> -0512`。纸带 59519 → **62624**(两套包装宏 ++ 一元负号)→ **64983**(再换成 3 格栈,+2.4k)。 diff --git a/examples/calc.r8asm b/examples/calc.r8asm index fd186af..5c7968f 100644 --- a/examples/calc.r8asm +++ b/examples/calc.r8asm @@ -1,30 +1,51 @@ ; in 12 34 + . ; out 62 32 48 48 52 54 10 ; -; calc —— 桌上计算器 stage 6(docs/calc.md §3 第 5 步 + 有符号数):把前面四块拼成 -; 一条常驻纸带。两个寄存器 A(累加器)和 P(待结算的操作数),没有栈:`inp` 一个字符、 -; 分派、算、`out` 全都在一条 `loop`/`endloop` 里,所以三者各只展开一次。 +; calc —— 桌上计算器 stage 7:3 格 RPN 栈 + 有符号数。`inp` 一个字符、分派、算、`out` +; 全都在一条 `loop`/`endloop` 里,所以三者各只展开一次。 ; ; 命令协议(docs/calc.md §1): ; '0'..'9' 攒进 D 位 ASCII 窗口(REG..REG+D-1,高位在低地址,见 stage 2) -; '*' '+' '-' '/' 把运算符记到 OP;'-' 在"还在等操作数"时是一元负号(见下) -; '.' 结算还没消费的 OP、显示 A、再把 A 留在 P 里 -; ',' 清 A、P、OP -; 空格/CR 等 只当数字的终止符 +; '*' '+' '-' '/' 立刻算:弹出栈顶两个(S1 op S0)、结果压回栈顶 +; '-' 在**空栈**时是一元负号(见下) +; '.' 显示栈顶,**不动栈** +; ',' 清栈(栈和深度一起归零) +; 空格/CR 等 只当数字的终止符:把窗口里的数压栈 ; 0(EOF) erase 主循环配额,跳出循环,纸带自然跑完 ; +; ---- 为什么是"栈":两寄存器版本算不了嵌套 ---- +; +; 上一版是 A(累加器)+ P(待结算操作数)两个格。它算得对 "12 34 + 5 *"(= 230), +; 但"1 2 + 3 4 * +"这种嵌套立刻垮:第二个运算符只能覆盖第一个,因为两个格放不下 +; "3"和"4"同时活着。RPN 要的就是"操作数先压着、用到才弹",所以换成一个 3 格的栈 +; (S0 = 栈顶、S1、S2 = 栈底),并且: +; +; * 运算符**立刻**算,不再有"待结算的运算符"(旧版的 OP 格因此删掉了); +; * '.' 是真 peek:显示栈顶但不弹,"1 2 3 . . ." 连打三次都是 3; +; * 深度用 DEPTH 数着(push +1、算一次 -1),只有"是不是 0"有意义 —— +; 一元负号的判据就是它。 +; +; 为什么只有 3 格:push/pop 都是"整体挪一格",一格一次 copy(约 500 字符纸带)。 +; push 两次 copy(S2<-S1、S1<-S0)、算完一次 copy(S1<-S2)+ 一次 copy 放结果, +; 3 格刚好把这条纸带压在 65536 以内(64983 字符)。20 格的理论深度见 TODO, +; 换算下来要 10 万字符,不现实。 +; +; ---- 一元负号:看栈深,不看上一个字符 ---- +; +; DEPTH == 0(空栈)时 '-' 是一元负号:置 NEG、清 ISCMD(第 3 步据此这一轮不算), +; 下一个压栈的数在 step 2 里被 clb_neg_ip 取负。DEPTH != 0 时它就是二元减号。 +; +; **判据不能是"上一个字符是不是运算符"**:栈机器里 "1 2 + -" 的 '-' 是二元减法 +; (a 弹空了就是 0,0 - 栈顶正好等于取负,效果和一元负号一样),把它当一元反而会 +; 把一个负号悄悄吞掉。也不能用 "HAVE == 0":HAVE 只是"正在攒数字",打完运算符 +; 之后它也是 0,会把 "2 * -5" 的负号判成减号。 +; ; ---- 有符号数(SPEC §5.4 的约定,实现在 §7.10)---- ; ; 加、减、乘天然按二补码正确,所以只补了两处显示/除法: -; * 显示走 clb_digits_signed:负数打 '-' 再打 |A| 的定宽四位(-2 -> "-0002"); +; * 显示走 clb_digits_signed:负数打 '-' 再打 |栈顶| 的定宽四位(-2 -> "-0002"); ; * '/' 走 clb_divmod_signed:截断除法、余数跟被除数同号(-7/2 -> -3 余 -1)。 ; -; 一元负号的判据是 **NEED**(= 在等一个新操作数:表达式开头、刚结算完、刚打完 -; 运算符、刚 ','),此时 '-' 置 NEG、清 ISCMD(第 3 步据此不改 OP),下一个数在 -; flush 里被取负。NEED = 0 说明 P 里已经有一个数在等着结算,'-' 就是二元减号。 -; 不用 "HAVE == 0" 当判据:HAVE 只是"正在攒数字",打完运算符之后 HAVE 也是 0, -; 那会把 "2 * -5 ." 里的负号判成二元减号。 -; ; "9 4 - ." 这一行和交接说明里写的 `out 62 32 48 48 53 48 10`("> 0050")差两位: ; 9 - 4 = 5,stage 3 的显示把它打成 "0005"(48 48 48 53),所以这里给的是实测值。 ; 0050 是 54 - 4 之类的答案,看着像那条期望值抄错了行(或者当年那份实现把窗口 @@ -38,77 +59,77 @@ ; 11 位下的行为。 ; ; 验证(r8forge_derive 和 r8forge_tape_run 两份实现逐项一致): -; build/Release/r8forge.exe examples/calc.r8asm > calc.rot8 ; 62624 字符 +; build/Release/r8forge.exe examples/calc.r8asm > calc.rot8 ; 64983 字符 ; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 + ." -; -> out 62 32 48 48 52 54 10 280645 步 "> 0046\n" +; -> out 62 32 48 48 52 54 10 246142 步 "> 0046\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "1023 3 / ." -; -> out 62 32 48 51 52 49 10 316724 步 "> 0341\n" +; -> out 62 32 48 51 52 49 10 282790 步 "> 0341\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "7 6 * ." -; -> out 62 32 48 48 52 50 10 267678 步 "> 0042\n" +; -> out 62 32 48 48 52 50 10 233072 步 "> 0042\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "9 4 - ." -; -> out 62 32 48 48 48 53 10 261075 步 "> 0005\n" +; -> out 62 32 48 48 48 53 10 226774 步 "> 0005\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "3 5 - ." -; -> out 62 32 45 48 48 48 50 10 261161 步 "> -0002\n" +; -> out 62 32 45 48 48 48 50 10 226854 步 "> -0002\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "-5 2 * ." -; -> out 62 32 45 48 48 49 48 10 268458 步 "> -0010\n" +; -> out 62 32 45 48 48 49 48 10 233865 步 "> -0010\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "-7 -2 / ." -; -> out 62 32 48 48 48 51 10 292612 步 "> 0003\n" +; -> out 62 32 48 48 48 51 10 261586 步 "> 0003\n" ; build/Release/r8forge_tape_run.exe calc.rot8 -i "-1024 2 / ." -; -> out 62 32 45 48 53 49 50 10 320646 步 "> -0512\n" +; -> out 62 32 45 48 53 49 50 10 287105 步 "> -0512\n" +; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 ." +; -> out 62 32 48 48 51 52 10 233771 步 "> 0034\n"('.' 会把还没压栈 +; 的 34 先压进去再显示) +; +; 栈真正买到的东西 —— 嵌套(旧的两寄存器版做不到): +; -i "1 2 + 3 4 * + ." -> "> 0015" 344537 步(旧版这一行打的是 "> 0007": +; 第二个 '+' 把 '* ' 覆盖掉了) +; -i "2 3 + 4 5 + * ." -> "> 0045" 348045 步 ; build/Release/r8forge_tape_run.exe calc.rot8 -i "12 34 + . 1023 3 / ." -; -> out 62 32 48 48 52 54 10 62 32 48 51 52 49 10 (14 个数,580046 步) +; -> out 62 32 48 48 52 54 10 62 32 48 51 52 49 10 (14 个数,512044 步) ; ; **唯一作废的旧例子是 "2047 3 / ."**:那是无符号时代的(2047/3 = 682)。 ; 有符号之后 2047 的位型就是 -1,-1/3 截断成 0,所以现在打 "> 0000";要 682 就用 ; "1023 3 / ." = 341。同样地,能打的整数范围变成 **-1024..1023**(比无符号少了 ; 一半),超出就按二补码回绕 —— 打 "2047" 得到的是 -1。 ; -; ------------------------------------------------------------ 四处不得不改的 -; -; (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 条),这里用扁平分派就是为了不踩它。 +; ------------------------------------------------------------ 不得不改的几处 ; +; (1) 栈的挪法。push 和 pop 都是"整体挪一格",**次序不能反**: +; push:S2 <- S1、S1 <- S0(从高往低搬,否则 S1 的新值会把还没搬的源盖掉); +; 新数直接 clb_undigits 进 S0 —— 它会先 erase N,所以 S0 脏的也行, +; 这样"新数落栈顶"就不用再从 RES 搬一道(省一次 copy,约 540 字符)。 +; pop :算完 S1 <- S2、S2 清掉,结果 RES -> S0。栈底那一格不一定是干净的: +; 深度 <= 2 时 S2 是死格,挪进 S1 也无所谓 —— 但',' 会把它擦掉, +; 所以"每次 push 都覆盖 S2"这条不变式一直成立。 +; (2) 运算符的编码还是 one-hot(1 加、2 减、4 乘、8 除),解析后搬进 F1..F4 +; 四条**互斥的单层 biz**(谁命中谁算,并置 POS);算完再由 POS 那个块统一收 +; 栈。不这么写就得每个分支各收一次栈(4 份挪位代码)。嵌套的 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(下面这些 -; 格号都按 11 位写;换位宽时窗口之后的每一格整体加 SHIFT = D-4,见 .var 段): +; (4) 内存地图。三处挪动都是为了把纸带压进 65536(下面这些格号都按 11 位写; +; 换位宽时窗口之后的每一格整体加 SHIFT = D-4,见 .var 段): ; * 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 近)。 +; * 运算的落点和显示目标从 cell 0 挪到 20,紧挨着栈(S0/S1 = 21/22)和共用 +; 草稿块。`%synth` 的块是按"参数相邻"搜索出来的,落点放在 0 时每个位级块 +; 都要跨 20 多格走过去,四个运算从 9.5k 涨到 16.7k 字符。 +; * 换出来的 35..45 当一次性分派标志;0 号格放 '\n' 的常量(显示时离 REG 近); +; S2 用回空出来的 33(旧 OP 格),离 S0/S1 只隔十来格 —— 一开始把 S2 摆在 +; 51,光行走就多花了 3.7k 字符。 ; -; 实测:这条纸带 **62624 字符**(`r8forge examples/calc.r8asm` 在 11 位下的输出 -; 长度;有符号数之前是 59519,两套带符号包装宏 + 一元负号的判据一共约 3.1k), -; 还在 ROT-8-viz 的 INS_SIZE(65536) 以内,可以拿过去做可视化/第二意见;表头的 -; `; in` / `; out` 就是 r8forge_examples_test 用的那一组。带符号数的三格 -; (T1=48、T2=49、SG=50)放在 46(T)之后的空地上:它们离 S 区(5..17)远, -; 但只在"四则结算"和"显示"两处被碰,不值得为省几十个行走字符去挤 35..45 那批 -; 一次性标志。 +; 实测:这条纸带 **64983 字符**(`r8forge examples/calc.r8asm` 在 11 位下的输出 +; 长度;两寄存器 + 有符号数是 62624,换栈又花了约 2.4k),还在 ROT-8-viz 的 +; INS_SIZE(65536) 以内,可以拿过去做可视化/第二意见;表头的 `; in` / `; out` +; 就是 r8forge_examples_test 用的那一组。带符号数的三格(T1=48、T2=49、SG=50) +; 放在 46(T)之后的空地上:它们离 S 区(5..17)远,但只在"四则运算"和"显示" +; 两处被碰,不值得为省几十个行走字符去挤 35..45 那批一次性标志。 %include "asm/lib.r8asm" %include "asm/digits.r8asm" ; clb_digits / clb_digits_signed(顺带带进 divmod / add_ip / inc_ip / raw_sub / raw_or) %include "asm/undigits.r8asm" ; clb_undigits(顺带带进 mul / raw_add_nc) @@ -130,18 +151,6 @@ erase %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) 条)---- ; 窗口长度 D 由位宽算出来(见文件开头的"位宽"一段):REG 占 REG..REG+D-1, ; 窗口之后的每一格都写成 `旧地址 + SHIFT`,SHIFT = D-4。11 位下 SHIFT = 0, @@ -155,12 +164,9 @@ erase %1 .var S 5+SHIFT ; S..S+12:clb_digits 的 13 格草稿(显示前整块擦) .var SU 5+SHIFT ; SU..SU+10:clb_undigits 的 11 格草稿,和上面那块叠着放 .var BUF 16+SHIFT ; copy 的缓冲格(每份 copy 前擦一遍;也在 S 区尾部) -.var FO0 17+SHIFT ; "这一轮没有运算符"的默认标志(也在 S 区尾部) .var GT 18+SHIFT ; '>' = 62 .var SP 19+SHIFT ; ' ' = 32 -.var RES 20+SHIFT ; 四个运算的落点 + 显示目标:clb_digits 会吃掉它 -.var A 21+SHIFT ; 累加器:add/sub 的 A、mul 的 MC、divmod 的 N -.var P 22+SHIFT ; 待结算的操作数:add/sub 的 B、mul 的 MUL、divmod 的 D +.var RES 20+SHIFT ; 运算落点 = 新读进来的数 = 显示源:clb_digits 会吃掉它 .var SC 23+SHIFT ; SC..SC+6:四个运算共用的 7 格草稿 .var MCi SC+0 ; 进位格:add/sub 的 Ci = mul 的 Ci = divmod 的 S+0 .var PH SC+1 ; mul 的 PH @@ -172,7 +178,7 @@ erase %1 .var R 30+SHIFT ; divmod 的余数(只在调用期间有意义) .var C 31+SHIFT ; 当前字符 .var HAVE 32+SHIFT ; 正在攒一个数 -.var OP 33+SHIFT ; 待结算的运算符,one-hot:1 加、2 减、4 乘、8 除、0 无 +; 33 号格原来是"待结算的运算符 OP",栈机器不再需要待结算状态,空着。 .var CNT 34+SHIFT ; 主循环配额(11 个 1,每轮补回来) .var T 46+SHIFT ; 分派临时:t = C - 0x2A ; ---- 一次性分派标志:原来 clb_undigits 的草稿区(35..45),现在空出来了 ---- @@ -180,14 +186,14 @@ erase %1 .var B0 36+SHIFT ; 命令树分派用的 0/1 位 .var B1 37+SHIFT .var B2 38+SHIFT -.var NEWOP 39+SHIFT ; 命令解析出来的新 OP(flush 之后才搬进 OP) -.var WANT 40+SHIFT ; 这一轮要显示 -.var RESET 41+SHIFT ; 这一轮要清 A、P、OP +.var NEWOP 39+SHIFT ; 命令解析出来的新 OP(one-hot:1 加、2 减、4 乘、8 除) +.var WANT 40+SHIFT ; 这一轮要显示栈顶 +.var RESET 41+SHIFT ; 这一轮要清栈 .var NONDIG 42+SHIFT ; 这一轮不是数字(要走命令/终止符那一支) .var ISCMD 43+SHIFT ; 这一轮真的是六个命令字符之一 -; ---- 结算时把 OP 的四位搬进这四个 0/1 格(和命令树的 B0..B2 复用,不冲突: -; 命令树跑完才轮到结算)---- -.var F1 B0 ; OP 的 bit0:加 +; ---- 命令解析出来的 one-hot 四位搬到这四个 0/1 格(和命令树的 B0..B2 复用, +; 不冲突:命令树跑完才轮到第 3 步)---- +.var F1 B0 ; NEWOP 的 bit0:加 .var F2 B1 ; bit1:减 .var F3 B2 ; bit2:乘 .var F4 44+SHIFT ; bit3:除 @@ -196,10 +202,19 @@ erase %1 ; 两套带符号宏不会同时活着(显示前整块擦、除法前后不用显示),所以 T1 既当 ; clb_divmod_signed 的取负草稿,也当 clb_digits_signed 的取负草稿。 .var NEG 45+SHIFT ; 下一个打进窗口的数是负数(一元负号) -.var NEED 47+SHIFT ; 在等一个新操作数:表达式开头 / 刚结算 / 刚打完运算符 / 刚 ',' +.var DEPTH 47+SHIFT ; 栈深(0..3);只有"是不是 0"有意义,一元负号的判据就是它 .var T1 48+SHIFT ; 带符号宏的取负草稿格(进来必须干净,结束是 0) .var T2 49+SHIFT ; clb_divmod_signed 的第二个符号格(同上) .var SG 50+SHIFT ; 符号标志格:两个带符号宏共用,只用最低位 +; ---- RPN 栈:3 格,S0 是栈顶 ---- +; 为什么 3 格而不是 TODO 里写的 16:push/pop 都是"整体挪一格",代价是 +; N 个 copy(每格 ~500 字符纸带)。3 格的 push 刚好三次 copy,纸带 ~1.7k; +; 16 格要 16 次(~8k),再加上两条 pop,这条纸带就要从 62.6k 涨到 70k 以上。 +; 3 格够算"1 2 + 3 4 * +"(最深用到 3),超了就像老式计算器那样把最底下那个挤掉。 +.var S0 21+SHIFT ; 栈顶:二元的 B、mul 的 MUL、divmod 的 D、'.' 的显示源 +.var S1 22+SHIFT ; 栈第二格:二元的 A、mul 的 MC、divmod 的 N +.var S2 33+SHIFT ; 栈底(33 号格正是空出来的旧 OP 格,离 S0/S1 只隔十来格) +.var POS 51+SHIFT ; 这一轮真的算了一次运算(四条互斥判决会置它) ; ================================ 开机 ================================ ; 三个常量格和空窗口只造一次。 @@ -209,9 +224,6 @@ load NL 10 %for k D load REG + k 48 %endfor -; 开机就在"等一个新操作数":这样 "-5 ..." 的第一个 '-' 才是 0-5 而不是 0-0。 -.tp NEED -set_1 ; 主循环配额:11 个 1(11 位 cell 能造的上限),循环体每轮补回来。 ; clb_ones 要求 A <= _CELL_SIZE;这里 A 就是 11,正好是满格。 @@ -280,8 +292,6 @@ loop CNT set_0 ; 吃掉条件位(C 不用再留) .tp HAVE set_1 ; HAVE = 1 - .tp NEED - set_0 ; 操作数已经开始了:后面的 '-' 是二元减号 .tp NONDIG set_0 ; 是数字 -> 不走命令/终止符那一支 .tp C ; 身体回到条件格(净位移 0) @@ -293,16 +303,18 @@ loop CNT ror %endrep - ; ---- 非数字:命令解析 + flush + 命令动作 ---- + ; ---- 非数字:命令解析 + 压数 + 运算 + 显示 ---- .tp NONDIG biz - ; 一次性标志先清掉(不是 '.' 时不会有整块擦,得自己清) + ; 一次性标志先清掉(不是 '.' / ',' 时不会有整块擦,得自己清) .tp ISCMD set_0 .tp WANT set_0 .tp RESET set_0 + .tp POS + set_0 ; ---- 1) 命令解析:t = C - 0x2A,进位出 Ci = (C >= 0x2A) ---- ; 先把"新 OP"算进 NEWOP,旧 OP 留给 flush 结算(见文件开头第 (1) 条)。 @@ -351,8 +363,6 @@ loop CNT load NEWOP 0 .tp WANT set_1 - .tp HAVE - set_1 ; 强制走一次 flush,把待结算的 OP 结掉 .tp FLAG set_0 rnz @@ -369,23 +379,26 @@ loop CNT set_1 .tp B0 biz ; t == 3 -> '-' - ; ---- 一元负号还是二元减号(见文件开头)---- - ; NEED = 1:还在等一个新操作数 -> 一元负号。置 NEG、清 ISCMD - ; (第 3 步据此这一轮不改 OP、也不重设 NEED),下一个打进窗口 - ; 的数在 flush 里被取负。NEED = 0:P 里已经有数等着结算 -> - ; 什么都不做,走下面默认的二元减号。 - .tp NEED - biz + ; ---- 一元负号还是二元减号:看栈深 ---- + ; DEPTH == 0(栈空)时 '-' 是一元负号:置 NEG、清 ISCMD + ; (第 3 步据此这一轮不算),下一个压栈的数在 flush 里取负。 + ; DEPTH != 0 时它就是二元减号。**判据不能用"上一个字符是 + ; 不是运算符"**:栈机器里 "1 2 + -" 的第二个 '-' 是二元 + ; 减法(拿 0 减栈顶),不是给下一个数加负号。 + .tp T + set_0 ; clb_nonzero 的草稿格只要求最低位干净 + clb_nonzero DEPTH F1 T ; F1 的最低位 = (DEPTH != 0) + .tp F1 + flb ; F1 的最低位 = (DEPTH == 0) + biz ; 栈空 -> 一元负号 .tp NEG set_1 .tp ISCMD - set_0 - .tp NEED - flb ; 吃掉条件 - .tp NEED ; 身体回到条件格 NEED + set_0 ; 这一轮没有运算符 + .tp F1 + flb ; 吃掉条件 + .tp F1 rnz - .tp NEED - set_1 ; 一元负号之后还是在等操作数 load NEWOP 2 .tp FLAG set_0 @@ -431,137 +444,148 @@ loop CNT set_0 ; 吃掉条件(回到条件格) rnz - ; ---- 2) flush:把攒着的数换出来,先把旧 OP 结算掉 ---- + ; ---- 2) 把攒着的数压进栈(一元负号在这里生效)---- .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 + ; push 的前半步:腾地方(S2 <- S1、S1 <- S0,从高往低搬,别把源盖掉) + .tp BUF + erase BUF + .tp S1 + copy S2 BUF + .tp BUF + erase BUF + .tp S0 + copy S1 BUF + ; 窗口 -> 栈顶。clb_undigits 进场自己会 erase N,所以 S0 脏的也行; + ; 这样"新数落栈顶"就不用再从 RES 搬一道(省一次 copy)。 + clb_undigits REG S0 SU + %for k D + load REG + k 48 + %endfor + ; 一元负号:只对刚读进来的这个数生效;草稿格借 BUF(它是干净的) + .tp NEG + biz + clb_neg_ip S0 BUF + .tp NEG + flb ; 吃掉条件(一个数只吃一次符号) + rnz + ; DEPTH += 1 + clb_inc_ip DEPTH BUF + .tp HAVE + set_0 + rnz + + ; ---- 3) 运算符:立刻算(吃掉栈顶两格,结果写 RES)---- + ; 注意这一步在压数之后:`12+` 会先把 12 压栈,再拿它和栈里那个数算。 + .tp ISCMD + biz + ; NEWOP 是 one-hot,四位各搬一格(clb_bit_mov 会吃掉源的那一位) + .tp NEWOP clb_bit_mov F1 - .tp OP + .tp NEWOP ror clb_bit_mov F2 - .tp OP + .tp NEWOP ror clb_bit_mov F3 - .tp OP + .tp NEWOP 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 - ; 四条互斥的单层判决:命中就结算,并清掉"没有运算符"那个默认标志。 + ; 四条互斥的单层判决:命中就算,并置 POS .tp F1 biz - clb_add_nc A P RES MCi - .tp FO0 - set_0 + clb_add_nc S1 S0 RES MCi + .tp POS + set_1 .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 + set_1 ; 进位入 = 1 -> S = A - B + clb_sub_nc S1 S0 RES MCi + .tp POS + set_1 .tp F2 set_0 rnz .tp F3 biz - clb_mul A P RES PH MCA MS MCi MT MF MNR - .tp FO0 - set_0 + clb_mul S1 S0 RES PH MCA MS MCi MT MF MNR + .tp POS + set_1 .tp F3 set_0 rnz .tp F4 biz - clb_divmod_signed A P RES R SC T1 T2 SG - .tp FO0 - set_0 + clb_divmod_signed S1 S0 RES R SC T1 T2 SG + .tp POS + set_1 .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 = 窗口里的数,窗口复位成 D 个 '0' ---- - clb_undigits REG P SU - %for k D - load REG + k 48 - %endfor - ; ---- 一元负号:只对刚读进来的这个数生效 ---- - ; NEG 是命令解析阶段置的;草稿格借 BUF(2b 的 copy 用完它就是干净的)。 - .tp NEG - biz - clb_neg_ip P BUF - .tp NEG - flb ; 吃掉条件(一个数只吃一次符号) - rnz - .tp NEED - set_0 ; P 里有数了:下一个 '-' 是二元减号 - - ; ---- 2e) HAVE = 0 ---- - .tp HAVE - set_0 - rnz - - ; ---- 3) 是命令才换 OP ---- - .tp ISCMD - biz - .tp BUF - erase BUF - .tp NEWOP - copy OP BUF - .tp NEED - set_1 ; 打完运算符就回到"等新操作数" .tp ISCMD set_0 rnz - ; ---- 4) ',' 清 A、P(OP 上一步已经归 0)---- + ; ---- 3b) 真的算过:结果压回栈顶,深度 -1 ---- + .tp POS + biz + ; 弹出两个 = 栈底下沉一格(S1 <- S2),S2 清掉;栈顶留给结果 + .tp BUF + erase BUF + .tp S2 + copy S1 BUF + .tp S2 + erase S2 + ; 结果回到栈顶 + .tp BUF + erase BUF + .tp RES + copy S0 BUF + ; 深度 -1:空栈时停在 0(再减会绕成全 1,一元负号就判错了) + .tp T + set_0 + clb_nonzero DEPTH F1 T ; F1 的最低位 = (DEPTH != 0) + .tp F1 + biz + clb_dec_ip DEPTH BUF + .tp F1 + flb + rnz + .tp POS + set_0 + rnz + + ; ---- 4) ',' 清栈 ---- .tp RESET biz - .tp A - erase A - .tp P - erase P + .tp S0 + erase S0 + .tp S1 + erase S1 + .tp S2 + erase S2 + .tp DEPTH + erase DEPTH .tp RESET set_0 rnz - ; ---- 5) '.' 显示 A ---- + ; ---- 5) '.' 显示栈顶(不动栈,也不动深度)---- .tp WANT biz - ; 累加器回到 P:下一轮 flush 的"旧操作数"就是它 + ; clb_digits_signed 会吃掉它的 N,所以先把栈顶抄一份进 RES .tp BUF erase BUF - .tp A - copy P BUF + .tp S0 + copy RES BUF ; clb_digits_signed 进场要求 REG、S、T1 干净、SG 的最低位是 0 ; (第一遍靠开机,之后每遍都擦;T1、SG 两个带符号宏都会还原成 0) %for k D @@ -581,8 +605,6 @@ loop CNT %for k D load REG + k 48 %endfor - .tp NEED - set_0 ; P 里现在有 A 这个数:下一个 '-' 是二元减号 .tp WANT set_0 ; 身体回到条件格(WANT 也可能已被整块擦成 0) rnz