calc: stage 4 verified -- four operations, one shared scratch block

drv/calc_op.r8asm computes one case per operation and displays it with the stage 3
prompt, so the arithmetic path of the calculator is proven:

    +  12 34  ->  46        *  12 34   -> 408
    -  100 30 ->  70        /  2047 3  -> 682

    out 62 32 48 48 52 54 10 | 62 32 48 48 55 48 10
        62 32 48 52 48 56 10 | 62 32 48 54 56 50 10

tape 77356 characters, 599090 steps, tape_run and derive agree on all 28 values.

The useful result is the memory map: the four macros want different scratch, and
one 7 cell block (23..29) serves all of them -- add/sub use its first cell as the
carry, clb_mul uses exactly those 7 as Ci PH MCA S T F NR, clb_divmod uses the same
7 as its S.  They never run at the same time, so one erase before each call does
for all three.  The result cell is the display's N cell directly (add/sub write S
there, mul writes PL, divmod writes Q), which saves a copy per case.

Contract probes confirm SPEC: add leaves the carry output 0, sub reports no-borrow
1, mul keeps MC and eats MUL, divmod keeps N and D and puts the remainder in R.

Over ROT-8-viz's 65536 limit (four expanded clb_digits blocks), so it is verified
through the two r8forge machines only; stage 5 loops the display, so the real
calculator will be smaller than this.
This commit is contained in:
dsh committed 2026-11-11 11:18:41 +08:00
1 parent b2ba20b885
commit f9821f8989
1 file changed
+208
+208
View File
@@ -0,0 +1,208 @@
; calc_op —— 桌上计算器 stage 4:四个运算各跑一次,结果按 stage 3 的格式显示
; (docs/calc.md §3 第 4 步)。没有 inp、没有栈、没有主循环 —— 那是 stage 5。
;
; 四组,顺序固定:
; 12 + 34 = 46 -> "> 0046\n"
; 100 - 30 = 70 -> "> 0070\n"
; 12 * 34 = 408 -> "> 0408\n"
; 2047 / 3 = 682 -> "> 0682\n"
;
; 显示那一半照抄 drv/calc_disp.r8asm:'>'、' '、clb_digits 的 4 位 ASCII 数字、'\n';
; 三个常量格(GT/SP/NL)开机造一次,四个运算都不碰它们。
;
; 内存地图:
; cell 0 N 要显示的数字,**同时也是四个运算的落点**:
; add/sub 的 S、mul 的 PL、divmod 的 Q 都直接写这里,
; 于是"把结果搬进 N"这一步不用做(三个宏都不要求结果格干净:
; clb_add_nc 的 S 每 bit 先 set_0 再写,clb_mul 开头 erase PL,
; clb_divmod 开头 erase Q)。
; cell 1..4 REG clb_digits 写出的 4 个 ASCII 数字,高位在前、左边补 '0'
; cell 5..17 S clb_digits 的 13 格草稿(S+0=TEN、S+1=商、S+2=余数、
; S+3..S+9=divmod 草稿、S+10=轮数、S+11/S+12=add_ip 草稿)
; cell 18 '>' 62
; cell 19 ' ' 32
; cell 20 '\n' 10
; cell 21 A 操作数 A:add/sub 的 A、mul 的 MC、divmod 的 N
; cell 22 B 操作数 B:add/sub 的 B、mul 的 MUL、divmod 的 D
; cell 23..29 SC **共用草稿块,7 格**:
; add/sub 只借 SC+0 当进位格(CellBit);
; mul 的 7 个草稿格正好是它(PH/MCA/S/Ci/T/F/NR);
; divmod 的 7 格连续草稿 S 也正好是它。
; mul 和 divmod 不同时跑,所以能共用;每次调用前整块 erase。
; cell 30 R divmod 的余数(宏自己 erase,跑完是 1,之后没人用)
;
; 进位格就是 SC+0,三处都把它当真输入用:
; * 加法:进来 erase 成 0,出去再查一遍(下面那个运行期断言)—— 46 < 2048,
; 最高位不进位,所以出来必须是 0;
; * 减法:进来 set_1(S = A + ~B + 1 才是 A - B),出去是"没借位",
; 100 >= 30 所以出 1(SPEC §7.2);
; * 乘法:复用同一格当 clb_mul 的 Ci,要求进来是 0(擦整块时一起擦掉)。
;
; 运行期断言:加法之后进位出万一不是 0,那个条件体会多 output 一个数(进位格的值),
; out 就从 28 个数变成 29 个,一眼看出来。
;
; 擦草稿分两种,别混:
; * clb_digits 进来要求 REG(4 格)和 S(13 格)干净。第一遍开机本来就是 0,
; 后面三遍之前照 stage 3 的惯用法把这两块擦回 0(stage 3 两遍之间干的就是这件事);
; * mul / divmod 的共用草稿块每次调用前整块擦(mul 要求 7 格全干净;divmod 按
; SPEC §7.6 只要求 S+5 干净,这里整块擦,省得记哪格脏过)。
;
; 验证:
; build/Release/r8forge.exe drv/calc_op.r8asm
; build/Release/r8forge_tape_run.exe <tape.rot8>
; build/Release/r8forge_derive.exe drv/calc_op.r8asm 0
; out 62 32 48 48 52 54 10 62 32 48 48 55 48 10 62 32 48 52 48 56 10 62 32 48 54 56 50 10
;
; 四个运算的契约,用同布局的临时探针**实测**过(跑完就删,没进仓库):
; + :N=46,进位出 0,A、B 被吃成 0
; - :N=70,没借位 1(100 >= 30),A、B 被吃成 0
; * :PL=408、PH=0,MC=12 保留,MUL 被吃成 0,7 格草稿全用上
; / :Q=682、R=1,N=2047、D=3 都保留
; 探针 out:46 0 0 0 70 1 0 0 408 0 12 0 682 1 2047 3
;
; 这条纸带 77356 字符、599090 步(r8forge_tape_run 和 derive 的 out 逐项一致)。
;
; 注意:77356 > ROT-8-viz 的 INS_SIZE(65536),它的 read_tape 会截断,所以这份驱动
; 只在 r8forge_tape_run / r8forge_derive 上验。这不是可以顺手改掉的小事:单个
; clb_digits 展开是 13741 字符(drv/digits.r8asm 口径),四个显示块写死就 54964,
; 剩下 1 万多要装四个运算和 51 次 erase —— 除非把显示改成运行期循环(stage 5 的
; 主循环里 clb_digits 只展开一次,所以那边不会超),否则下不来。
%include "asm/lib.r8asm"
%include "asm/digits.r8asm" ; clb_digits(顺带带进 divmod / add_ip / raw_sub / raw_or)
%include "asm/raw_add_nc.r8asm" ; clb_add_nc
%include "asm/raw_sub_nc.r8asm" ; clb_sub_nc(顺带带进 clb_not_ip)
%include "asm/mul.r8asm" ; clb_mul
; Macro load
; %1: Cell operand
; %2: Count value
;
; 先整格清干净,再 `.xor` 上常数(`.xor` 是异或,不清格就变成和旧值异或)。
%macro load 2
erase %1
.tp %1
.xor %2
%endmacro
.var N 0 ; 要显示的数字,四个运算的结果都写这里(clb_digits 吃干净)
.var REG 1 ; REG..REG+3:clb_digits 的输出,4 个 ASCII 数字
.var S 5 ; S..S+12:clb_digits 的草稿区(13 格)
.var GT 18 ; '>' = 62
.var SP 19 ; ' ' = 32
.var NL 20 ; '\n' = 10
.var A 21 ; 操作数 A:add/sub 的 A、mul 的 MC、divmod 的 N
.var B 22 ; 操作数 B:add/sub 的 B、mul 的 MUL、divmod 的 D
.var SC 23 ; 共用草稿块 SC..SC+6(7 格)
.var MCi SC ; 进位格: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(移位寄存器的最高位)
.var MNR SC+6 ; mul 的轮数计数器
.var R 30 ; divmod 的余数
; ---- 常量区:三格只造一次 ----
load GT 62
load SP 32
load NL 10
; ================= 1) 12 + 34 = 46 =================
load A 12
load B 34
erase MCi ; 进位输入 = 0(真输入,不靠上一轮剩的)
clb_add_nc A B N MCi ; A、B 被吃干净,N = 46,MCi = 进位出
; 查进位出:46 < 2048 不进位,所以这里 MCi 必须是 0。
.tp MCi
biz
output MCi ; 只有进位出 = 1 才会多打一个数
.tp MCi
flb ; 把条件吃掉(biz/rnz 是循环对)
rnz
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; ================= 2) 100 - 30 = 70 =================
load A 100
load B 30
erase MCi
.tp MCi
set_1 ; 进位输入 = 1 -> S = A + ~B + 1 = A - B
clb_sub_nc A B N MCi ; A、B 被吃干净;MCi 出"没借位"(100 >= 30 -> 1)
; 第二遍之前:把 clb_digits 要的两块擦回开机状态(stage 3 的惯用法)。
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; ================= 3) 12 * 34 = 408 =================
%for k 7
erase SC + k ; mul 的 7 格草稿(含 Ci)进来必须干净
%endfor
load A 12 ; MC(乘完保留)
load B 34 ; MUL(结束为 0)
; 签名:clb_mul MC MUL PL PH MCA S Ci T F NR
clb_mul A B N PH MCA MS MCi MT MF MNR
; 积是 (PH:PL) = (0:408),低半就是 N;PH 那半不用(408 < 2048)。
; 第三遍之前:再擦一次 clb_digits 的两块。
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL
; ================= 4) 2047 / 3 = 682 =================
%for k 7
erase SC + k ; divmod 的 7 格草稿(SC+5 是拷贝缓冲,必须干净)
%endfor
load A 2047 ; N(除完保留)
load B 3 ; D(除完保留)
clb_divmod A B N R SC ; Q = 682 直接写进 N;R = 1(余数,不显示)
; 第四遍之前:再擦一次 clb_digits 的两块。
%for k 4
erase REG + k
%endfor
%for k 13
erase S + k
%endfor
output GT
output SP
clb_digits N REG S
output REG + 0
output REG + 1
output REG + 2
output REG + 3
output NL