asm/undigits: the inverse of clb_digits (ASCII decimal -> integer)
clb_digits could turn a number into four ASCII digits but nothing could turn
them back, so a program that stored or received a decimal string had no way
home. clb_undigits REG N S is that way back:
clb_digits N REG S ; 1234 -> 49 50 51 52
clb_undigits REG N S ; 49 50 51 52 -> 1234
Same number of digit cells as clb_digits writes (floor(W*log10 2) + 1, four at
11 bits), each read as its low 7 bits, so leading zeros are fine and garbage in
bits 7 and above is ignored. No validity checking, exactly like clb_digits: a
cell that is not '0'..'9' yields a deterministic but meaningless number, and the
documentation says so.
Horner in a runtime loop, one clb_mul in the whole tape:
N = 0 ; repeat 4: N = N*10 + digit ; shift the digit cells down one
9642 characters (minimum driver) -- smaller than clb_digits, because the reverse
direction needs no division.
Three things worth remembering, all found by testing rather than reasoning:
* c ^ 48 == c - 48 for '0'..'9' (the top two bits cancel, the low four are
identical), so subtracting '0' is one assembly time `.xor 48`: no
subtraction, no constant cell.
* The low-7-bit mask is `ror` 7, then set_0+ror per bit for the rest: the total
rotation is W, so the cell ends up facing the same way. The first version
wrote `rol; set_0; ror` in a %rep and cleared the same bit four times -- it
looks right and is undetectable on inputs whose high bits are already 0
(measured: 0|5<<7 came through as 688).
* The round counter must be erased before it is built: set_1 only clears the
bit it rotates to, so high ones left in the cell turn into extra rounds
(measured: dirty scratch gave 1234 -> 1564).
Tests and docs:
* r8forge_byte_op_test gains test_undigits: all 2048 values x {clean, garbage
in bits 7+} = 4096 cases, worst 36,481 steps.
* examples/undigits_demo.r8asm: "1234" -> 1234, "0007" -> 7, and a
digits -> undigits round trip on 2047; examples_test runs it like the rest.
* asm/test.r8asm calls it too (round trip inside the digits section). That
pushed the file over ROT-8-viz's 65536 instruction limit, so the redundant
second raw_add case, the reversed raw_sub case and the standalone divmod
section are gone -- every macro is still called at least once, and the file
is 64513 characters / 236439 steps / 93 outputs now.
* SPEC 7.9 (contract + the three traps), 10.2, 10.3 and 11, the AGENTS byte
table / verified list / naming table / baselines, and the README example
table all updated.
This commit is contained in:
1 parent
eacf6c01da
commit
c4048132cc
9 files changed
+292
-52
No files matched your search
@@ -38,10 +38,10 @@
|
||||
**当前基线(都通过,别弄坏)**:
|
||||
|
||||
```sh
|
||||
r8forge asm/test.r8asm # 58722 字符(调用每个标准宏 + 每个语言特性)
|
||||
r8forge_byte_op_test # 20 项(clb_divmod 16384 组、clb_digits 2048 个值)
|
||||
r8forge_examples_test # 13 个 example + asm/test.r8asm,头部 `; out` 逐个核对
|
||||
r8forge_macro_docs_test # 47 macros in 21 files
|
||||
r8forge asm/test.r8asm # 64513 字符(调用每个标准宏 + 每个语言特性)
|
||||
r8forge_byte_op_test # 21 项(clb_divmod 16384 组、clb_digits 2048 个值、clb_undigits 4096 组)
|
||||
r8forge_examples_test # 14 个 example + asm/test.r8asm,头部 `; out` 逐个核对
|
||||
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
|
||||
```
|
||||
@@ -125,12 +125,12 @@ clang-cl /nologo /std:c++20 /EHsc /O2 /I include src/r8asm.cc src/synth.cc tests
|
||||
自检:
|
||||
|
||||
```sh
|
||||
r8forge asm/test.r8asm # exit 0,58722 字符(全家桶:每个宏至少一次)
|
||||
r8forge asm/test.r8asm # exit 0,64513 字符(全家桶:每个宏至少一次)
|
||||
r8forge_synth_test examples/full_add.r8asm # all eight combinations ok
|
||||
r8forge verify_clb_bit_add_nc.r8asm # 4 cell 加法切片(进位进->出)
|
||||
r8forge verify_clb_bit_inc_nc.r8asm # 3 cell 自增切片,进位同样进->出
|
||||
r8forge_derive verify_loop.r8asm -1 0=5 # 动态循环:跑 5 次,out 应该是 5 0
|
||||
r8forge_byte_op_test # 字节级库:20 个操作穷举/抽样,这台机器约 10 秒
|
||||
r8forge_byte_op_test # 字节级库:21 个操作穷举/抽样,这台机器约 10 秒
|
||||
r8forge_macro_docs_test # asm/ 里每个宏的注释格式
|
||||
```
|
||||
|
||||
@@ -271,6 +271,7 @@ inline constexpr uint32_t kDefaultCellMask = (1u << kDefaultCellSize) - 1u;
|
||||
| **`clb_ones`(数量 → 从末位起 N 个 1,4 cell)** | `drv/ones.r8asm` | **742 字符**(带 output)/ **828**(最小驱动) | **12 个计数全对**(N=0..11) |
|
||||
| **`clb_divmod`(N div D / N mod D,11 cell)** | `drv/divmod.r8asm` | **4499 字符**(最小驱动)/ 4511(带 output) | **16384 组全对**(8 个除数 × 全部 2048 个被除数;固定 11 轮,最坏 32,383 步,`2047/1` 不再挂) |
|
||||
| **`clb_digits`(整数 → 4 位 ASCII 十进制,18 cell)** | `drv/digits.r8asm` | **13717 字符**(最小驱动)/ 13741(带 output) | **全部 2048 个值全对**(最坏 164,867 步;2047 是 14.5 万步) |
|
||||
| **`clb_undigits`(4 位 ASCII 十进制 → 整数,16 cell)** | `drv/undigits_byte.r8asm` | **9642 字符**(最小驱动)/ 9651(带 output) | **全部 2048 个值 × 干净/高位垃圾 2 种 = 4096 组全对**(最坏 36,481 步) |
|
||||
| **`raw_sub`(A-B,**保留 A、B**,Bo = 没借位,7 cell)** | `drv/raw_sub.r8asm` | **≈2900 字符** | **9 组抽样全对**;长除法要用它(`clb_sub_nc` 会把操作数吃掉) |
|
||||
| `asm/fibonacci.r8asm` | — | 11959 字符 | 跑出 13 项 `1 1 2 3 5 8 13 21 34 55 89 144 233` |
|
||||
|
||||
@@ -473,7 +474,7 @@ W 轮之后 `(PH:PL)` 就是积;`PL`(原来的 Q)被移空,所以 **MUL
|
||||
| 东西 | 结论 |
|
||||
|---|---|
|
||||
| 库里的 7 个位运算块(and/or/xor/inc/add) | 合成版比手写短(8 位时代 1714 → 1666;位宽改了以后位级块不受影响,长度变的是字节级那层) |
|
||||
| `asm/test.r8asm` 全家桶测试 | 11 位下 **58722 字符**、**215169 步**、100 个 `out`。`asm/` 里每个宏至少被调一次(含 `bit_raw_*`/`clb_bit_*`/`raw_*`/`clb_*_nc`/`clb_*_ip`/`clb_nonzero`/`clb_ones`/`clb_mul`/`clb_divmod`/`clb_digits`/`copy`/`bit_copy`/`*_to_buffer`/`loop`),语言特性也各走一遍(`%macro`/`%rep`/`%for`/`%synth` 的 map 和 stat/`.var`/`.anchor`/`step`/`back`)。头部 `; out ...` 是期望值,`r8forge_examples_test` 逐项核对;`derive`、`tape_run`、ROT-8-viz 三份实现一致。**必须留在 65536 条指令以下**(ROT-8-viz 的 `INS_SIZE`),所以 hash 只留两轮(尾 6 个值 `1322 5 82 0 1786 94`) |
|
||||
| `asm/test.r8asm` 全家桶测试 | 11 位下 **64513 字符**、**236439 步**、93 个 `out`。`asm/` 里每个宏至少被调一次(含 `bit_raw_*`/`clb_bit_*`/`raw_*`/`clb_*_nc`/`clb_*_ip`/`clb_nonzero`/`clb_ones`/`clb_mul`/`clb_divmod`/`clb_digits`/`copy`/`bit_copy`/`*_to_buffer`/`loop`),语言特性也各走一遍(`%macro`/`%rep`/`%for`/`%synth` 的 map 和 stat/`.var`/`.anchor`/`step`/`back`)。头部 `; out ...` 是期望值,`r8forge_examples_test` 逐项核对;`derive`、`tape_run`、ROT-8-viz 三份实现一致。**必须留在 65536 条指令以下**(ROT-8-viz 的 `INS_SIZE`),所以 hash 只留两轮(尾 6 个值 `1322 5 82 0 1786 94`) |
|
||||
| `clb_bit_add_nc`(4 cell 忽略进位切片) | flat 代价 **27**,完整全加器切片是 38;8/8 组合正确(与位宽无关) |
|
||||
| `clb_bit_inc_nc`(3 cell 自增切片) | 表 `0 4 4 2 0 4 4 2`(3 参数)缓存里就有,4 blocks;4/4 组合正确(与位宽无关) |
|
||||
| `clb_add_nc`(4 cell 加法) | 11 位下 937 字符,65536 组合全对;比 6 cell 的 `raw_add` 少 2 个 cell |
|
||||
@@ -488,11 +489,12 @@ W 轮之后 `(PH:PL)` 就是积;`PL`(原来的 Q)被移空,所以 **MUL
|
||||
| `clb_add_ip`(4 cell 原地加) | **726 字符**,2048 抽样全对;`raw_add` 2199 |
|
||||
| `clb_mul`(10 cell 乘法,积占两个 cell) | **3977 字符**,65536 组穷举全对;轮数只跟位宽有关(最坏 26123 步),跟 MUL 的值无关 |
|
||||
| `clb_ones`(4 cell,数量 → 从末位起 N 个 1) | **828 字符**(最小驱动),N=0..11 全对;`rol` + `set_1` 就是 `B = 2B + 1`,A 当计数器吃干净 |
|
||||
| `clb_undigits`(4 位 ASCII 十进制 → 整数) | **9642 字符**(最小驱动);4096 组(2048 个值 × 干净/高位垃圾)全对,最坏 36,481 步。反方向的 Horner:`.xor 48` 当"减 '0'"、`clb_mul` 每轮乘 10(纸带里只出现一次)。两个坑:掩码写成 `rol;set_0;ror` 等于没清(每轮清同一位)、计数器要先 `erase`(否则高位 1 会让循环多跑) |
|
||||
| `clb_ones` + `loop`/`endloop` | **动态循环**:次数由运行期数据决定。`verify_loop.r8asm` **939 字符**,N=0..11 正好跑 N 次(A=N、C=0,N=0 一圈不跑);嵌套也对(NO×MI,11×11=121)。见 SPEC §5.1 |
|
||||
| `bit_raw_add`(6 cell 全加器切片) | 保留 A、B;字节级 `raw_add` 2199 字符,65536 组合全对 |
|
||||
| `raw_and` / `raw_or` / `raw_xor` / `raw_inc` | 870 / 782 / 628 / 1619 字符,各 65536(inc 512)全对 |
|
||||
| `asm/fibonacci.r8asm` | 11959 字符,跑出 13 项(`… 89 144 233`),比 8 位时代多 3 项 |
|
||||
| `examples/` 里的例程 | **每组宏一份**,9 个程序(§10.3 的表)+ 4 个 `%synth` 例子。每个都是能跑的程序,头部 `; out ...` 是它打印什么;`r8forge_examples_test` 全部跑一遍逐项核对(缺那行也算失败),顺带打印纸带长度和步数 —— 它还会跑 `asm/test.r8asm`(全家桶) |
|
||||
| `examples/` 里的例程 | **每组宏一份**,10 个程序(§10.3 的表)+ 4 个 `%synth` 例子。每个都是能跑的程序,头部 `; out ...` 是它打印什么;`r8forge_examples_test` 全部跑一遍逐项核对(缺那行也算失败),顺带打印纸带长度和步数 —— 它还会跑 `asm/test.r8asm`(全家桶) |
|
||||
|
||||
## 已经确认走不通的(别重试)
|
||||
|
||||
@@ -559,6 +561,7 @@ SPEC 第 136-150 行的标准宏前缀:
|
||||
| `clb_ones` | 破坏性的纯计算(把"数量"展开成从末位起的一串 1,输入被吃干净);结果写在另一个 cell 里,所以也不带 `_ip` |
|
||||
| `clb_divmod` | 破坏性的纯计算(除/取模,商 Q、余数 R 各落在自己的 cell 里,`S` 起 7 格草稿由调用者传);N、D 现在**保留**,`clb` 指的是 Q 和草稿块会被覆盖 |
|
||||
| `clb_digits` | 破坏性的纯计算(整数 → 一串 ASCII 数字),输入被吃干净、结果写在连续区域里,所以不带 `_ip` |
|
||||
| `clb_undigits` | `clb_digits` 的逆(一串 ASCII 数字 → 整数),输入(数字区)被吃干净、结果写进另一个 cell,所以同样不带 `_ip`;不做合法性判定 |
|
||||
| `loop` / `endloop` | 结构性的**宏对**(开/收一个运行时循环),不带前缀;不开 anchor 所以能嵌套,收口后 dp 停在计数器上 |
|
||||
| `clb_bit_mov` | 位级搬运,并且把源吃掉 |
|
||||
| `bit_copy` / `copy` | 位级/字节级拷贝,缓冲由调用者传(历史命名,少了 `raw`) |
|
||||
|
||||
@@ -371,6 +371,7 @@ build/Release/r8forge_tape_run t.rot8 # 打印 out 和步数
|
||||
| `mul_demo.r8asm` | 82×141、2047×2047 的 `(PH:PL)` |
|
||||
| `divmod_demo.r8asm` | 2047/10、2047/1(旧版会 HANG) |
|
||||
| `digits_demo.r8asm` | 1234 和 7 的 4 位 ASCII |
|
||||
| `undigits_demo.r8asm` | 反方向:`"1234"` → 1234、`"0007"` → 7,以及 2047 的 digits → undigits 往返 |
|
||||
| `full_add*.r8asm` | `%synth` 的四种写法(`map` / `stat` / `layers` / 手写);`--synth-chars` 那版见上一节 |
|
||||
|
||||
`r8forge_examples_test` 会把它们全跑一遍,实跑的 `out` 和头部那行逐项比 —— 例程不会悄悄腐掉。
|
||||
@@ -503,7 +504,7 @@ cost(layer) = 2 # biz + rnz
|
||||
那些都是失败换来的结论,别重试。
|
||||
|
||||
要查"某个宏到底怎么调、吃什么、留什么、占几个 cell、纸带多长、谁验证的",看
|
||||
[`SPEC.md`](SPEC.md):`%synth` 的完整语法 + `asm/` 里 42 个宏的契约表。
|
||||
[`SPEC.md`](SPEC.md):`%synth` 的完整语法 + `asm/` 里 48 个宏的契约表。
|
||||
|
||||
## 构建
|
||||
|
||||
@@ -513,7 +514,7 @@ cmake --build build --config Release
|
||||
build\Release\r8forge.exe asm\test.r8asm > test.rot8 # 全家桶:每个标准宏至少一次
|
||||
build\Release\r8forge_synth_test.exe # 合成 + 跑虚拟机自检
|
||||
build\Release\r8forge_byte_op_test.exe # 字节级库穷举:65536×4 + 512 全对
|
||||
build\Release\r8forge_examples_test.exe # examples/ 13 个 + asm/test.r8asm,核对头部 `; out`
|
||||
build\Release\r8forge_examples_test.exe # examples/ 14 个 + asm/test.r8asm,核对头部 `; out`
|
||||
build\Release\r8forge_macro_docs_test.exe # 宏注释格式(asm/ 下每个 %macro)
|
||||
```
|
||||
|
||||
|
||||
@@ -586,6 +586,42 @@ N 被吃干净;`REG` 起 4 格、`S` 起 **13 格**必须连续且干净。纸
|
||||
整格取反,0 会变成 2047、1 会变成 2046(实测),不是 0/1。要用"没借位"这个
|
||||
现成语义,和 `clb_sub_nc` 保持一致。
|
||||
|
||||
### 7.9 `clb_undigits`:十进制字符串转整数(`clb_digits` 的逆)
|
||||
|
||||
`clb_undigits REG N S`:把 `REG` 起 **4 个连续 cell**(11 位;位数和 `clb_digits` 一样是
|
||||
`floor(W*log10(2)) + 1`,跟着位宽走)的低 7 位当成 ASCII 数字,拼成整数写进 `N`。
|
||||
**不做合法性判定**(和 `clb_digits` 一致):每格只取低 7 位,第 7 位以上直接忽略;
|
||||
超出 `'0'..'9'` 的输入算出一个确定但没意义的数。`REG` 起 4 格被吃干净(每轮把当前位当
|
||||
加数用掉、其余整体下移一格),`N` 被覆盖;`S` 起 **11 格**草稿,**脏的也行**(每轮都会重建
|
||||
或整格重写)。纸带 **9642 字符**(最小驱动)/ 9651(带 output),
|
||||
`test_undigits` 穷举**全部 2048 个值 × 2 种输入(干净 / 高位置垃圾)= 4096 组**
|
||||
(最坏 36,481 步)。
|
||||
|
||||
49 50 51 52 -> 1234 ("1234")
|
||||
48 48 48 55 -> 7 ("0007")
|
||||
2047 -> clb_digits -> "2047" -> clb_undigits -> 2047
|
||||
|
||||
做法是 Horner:`N = 0`,然后每位 `N = N*10 + 当前位`,数字区每轮整体**下移一格**,让下一位
|
||||
进 `REG+0`(和 §7.7 的挪位方向正好相反:那边往高地址挪、新数字写 `REG+0`)。
|
||||
和 `clb_digits` 一样用一个跑 4 次的运行期循环,所以乘 10 的 `clb_mul` 在纸带里只出现一次 ——
|
||||
反方向不需要除法,一位一位乘上去就够,整条比 `clb_digits` 小一半。
|
||||
|
||||
三个关键点:
|
||||
|
||||
* **`c ^ 48 = c - 48`**(`c` 在 `'0'..'9'` 内):`'0'+d` 与 48 异或,高两位抵消、低 4 位
|
||||
不变,所以"减 '0'"就是一条汇编期的 `.xor 48` —— 不用减法、不用常数格。
|
||||
* **低 7 位掩码**:`ror` 7 格把第 7 位转到最低位,再 `set_0` + `ror` 清掉第 7..W-1 位,
|
||||
一共转 W 格、结束时格子正好转回原位。第一版写成 `rol; set_0; ror` 循环,**每轮都把同一个
|
||||
bit 清一遍**,等于什么都没做(实测 `0|5<<7` 原样算进去,`out 688`);错误很隐蔽,因为
|
||||
它在"高位本来就是 0"的输入上完全正确。
|
||||
* **计数器要先 `erase`**:`set_1` 只清它转到的那一位,格子里原来的高位会变成额外的 1,
|
||||
循环就多跑几轮(实测脏草稿时 `1234 -> 1564`)。`clb_mul` 的 NR 没这个问题 ——
|
||||
它是 `%rep W { set_1; ror }`,每个位都会轮到一次。
|
||||
|
||||
`S` 的排法:`S+0` TEN(乘数 10,每轮重建)、`S+1` 轮数计数器、`S+2` copy 缓冲、
|
||||
`S+3..S+10` 是 `clb_mul` 的 PL/PH/MCA/S/Ci/T/F/NR —— **MC 直接就是 `N`,MUL 就是 `S+0`**,
|
||||
所以乘法器不用额外的两个 cell。每轮开始把 `Ci` 清 0(上一轮留下的是进位输出)。
|
||||
|
||||
存在的理由:`clb_sub_nc` 会吃掉 A 和 B,所以"重复减法"的除法器每轮都得 copy 两个
|
||||
副本;二进制长除法每轮都要拿同一个除数去比/减,必须有个不破坏操作数的减法。
|
||||
`clb_divmod` 换成长除法(§7.6)之后,每一轮开的就是它。另外实测过一次"预计算
|
||||
@@ -668,10 +704,10 @@ clb_add_ip PH Ci S F ; 把进位加进高字节(Ci 被吃)
|
||||
核对(同一个测试也跑 `examples/`,见 §10.3)。
|
||||
|
||||
段落:A 基础设施 → B 位级切片 → C `raw_*`(保留操作数)→ D `clb_*`(破坏性)→
|
||||
E 大宏(`clb_ones` / `loop` / `clb_divmod` / `clb_digits`)→ F 语言特性(自定义
|
||||
E 大宏(`clb_ones` / `loop` / `clb_digits` + `clb_undigits`)→ F 语言特性(自定义
|
||||
`%macro` + `%rep` + `%for` + 两份 `%synth`)→ G 两轮 hash(`clb_add_nc` + `clb_mul`)。
|
||||
|
||||
11 位下纸带 **58722 字符**、**215169 步**、100 个 `out`。两个约束值得记住:
|
||||
11 位下纸带 **64513 字符**、**236439 步**、93 个 `out`。两个约束值得记住:
|
||||
|
||||
* **必须留在 65536 条指令以下**:ROT-8-viz 的 `INS_SIZE`(`include/rot8/rot8.h`)是 65536,
|
||||
超了 `read_tape` 会截断,交叉验证就废了。所以 hash 只留两轮、每个宏只调一次。
|
||||
@@ -699,6 +735,7 @@ r8forge_tape_run t.rot8 # 打印 out 和步数
|
||||
| `mul_demo.r8asm` | §9 | 82×141、2047×2047 的 `(PH:PL)` |
|
||||
| `divmod_demo.r8asm` | §7.6 | 2047/10、2047/1(旧版第二个会 HANG),顺带证明 N、D 保留、草稿可以反复用 |
|
||||
| `digits_demo.r8asm` | §7.7 | 1234 和 7 的 4 位 ASCII |
|
||||
| `undigits_demo.r8asm` | §7.9 | `"1234"` → 1234、`"0007"` → 7,以及 2047 的 `digits → undigits` 往返 |
|
||||
| `full_add*.r8asm` | §3 `%synth` | 四种写法(`map` / `stat` / `layers` / 手写);输入全 0,所以 `out 0 0` |
|
||||
|
||||
`r8forge_examples_test` 会把 `examples/` 里所有 `.r8asm` 跑一遍,实跑的 `out` 和头部那行
|
||||
@@ -711,9 +748,9 @@ r8forge_tape_run t.rot8 # 打印 out 和步数
|
||||
|
||||
| 测试 | 覆盖 | 断言口径 |
|
||||
|---|---|---|
|
||||
| `r8forge_byte_op_test` | 20 个测试项 = 19 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§7.6、§7.7、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举、`clb_divmod` 8 个除数 × 全部 2048 个被除数 = 16384 组全穷举、`clb_digits` 全部 2048 个值全穷举),任一不符即退出码非 0 |
|
||||
| `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/` 里全部 13 个程序(9 组宏例程 + 4 个 `%synth` 例子,见 §10.3)**加上 `asm/test.r8asm`**(§10.2) | **按返回值**:每个头部 `; out ...` 与实跑 `out` 逐项相等,缺这一行也算失败 |
|
||||
| `r8forge_examples_test` | `examples/` 里全部 14 个程序(10 组宏例程 + 4 个 `%synth` 例子,见 §10.3)**加上 `asm/test.r8asm`**(§10.2) | **按返回值**:每个头部 `; out ...` 与实跑 `out` 逐项相等,缺这一行也算失败 |
|
||||
| `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` |
|
||||
|
||||
+13
-38
@@ -20,16 +20,18 @@
|
||||
; D 字节级 clb_* clb_add_nc / clb_inc_nc / clb_neg_nc / clb_sub_nc /
|
||||
; clb_not_ip / clb_inc_ip / clb_neg_ip / clb_dec_ip /
|
||||
; clb_nonzero / clb_add_ip(这些吃掉操作数)
|
||||
; E 大宏 clb_ones / loop+endloop / clb_divmod / clb_digits
|
||||
; E 大宏 clb_ones / loop+endloop / clb_digits + clb_undigits
|
||||
; F 语言特性 %macro + %rep + %for / %synth(map 和 stat 各一份)
|
||||
; G 老本行 两轮 hash(h = (h+c)*141 mod 2048),顺带 clb_mul
|
||||
;
|
||||
; 纸带必须留在 65536 条指令以下(ROT-8-viz 的 INS_SIZE),所以这里只放
|
||||
; "每个宏一次" + 两轮 hash;想加更多调用前先看长度,超了那边就跑不完整。
|
||||
; 现在 64513 字符、236439 步、93 个 out —— 离上限只剩 1k,加东西前先算账。
|
||||
; (clb_divmod 没有单独的显式段落:clb_digits 每一轮都在调它。)
|
||||
;
|
||||
; 没有 %include 的只有 asm/fibonacci.r8asm:那个文件是**程序**不是宏库,
|
||||
; 包含进来会把它的代码直接插进纸带。
|
||||
; out 1 0 2047 0 2 1 5 5 5 1 5 0 9 1 0 1 0 1 1 1 0 1 1 1 0 1 0 0 1 0 1 1 0 100 57 157 0 0 1 41 42 0 8 14 6 100 30 70 1 1978 0 157 0 0 1 2043 7 1 2042 42 2043 41 0 0 7 1 105 0 0 15 3 0 204 7 2047 10 49 50 51 52 0 7 10 11 12 20 21 7 7 7 0 1 0 1 1322 5 82 0 1786 94
|
||||
; out 1 0 2047 0 2 1 5 5 5 1 5 0 9 1 0 1 0 1 1 1 0 1 1 1 0 1 0 0 1 0 1 1 0 100 57 157 0 41 42 0 8 14 6 100 30 70 1 157 0 0 1 2043 7 1 2042 42 2043 41 0 0 7 1 105 0 0 15 3 0 49 50 51 52 0 1234 7 10 11 12 20 21 7 7 7 0 1 0 1 1322 5 82 0 1786 94
|
||||
%include "asm/lib.r8asm"
|
||||
%include "asm/raw_add.r8asm"
|
||||
%include "asm/raw_inc.r8asm"
|
||||
@@ -49,6 +51,7 @@
|
||||
%include "asm/mul.r8asm"
|
||||
%include "asm/divmod.r8asm"
|
||||
%include "asm/digits.r8asm"
|
||||
%include "asm/undigits.r8asm"
|
||||
|
||||
; Macro load
|
||||
; %1: Cell operand
|
||||
@@ -237,15 +240,7 @@ output R2 ; 57
|
||||
output R3 ; 157
|
||||
output Rco ; 0
|
||||
|
||||
; C2 raw_add 的进位:2047 + 1 = 0(回绕),进位出 1
|
||||
load R1 2047
|
||||
load R2 1
|
||||
erase Rci
|
||||
raw_add R1 R2 Rci R3 Rco Rtmp
|
||||
output R3 ; 0
|
||||
output Rco ; 1
|
||||
|
||||
; C3 raw_inc:41 + 1 = 42(进位输入是真正的 1,不是"隐含加一"),A 保留
|
||||
; C2 raw_inc:41 + 1 = 42(进位输入是真正的 1,不是"隐含加一"),A 保留
|
||||
load R1 41
|
||||
load Rci 1
|
||||
raw_inc R1 Rci R3 Rco Rtmp
|
||||
@@ -253,7 +248,7 @@ output R1 ; 41
|
||||
output R3 ; 42
|
||||
output Rco ; 0
|
||||
|
||||
; C4 raw_and / raw_or / raw_xor:12(1100) 和 10(1010)
|
||||
; C3 raw_and / raw_or / raw_xor:12(1100) 和 10(1010)
|
||||
load R1 12
|
||||
load R2 10
|
||||
raw_and R1 R2 R3 Rtmp
|
||||
@@ -263,7 +258,7 @@ output R3 ; 14
|
||||
raw_xor R1 R2 R3 Rtmp
|
||||
output R3 ; 6
|
||||
|
||||
; C5 raw_sub:100 - 30 = 70,Bo=1(A >= B,没借位)
|
||||
; C4 raw_sub:100 - 30 = 70,Bo=1(A >= B,没借位)
|
||||
load R1 100
|
||||
load R2 30
|
||||
erase Rbc
|
||||
@@ -275,16 +270,6 @@ output R2 ; 30
|
||||
output R3 ; 70
|
||||
output Rbo ; 1
|
||||
|
||||
; C6 反过来:30 - 100 = 1978(回绕),Bo=0
|
||||
load R1 30
|
||||
load R2 100
|
||||
erase Rbc
|
||||
erase Rci2
|
||||
erase Rbuf
|
||||
raw_sub R1 R2 R3 Rbo Rbc Rci2 Rbuf
|
||||
output R3 ; 1978
|
||||
output Rbo ; 0
|
||||
|
||||
; ---------------------------------------------------------- D 字节级 clb_*
|
||||
.var CA 30
|
||||
.var CB 31
|
||||
@@ -383,24 +368,12 @@ endloop LC
|
||||
output LCNT ; 3
|
||||
output LC ; 0(配额正好用完)
|
||||
|
||||
; E3 clb_divmod:2047 / 10 = 204 余 7,N、D 都保留
|
||||
.var DN 60
|
||||
.var DD 61
|
||||
.var DQ 62
|
||||
.var DR 63
|
||||
.var DS 64 ; S 起 7 格:64..70
|
||||
load DN 2047
|
||||
load DD 10
|
||||
clb_divmod DN DD DQ DR DS
|
||||
output DQ ; 204
|
||||
output DR ; 7
|
||||
output DN ; 2047
|
||||
output DD ; 10
|
||||
|
||||
; E4 clb_digits:1234 -> '1' '2' '3' '4'
|
||||
; E3 clb_digits -> clb_undigits:1234 -> '1' '2' '3' '4' -> 1234(往返)
|
||||
.var GN 80
|
||||
.var REG 81 ; REG 起 4 格
|
||||
.var GS 85 ; S 起 13 格:85..97
|
||||
.var N2 98
|
||||
.var US 99 ; clb_undigits 的 S 起 11 格:99..109
|
||||
load GN 1234
|
||||
clb_digits GN REG GS
|
||||
output REG ; 49
|
||||
@@ -408,6 +381,8 @@ output REG+1 ; 50
|
||||
output REG+2 ; 51
|
||||
output REG+3 ; 52
|
||||
output GN ; 0(输入被吃)
|
||||
clb_undigits REG N2 US
|
||||
output N2 ; 1234(拼回去)
|
||||
|
||||
; ------------------------------------------------------------ F 语言特性
|
||||
; F1 .var 里也能算:先把 BASE 定义出来,再用它定义 NEXT
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
; 十进制数字 -> 整数:clb_digits 的逆操作。
|
||||
;
|
||||
; clb_undigits REG N S
|
||||
; clb_digits N REG S ; 反方向,位数和格子约定一样
|
||||
;
|
||||
; REG 起 D 个连续 cell,每个 cell 的低 7 位当成一个 ASCII 数字('0'..'9');
|
||||
; 拼出来的整数写进 N。D = _CELL_SIZE*30103/100000 + 1,也就是
|
||||
; floor(W*log10(2)) + 1 —— 11 位下是 4 位十进制,和 clb_digits 写的位数
|
||||
; 完全一致,所以 digits -> undigits 能原样转回来(实测 0..2047 全部)。
|
||||
;
|
||||
; **不做合法性判定**(和 clb_digits 一样):每个 cell 只取低 7 位,再和 48
|
||||
; 异或 —— 对 '0'..'9' 来说 x^48 正好是 x-48(高两位相同),所以不需要减法。
|
||||
; 超出 '0'..'9' 的输入会算出一个确定但没有意义的数;高位(第 7 位以上)
|
||||
; 直接忽略,所以格子里的垃圾不会影响结果。
|
||||
;
|
||||
; REG 起 D 格被吃干净(每轮把当前位当加数用掉,其余整体下移一格),
|
||||
; N 被覆盖写入。S 起 11 格草稿:
|
||||
; S+0 TEN(乘数 10) ; S+1 轮数计数器 ; S+2 copy 的缓冲
|
||||
; S+3..S+10 clb_mul 的草稿(PL、PH、MCA、S、Ci、T、F、NR)
|
||||
;
|
||||
; 算法是 Horner:
|
||||
; N = 0
|
||||
; repeat D: N = N*10 + 当前位 ; 数字整体下移一格
|
||||
; 乘 10 用现成的 clb_mul(纸带里它只出现一次),所以整条纸带 ~6.6k,
|
||||
; 比 clb_digits 小一半 —— 反方向不需要除法,一位一位乘上去就够了。
|
||||
%include "asm/lib.r8asm"
|
||||
%include "asm/mul.r8asm"
|
||||
|
||||
; Macro clb_undigits
|
||||
; %1: Cell REG
|
||||
; %2: Cell N
|
||||
; %3: Cell S
|
||||
;
|
||||
; clb_digits 的逆:REG 起 D 格(低 7 位的 ASCII 数字)-> N。不做合法性判定。
|
||||
%macro clb_undigits 3
|
||||
.anchor before_clb_undigits
|
||||
|
||||
erase %2
|
||||
|
||||
; 轮数计数器:D 个 1(一个数字格一个),和 clb_digits 的计数法子一样。
|
||||
; 先 erase:set_1 只清它转到的那一位,格子里原来的高位会变成额外的 1,
|
||||
; 循环就会多跑几轮。
|
||||
erase %3+1
|
||||
.tp %3+1
|
||||
set_1
|
||||
%rep _CELL_SIZE * 30103 / 100000
|
||||
rol
|
||||
set_1
|
||||
%endrep
|
||||
|
||||
loop %3+1
|
||||
; ---- 当前位:只留低 7 位(ASCII),再 ^48 变成 0..9。
|
||||
; 先 ror 7 格把第 7 位转到最低位,再 set_0+ror 清掉第 7..W-1 位 ——
|
||||
; 一共转 W 格,结束时格子正好回到原来的方向。
|
||||
.tp %1
|
||||
%rep 7
|
||||
ror
|
||||
%endrep
|
||||
%rep _CELL_SIZE - 7
|
||||
set_0
|
||||
ror
|
||||
%endrep
|
||||
.xor 48
|
||||
|
||||
; ---- TEN = 10(位 1、3):绕整圈,在 1 和 3 各置一个 1
|
||||
erase %3+0
|
||||
.tp %3+0
|
||||
ror
|
||||
set_1
|
||||
%rep 2
|
||||
ror
|
||||
%endrep
|
||||
set_1
|
||||
%rep _CELL_SIZE - 3
|
||||
ror
|
||||
%endrep
|
||||
|
||||
; ---- (PH:PL) = N*10(N 是 MC,保持不变;MUL 被吃掉)
|
||||
clb_mul %2 %3+0 %3+3 %3+4 %3+5 %3+6 %3+7 %3+8 %3+9 %3+10
|
||||
|
||||
; ---- N = PL + 当前位。进位输入先清 0(上一轮留下的是进位输出)
|
||||
.tp %3+7
|
||||
set_0
|
||||
clb_add_nc %3+3 %1 %2 %3+7
|
||||
|
||||
; ---- 数字整体下移一格:从低到高搬(源还没被盖掉)
|
||||
%for k _CELL_SIZE * 30103 / 100000
|
||||
erase %3+2
|
||||
.tp %1 + k + 1
|
||||
copy %1 + k %3+2
|
||||
%endfor
|
||||
endloop %3+1
|
||||
|
||||
.tp before_clb_undigits
|
||||
%endmacro
|
||||
@@ -0,0 +1,18 @@
|
||||
; clb_undigits 的最小驱动:把 "1234"(ASCII 49 50 51 52)拼回 1234。
|
||||
%include "asm/undigits.r8asm"
|
||||
|
||||
.var REG 0
|
||||
.var N 4
|
||||
.var S 5
|
||||
|
||||
.tp REG
|
||||
.xor 49
|
||||
.tp REG+1
|
||||
.xor 50
|
||||
.tp REG+2
|
||||
.xor 51
|
||||
.tp REG+3
|
||||
.xor 52
|
||||
|
||||
clb_undigits REG N S
|
||||
output N
|
||||
@@ -0,0 +1,15 @@
|
||||
; clb_undigits 的驱动:0..3 是四个数字格(低 7 位 ASCII),4 是结果,5 起是草稿。
|
||||
;
|
||||
; r8forge_derive drv/undigits_byte.r8asm -1 0=49 1=50 2=51 3=52 # out 1234
|
||||
; r8forge_derive drv/undigits_byte.r8asm -1 0=48 1=48 2=48 3=55 # out 7
|
||||
;
|
||||
; 位数和 clb_digits 一致(_CELL_SIZE*30103/100000+1,11 位下 4 位)。
|
||||
%include "asm/undigits.r8asm"
|
||||
|
||||
.var REG 0
|
||||
.var N 4
|
||||
.var S 5
|
||||
|
||||
clb_undigits REG N S
|
||||
|
||||
output N
|
||||
@@ -0,0 +1,56 @@
|
||||
; clb_undigits:把一串 ASCII 十进制数字拼回整数 —— clb_digits 的反方向。
|
||||
;
|
||||
; 三个用例:
|
||||
; 1) 直接摆 "1234"(ASCII 49 50 51 52)-> 1234
|
||||
; 2) "0007" -> 7(前导 0 不是问题)
|
||||
; 3) 往返:2047 -> clb_digits -> "2047" -> clb_undigits -> 2047
|
||||
; (顺便把中间那四位 ASCII 打出来)
|
||||
; out 1234 7 50 48 52 55 2047
|
||||
%include "asm/digits.r8asm"
|
||||
%include "asm/undigits.r8asm"
|
||||
|
||||
; ---- 1) "1234"
|
||||
.var REG 0
|
||||
.var N 4
|
||||
.var S 5
|
||||
.tp REG
|
||||
.xor 49
|
||||
.tp REG+1
|
||||
.xor 50
|
||||
.tp REG+2
|
||||
.xor 51
|
||||
.tp REG+3
|
||||
.xor 52
|
||||
clb_undigits REG N S
|
||||
output N ; 1234
|
||||
|
||||
; ---- 2) "0007"
|
||||
.var REG2 20
|
||||
.var N2 24
|
||||
.var S2 25
|
||||
.tp REG2
|
||||
.xor 48
|
||||
.tp REG2+1
|
||||
.xor 48
|
||||
.tp REG2+2
|
||||
.xor 48
|
||||
.tp REG2+3
|
||||
.xor 55
|
||||
clb_undigits REG2 N2 S2
|
||||
output N2 ; 7
|
||||
|
||||
; ---- 3) 往返
|
||||
.var V 40
|
||||
.var DREG 41
|
||||
.var DS 45
|
||||
.var N3 58
|
||||
.var S3 59
|
||||
.tp V
|
||||
.xor 2047
|
||||
clb_digits V DREG DS
|
||||
output DREG+0 ; 50 '2'
|
||||
output DREG+1 ; 48 '0'
|
||||
output DREG+2 ; 52 '4'
|
||||
output DREG+3 ; 55 '7'
|
||||
clb_undigits DREG N3 S3
|
||||
output N3 ; 2047
|
||||
@@ -538,6 +538,45 @@ int test_digits(const std::string &file) {
|
||||
return bad;
|
||||
}
|
||||
|
||||
// clb_undigits: the inverse of clb_digits. Every value is fed in as its decimal
|
||||
// ASCII digits (most significant first, the same cells clb_digits writes) and
|
||||
// has to come back unchanged. Every second case also sets garbage in bits 7 and
|
||||
// above of each digit cell: the macro only looks at the low 7 bits, so the
|
||||
// answer must not move.
|
||||
int test_undigits(const std::string &file) {
|
||||
const std::string tape = assemble(file);
|
||||
std::cout << "clb_undigits: " << tape.size() << " characters\n";
|
||||
const int digs = int(kCellSize) * 30103 / 100000 + 1;
|
||||
int bad = 0, n = 0;
|
||||
size_t worst = 0;
|
||||
for (int v = 0; v < kCellMod; v++) {
|
||||
for (int garbage = 0; garbage < 2; garbage++) {
|
||||
machine m;
|
||||
int rest = v;
|
||||
for (int i = digs - 1; i >= 0; i--) {
|
||||
int digit = rest % 10;
|
||||
rest /= 10;
|
||||
if (garbage)
|
||||
digit |= 5 << 7; // bits the macro must ignore
|
||||
m.cells[size_t(i)] = uint16_t('0' + digit);
|
||||
}
|
||||
m.run(tape, 500'000);
|
||||
n++;
|
||||
if (m.steps > worst) worst = m.steps;
|
||||
const bool ok = m.finished && m.out.size() == 1 && m.out[0] == v;
|
||||
if (!ok) {
|
||||
bad++;
|
||||
if (bad <= 3)
|
||||
report("clb_undigits", v, garbage, m, std::to_string(v));
|
||||
}
|
||||
}
|
||||
}
|
||||
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " digits ok")
|
||||
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "")
|
||||
<< " (worst " << worst << " steps)\n";
|
||||
return bad;
|
||||
}
|
||||
|
||||
// clb_add_ip: A = A + B in place, B is eaten. The loop runs B times, so this
|
||||
// one is sampled rather than exhaustive -- 256 addends x 8 accumulators.
|
||||
int test_add_ip(const std::string &file) {
|
||||
@@ -621,6 +660,7 @@ int main(int argc, char **argv) {
|
||||
test_ones(drv + "ones.r8asm") +
|
||||
test_divmod(drv + "divmod.r8asm") +
|
||||
test_digits(drv + "digits.r8asm") +
|
||||
test_undigits(drv + "undigits_byte.r8asm") +
|
||||
test_add_ip(drv + "add_ip_byte.r8asm") +
|
||||
test_mul(drv + "mul_byte.r8asm") +
|
||||
test_sub_nc(drv + "raw_sub_nc_byte.r8asm");
|
||||
|
||||
Reference in new issue
Block a user