Files
dsh 5c414292d2 calc: a terminal front end -- echo, backspace editing and a prompt
The calculator now behaves like the terminal tape from the previous commit:
every character is echoed, backspace edits the digit window, Enter commits the
line and prints the next prompt, and '.' puts its result on its own line:

    > 12 34 + .
    0046
    > 12<BS>3 .
    0013
    > ^D

It is not the terminal's line buffer moved over: the calculator consumes one
character at a time, and replaying a buffered line would mean unrolling the
engine once per buffer cell, which does not fit.  Line editing here is the
digit window: backspace shifts it right by one, pads a '0' in front, echoes
"space, backspace" and keeps accumulating.

Three things had to be learned the hard way, all recorded in docs/calc.md ?8:

* a borrowed constant cell gets eaten.  KBS (the 8 that backspace subtracts)
  lived in SC+5, and the operator step erases SC..SC+6 wholesale, so the first
  byte after an operator was treated as a backspace -- every character of
  "12 34 + ." came out as an erase.  It is now loaded right before each use.
  It also must not borrow R: the EOF test writes R every round.
* set_1 only forces the low bit; cells lent to the classifier have to be
  re-initialised each round rather than assumed clean.
* the prompt after Enter has to be printed before the command dispatch and the
  operators run, because EH (the "this was Enter" flag) borrows SC+3, which
  mul uses as scratch -- the first version printed a prompt after every
  multiplication.

The tape went 64983 -> 73624 characters (+8.6k: three copies for the window
shift alone are ~4.4k, the two subtracts ~3k).  That is past the old
ROT-8-viz INS_SIZE of 65536; the current VM sizes its buffer from the tape and
runs 112802 characters at 16 bits and 336304 at 32 bits, so only the
historical budget is gone, not the ability to run it.  Ducking under 65536
again would mean dropping line editing: echo plus the Enter prompt alone is
about +2.5k, still over.

Verified: ctest 8/8 (examples_test checks the new header stream), the width
matrix at 11, 16 and 32 bits (calc stream, terminal tape and the viz's serial
output all agree; 73624 / 112802 / 336304 characters), and docs/calc.md records
step counts for the whole session list -- "12 34 + ." is 287589 steps, about
17% more than before the front end.
2026-11-19 14:27:30 +08:00

729 lines
35 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 12 34 + .
; out 62 32 49 50 32 51 52 32 43 32 46 10 48 48 52 54 10 62 32 10
;
; calc —— 桌上计算器 stage 8:3 格 RPN 栈 + 有符号数 + 终端外壳(回显/退格/提示符)。
; `inp` 一个字符、分派、算、`out` 全都在一条 `loop`/`endloop` 里,所以三者各只展开一次。
;
; 命令协议(docs/calc.md §1):
; '0'..'9' 攒进 D 位 ASCII 窗口(REG..REG+D-1,高位在低地址,见 stage 2),
; 并且**原样回显**
; '*' '+' '-' '/' 立刻算:弹出栈顶两个(S1 op S0)、结果压回栈顶
; '-' 在**空栈**时是一元负号(见下)
; '.' 显示栈顶(另起一行),**不动栈**
; ',' 清栈(栈和深度一起归零)
; 8(退格) 删掉窗口最后一位(屏幕上是"空格 + 退格"),攒着的数继续攒
; 10(回车) 提交这一行(攒着的数压栈),然后打下一行的提示符 "> "
; 空格等其它 同回车但没有提示符 —— 只当数字的终止符
; 0(EOF) erase 主循环配额,跳出循环,纸带自然跑完
;
; ---- 终端外壳(stage 8 加的,之前打什么都看不见)----
;
; 开机打一次 "> ";之后每读到一个字符都原样回显;'.' 打完结果另起一行再补一个
; 提示符;回车 / 退格按终端的规矩来(退格是"空格 + 退格",屏幕上就擦掉一格)。
; 屏幕上因此是一条能读的会话:
;
; > 12 34 + .
; 0046
; > 12<退格>3 .
; 0013
; > ^D
;
; 代价:纸带 **64983 -> 73624 字符**(+8.6k)。退格那套(窗口右移三格 = 三次 copy、
; 再判一次 C == 8)占了大头,回显和提示符本身只要几百。**这条纸带因此超过了
; ROT-8-viz 的旧 INS_SIZE(65536)** —— 现在的虚拟机按纸带长度分配缓冲,16 位那版
; 96052 字符、32 位 284720 字符都照跑(SPEC §11),所以只是历史口径作废,不是跑不动。
; 想压回去就得砍行编辑:只留回显 + 回车提示符约 +2.5k,仍然在 65536 之上。
;
; ---- 为什么是"栈":两寄存器版本算不了嵌套 ----
;
; 上一版是 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 字符),终端又是 8.6k,所以现在
; 是 73624;4 格会再加一次 copy(约 500),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:负数打 '-' 再打 |栈顶| 的定宽四位(-2 -> "-0002");
; * '/' 走 clb_divmod_signed:截断除法、余数跟被除数同号(-7/2 -> -3 余 -1)。
;
; "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 里的三个例子都逐项对得上。
;
; 位宽:窗口的位数不是写死的。D = _CELL_SIZE * 30103 / 100000 + 1 是
; clb_digits / clb_undigits 的十进制位数(30103 ≈ log10(2)×1e5,W <= 64 都准),
; 11 位下 D = 4,窗口就是 REG..REG+3;换位宽时窗口变成 REG..REG+D-1,窗口之后
; 的每一格整体平移 D-4 格(下面的内存地图按 D 写)。**本文件只在默认 11 位下
; 验证过**:表头 `; in` / `; out` 这两行、以及下面的实测步数,都只记录
; 11 位下的行为。
;
; 验证(r8forge_derive 和 r8forge_tape_run 两份实现逐项一致):
; build/Release/r8forge.exe examples/calc.r8asm > calc.rot8 ; 73624 字符
; 下表的 out 是**整条 stream**(含回显和提示符),"屏幕"一列是它渲染出来的样子;
; `<BS>` 是字符 8,`<NL>` 是字符 10。
;
; -i "12 34 + ."
; -> out 62 32 49 50 32 51 52 32 43 32 46 10 48 48 52 54 10 62 32 10
; 287589 步 "> 12 34 + .\n0046\n> \n"
; -i "1023 3 / ." 328750 步 "> 1023 3 / .\n0341\n> \n"
; -i "7 6 * ." 265773 步 "> 7 6 * .\n0042\n> \n"
; -i "9 4 - ." 259465 步 "> 9 4 - .\n0005\n> \n"
; -i "3 5 - ." 259419 步 "> 3 5 - .\n-0002\n> \n"
; -i "-5 2 * ." 270848 步 "> -5 2 * .\n-0010\n> \n"
; -i "-7 -2 / ." 303572 步 "> -7 -2 / .\n0003\n> \n"
; -i "-1024 2 / ." 337753 步 "> -1024 2 / .\n-0512\n> \n"
; -i "12 34 ." 266477 步 "> 12 34 .\n0034\n> \n"('.' 会把
; 还没压栈的 34 先压进去再显示)
;
; 终端那两条编辑键(`<BS>` = 退格、`<NL>` = 回车):
; -i "12<BS>3 ." 215032 步 "> 12<BS>SP<BS>3 .\n0013\n> \n"
; (退格删掉 '2',再打 '3' 得 13)
; -i "12 34 +<NL>." 287652 步 "> 12 34 +<NL>> .\n0046\n> \n"
; (回车的换行先回显,提示符跟在后面)
; -i "1234<BS>." 223565 步 "> 1234<BS>SP<BS>.\n0123\n> \n"
; (窗口满 4 位,退格删最后一位)
; -i "<BS>5 2 * ." 265854 步 空窗口上退格是无害的(还是 0)
;
; 栈真正买到的东西 —— 嵌套(旧的两寄存器版做不到):
; -i "1 2 + 3 4 * + ." 411713 步 "> 0015"(旧版这一行打 "> 0007")
; -i "2 3 + 4 5 + * ." 415298 步 "> 0045"
; -i "12 34 + . 1023 3 / ." 601744 步 "> 0046\n> 0341\n"(两行)
;
; **唯一作废的旧例子是 "2047 3 / ."**:那是无符号时代的(2047/3 = 682)。
; 有符号之后 2047 的位型就是 -1,-1/3 截断成 0,所以现在打 "> 0000";要 682 就用
; "1023 3 / ." = 341。同样地,能打的整数范围变成 **-1024..1023**(比无符号少了
; 一半),超出就按二补码回绕 —— 打 "2047" 得到的是 -1。
;
; ------------------------------------------------------------ 不得不改的几处
;
; (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) 内存地图。三处挪动都是为了把纸带压进 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,紧挨着栈(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 字符。
;
; 实测:这条纸带 **73624 字符**(`r8forge examples/calc.r8asm` 在 11 位下的输出
; 长度;两寄存器 + 有符号数是 62624,换栈花约 2.4k,终端外壳再花 8.6k)。已经**超过**
; ROT-8-viz 的旧 INS_SIZE(65536),但现在的虚拟机按纸带长度分配缓冲,仍然可以拿过去
; 做可视化/第二意见(16 位那版 96052、32 位 284720 都在那边跑过);表头的
; `; in` / `; out` 就是 r8forge_examples_test 用的那一组 —— 注意它现在是带回显的
; 整条 stream。带符号数的三格(T1=48、T2=49、SG=50)放在 46(T)之后的空地上:
; 它们离 S 区(5..17)远,但只在"四则运算"和"显示"两处被碰,不值得为省几十个行走
; 字符去挤 35..45 那批一次性标志。终端那几格(CE/KBS/ED/KCi/EH/EG)借的是
; "分类那一刻正好空着"的格子(RES、SC 区、B0..),见下面 .var 段的注释。
%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)
%include "asm/raw_sub_nc.r8asm" ; clb_sub_nc
%include "asm/mul.r8asm" ; clb_mul
%include "asm/divmod.r8asm" ; clb_divmod / clb_divmod_signed
%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
; ---- 内存地图(calc_op 那张表,挪过三处,见文件开头第 (4) 条)----
; 窗口长度 D 由位宽算出来(见文件开头的"位宽"一段):REG 占 REG..REG+D-1,
; 窗口之后的每一格都写成 `旧地址 + SHIFT`,SHIFT = D-4。11 位下 SHIFT = 0,
; 下面就还是旧地图那张表;换位宽时窗口和它后面的一切整体跟着走。
.var D _CELL_SIZE * 30103 / 100000 + 1 ; 十进制位数:11 位 -> 4
.var NL 0 ; '\n' = 10(0 号格空出来放它:显示时离 REG 最近)
.var REG 1 ; REG..REG+D-1:D 位 ASCII 数字窗口,也是 clb_digits 的输出
.var D3 REG+0 ; 窗口最高位
.var D0 REG+D-1 ; 窗口最低位:新数字写这里
.var SHIFT D-4 ; 窗口之后的格子相对旧地图的偏移(11 位下是 0)
.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 GT 18+SHIFT ; '>' = 62
.var SP 19+SHIFT ; ' ' = 32
.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
.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+SHIFT ; divmod 的余数(只在调用期间有意义)
.var C 31+SHIFT ; 当前字符
.var HAVE 32+SHIFT ; 正在攒一个数
; 33 号格原来是"待结算的运算符 OP",栈机器不再需要待结算状态,空着。
.var CNT 34+SHIFT ; 主循环配额(11 个 1,每轮补回来)
.var T 46+SHIFT ; 分派临时:t = C - 0x2A
; ---- 一次性分派标志:原来 clb_undigits 的草稿区(35..45),现在空出来了 ----
.var FLAG 35+SHIFT ; 命令树里 if/else 的"这一支走 else"标志
.var B0 36+SHIFT ; 命令树分派用的 0/1 位
.var B1 37+SHIFT
.var B2 38+SHIFT
.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 ; 这一轮真的是六个命令字符之一
; ---- 命令解析出来的 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:除
; ---- 有符号数(SPEC §5.4 / §7.10)----
; 45、47 是 35..45 那批一次性标志里最后的空格;48..50 是 46(T)之后没用过的格子。
; 两套带符号宏不会同时活着(显示前整块擦、除法前后不用显示),所以 T1 既当
; clb_divmod_signed 的取负草稿,也当 clb_digits_signed 的取负草稿。
.var NEG 45+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 ; 这一轮真的算了一次运算(四条互斥判决会置它)
; ---- 终端那一套:回显、退格、回车(见文件开头的"终端外壳"一段)----
; 这几格借的是"分类那一刻正好空着"的格子 —— 退格/回车的判定跑在命令分派
; **之前**,那时 RES(20)、SC 区(23..29)、FLAG(35)、B0(36) 都还没用上。
; 地址挨着排不是洁癖:clb_sub_nc / clb_nonzero / copy 内部每一位都要在
; A、B、S、Ci 之间走,摆散了两千字符就变八千(第一版摆在 52..57,整条纸带
; 从 65k 涨到 80k)。**借来的格子必须每轮重装/重算**(KBS 会被 clb_sub_nc
; 吃掉、SC 区会被运算整块擦掉、EH 会被 mul 当草稿格写),别指望它们跨轮保持。
; 还有两个坑:`set_1` 只能把最低位变 1(高位残留不管);KBS 借 R(30) 那次
; **不行** —— EOF 那一支每轮都会把 R 写成 0/2047。
.var CE 20+SHIFT ; C 的副本(减法会吃掉被减数,命令解析还要用 C)
.var KBS 23+SHIFT ; 常量 8(退格):clb_sub_nc 会吃掉它,每轮用之前现装
.var ED 24+SHIFT ; 减法结果:C - 8(退格)、C - 10(回车)
.var KCi 25+SHIFT ; 这两个减法专用的进位格
.var EH 26+SHIFT ; "这一轮是退格 / 是回车"的标志
.var EG 27+SHIFT ; clb_nonzero 的草稿格
.var SHIFT_BUF 5+SHIFT ; 窗口右移用的 copy 缓冲(S+0,紧挨着 REG,分类时是空的)
; ================================ 开机 ================================
; 三个常量格和空窗口只造一次。
load GT 62
load SP 32
load NL 10
load KBS 8 ; 退格的常量格;每次减法之后要重装,这里先造一份
%for k D
load REG + k 48
%endfor
clb_puts GT 2 ; 第一行的提示符 "> "(之后每行末尾再补)
; 主循环配额: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
; ---- 是不是数字:bit4 == 1(和 stage 1 一样的一次 ror×4 + biz)----
.tp NONDIG
set_1 ; 默认"不是数字";数字那一支会把它清掉
.tp C
%rep 4
ror
%endrep
.tp C
biz
; ---- 数字:窗口整体右移一格,新字符落在 REG+D-1 ----
; 低地址是高位(stage 2 的约定):REG+0 <- REG+1 <- ... <- REG+D-1 <- C。
; %for k D-1 的 k = 0..D-2,每轮搬一对:REG+k <- REG+k+1。
; **次序必须升序**(先搬 REG+0 那一对):copy 先清目的格再逐位抄、源
; 保留,目的格在源下面才安全;按 D-2-k 降序先写 REG+D-2 的话,下一轮
; 的源已经被上一轮写过(试过:11 位下 "12 34 + ." 打出 "> 0350")。
%rep _CELL_SIZE - 4
ror ; 4 次测 bit4 + 这几次 = 整圈,转回原字符
%endrep
output C ; 回显(终端感:打什么看到什么)
%for k D-1
.tp BUF
erase BUF
.tp REG + k + 1
copy REG + k BUF ; REG+k <- REG+k+1
%endfor
.tp BUF
erase BUF
.tp C
copy REG + D - 1 BUF ; REG+D-1 <- C(新数字)
.tp C
set_0 ; 吃掉条件位(C 不用再留)
.tp HAVE
set_1 ; HAVE = 1
.tp NONDIG
set_0 ; 是数字 -> 不走命令/终止符那一支
.tp C ; 身体回到条件格(净位移 0)
rnz
; 非数字:把 C 转回原字符(数字那一支已经转回来过,再转 _CELL_SIZE-4 次
; 对它没意义,它死了;这段在纸带上只出现一次)。
.tp C
%rep _CELL_SIZE - 4
ror
%endrep
; ---- EOF:字符 0 就是输入用完了 ----
; clb_nonzero 给出"整格非零",clb_not_ip 把最低位取反 -> (C == 0)。
; 条件格借 R(divmod 的余数,这里闲着),clb_nonzero 的草稿格借 SC+0。
; 这一步放在"数字判定"之后,所以 C == 0 时那条数字化判定要先走一遍
; (它的分支进不去),换来的是下面这一支可以直接把 NONDIG 清掉 —— 否则
; 回车/EOF 后面那段命令分派会拿 C = 0 白跑一遍,回显还会多打一个 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 NONDIG
set_0 ; 这一轮到此为止:不回显、不进命令分派
.tp R
set_0 ; 吃掉条件(biz/rnz 是循环对)
rnz
; ---- 退格(8)和回车(10):终端的两条编辑键 ----
; 判据用 C 的副本 CE —— 命令分派那一步要把 C 减掉,这里不能先吃。
.tp SHIFT_BUF
erase SHIFT_BUF
.tp C
copy CE SHIFT_BUF
; 常量格每轮现装:KBS 借的是 SC+5,而运算那一步会把 SC..SC+6 整块擦掉
; ('.' 也是一条命令,所以显示之前的回合也会擦),装晚了就会拿 0 去减。
load KBS 8
.tp KCi
set_1 ; 进位入 1 -> S = A - B
clb_sub_nc CE KBS ED KCi ; ED = C - 8
clb_nonzero ED EH EG ; EH = (ED != 0)
.tp FLAG
set_1 ; 默认:不是退格
.tp EH
flb ; EH = (C == 8)
biz ; ---- 退格:擦掉屏幕上一格 + 窗口右移一格 ----
output SP
load KBS 8 ; 减法把常量格吃掉了,这里再装一份来打"退格"
output KBS ; "空格 + 退格" = 屏幕上前一个字符被抹掉
; 窗口是定宽补零的(REG+0 是最高位):右移一格就等于删掉最后一位,
; 前面补 '0'。**次序不能反**(从高地址往低搬,源还没被写过)。
%for k D-1
.tp SHIFT_BUF
erase SHIFT_BUF
.tp REG + D - 2 - k
copy REG + D - 1 - k SHIFT_BUF
%endfor
load REG 48
.tp FLAG
set_0 ; 命中:这一轮不走"非数字"那一支
.tp NONDIG
set_0 ; 退格不是终止符:攒着的数继续攒
.tp EH
set_0 ; 吃掉条件
rnz
; ---- 回车:ED 再减 2 就是 C - 10 ----
; **不在这里清 EH**:换行要先由下面那句回显打出去,提示符得等回显之后
; 才补(否则屏幕上会看到"> "跑到上一行末尾)。所以提示符放在 NONDIG
; 块之后,用 EH 当"这一轮是回车"的记号。
clb_dec_ip ED EG
clb_dec_ip ED EG
clb_nonzero ED EH EG
.tp EH
flb ; EH = (C == 10)
; ---- 非数字:命令解析 + 压数 + 运算 + 显示 ----
.tp NONDIG
biz
output C ; 回显(退格在上一支里自己打过"空格 + 退格"了)
; ---- 回车:换行刚刚回显出去,这里补下一行的提示符 ----
; **必须赶在命令分派和运算之前**:EH 借的是 SC+3,mul 会把它当草稿格
; 写成垃圾(第一版把提示符放在 NONDIG 块之后,乘法一过就乱打 "> ")。
.tp EH
biz
clb_puts GT 2
.tp EH
set_0 ; 吃掉条件
rnz
; 一次性标志先清掉(不是 '.' / ',' 时不会有整块擦,得自己清)
.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) 条)。
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 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 -> '-'
; ---- 一元负号还是二元减号:看栈深 ----
; 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 F1
flb ; 吃掉条件
.tp F1
rnz
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) 把攒着的数压进栈(一元负号在这里生效)----
.tp HAVE
biz
; 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 NEWOP
ror
clb_bit_mov F2
.tp NEWOP
ror
clb_bit_mov F3
.tp NEWOP
ror
clb_bit_mov F4
; 共用草稿块整块擦(mul 要求 7 格全干净;add/sub 只用 SC+0,也要 0)
%for k 7
erase SC + k
%endfor
; 四条互斥的单层判决:命中就算,并置 POS
.tp F1
biz
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 - B
clb_sub_nc S1 S0 RES MCi
.tp POS
set_1
.tp F2
set_0
rnz
.tp F3
biz
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 S1 S0 RES R SC T1 T2 SG
.tp POS
set_1
.tp F4
set_0
rnz
.tp ISCMD
set_0
rnz
; ---- 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 S0
erase S0
.tp S1
erase S1
.tp S2
erase S2
.tp DEPTH
erase DEPTH
.tp RESET
set_0
rnz
; ---- 5) '.' 显示栈顶(不动栈,也不动深度)----
.tp WANT
biz
; clb_digits_signed 会吃掉它的 N,所以先把栈顶抄一份进 RES
.tp BUF
erase BUF
.tp S0
copy RES BUF
; clb_digits_signed 进场要求 REG、S、T1 干净、SG 的最低位是 0
; (第一遍靠开机,之后每遍都擦;T1、SG 两个带符号宏都会还原成 0)
%for k D
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output NL ; 结果另起一行(提示符在开机/回车/上一行末尾打)
clb_digits_signed RES REG S T1 SG
%for k D
output REG + k
%endfor
output NL
clb_puts GT 2 ; 下一行的提示符 "> "
; 窗口复位:clb_digits_signed 把 D 位数字写进 REG..REG+D-1 了
%for k D
load REG + k 48
%endfor
.tp WANT
set_0 ; 身体回到条件格(WANT 也可能已被整块擦成 0)
rnz
; ---- 身体回到条件格 NONDIG(净位移 0)----
.tp NONDIG
set_0
rnz
endloop CNT
; ---- 收尾:最后的换行(屏幕上停在一个空行上,别把提示符丢在行尾)----
output NL