calc: a 3 cell RPN stack -- nesting now works
The two register machine (A accumulator + P pending operand) could not nest:
"1 2 + 3 4 * + ." printed 0007 because the second operator overwrote the
first. The calculator now keeps a 3 cell stack (S0 is the top), operators run
immediately (pop two, push one), '.' is a real peek (repeated '.' shows the
same value, and it no longer flushes anything), and ',' clears both the stack
and the depth.
Depth is counted in DEPTH because the unary minus rule needs it: '-' is unary
iff the stack is empty. The previous "the previous character was an operator"
rule is wrong for a stack machine -- in "1 2 + -" the minus has to be a binary
subtraction (popping an empty cell yields 0, and 0 - top is exactly a
negation); treating it as unary would silently swallow the sign. The
"have == 0" rule from the original plan was already wrong for the old machine
("2 * -5" would lose its minus).
Sizing was driven by the tape: every push/pop is one copy per stack cell
(~500 characters), and the file has to stay under 65536. So 3 cells instead
of the 16 the TODO dreamed of: push is two copies (S2<-S1, S1<-S0), an
operator is two more (S1<-S2, then the result), and the new number is written
straight into clb_undigits' target cell (it erases N itself) so the extra
"result -> top" copy disappears -- that one was worth 540 characters. S2 sits
in cell 33, the freed OP cell: putting it at 51 cost 3.7k in walking alone.
64983 characters (was 62624) and 246142 steps for "12 34 + ." (was 280645 --
the old settle-the-pending-OP block is gone). The file header carries the
measured session list, the nesting cases, the stack move order (high to low,
or the source gets overwritten) and the older "2047 3 / ." caveat; docs/calc.md
gets the stack section, and SPEC 5.4/7.10 now point at DEPTH instead of NEED.
This commit is contained in:
1 parent
10f164b480
commit
0c218abf32
5 files changed
+293
-246
No files matched your search
@@ -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`,以及栈要不要再深一格。
|
||||
|
||||
## 索引
|
||||
|
||||
|
||||
@@ -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 - 栈顶` 和取负同效),按"上一个是运算符"判会把那个负号悄悄吞掉。
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -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 * +` 这种两层的嵌套;真要写长表达式就得再想办法。
|
||||
|
||||
## 工具
|
||||
|
||||
|
||||
+51
-37
@@ -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)。
|
||||
+212
-190
@@ -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
|
||||
|
||||
Reference in new issue
Block a user