From c4048132cc2dc118c5e85145b209650bb57faaf6 Mon Sep 17 00:00:00 2001 From: dsh Date: Mon, 9 Nov 2026 16:17:39 +0800 Subject: [PATCH] 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. --- AGENTS.md | 19 +++++--- README.md | 5 +- SPEC.md | 45 +++++++++++++++-- asm/test.r8asm | 51 +++++-------------- asm/undigits.r8asm | 95 ++++++++++++++++++++++++++++++++++++ drv/undigits.r8asm | 18 +++++++ drv/undigits_byte.r8asm | 15 ++++++ examples/undigits_demo.r8asm | 56 +++++++++++++++++++++ tests/byte_op_test.cc | 40 +++++++++++++++ 9 files changed, 292 insertions(+), 52 deletions(-) create mode 100644 asm/undigits.r8asm create mode 100644 drv/undigits.r8asm create mode 100644 drv/undigits_byte.r8asm create mode 100644 examples/undigits_demo.r8asm diff --git a/AGENTS.md b/AGENTS.md index 3af8fdb..eed04ee 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -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`) | diff --git a/README.md b/README.md index e1581c3..a90164f 100644 --- a/README.md +++ b/README.md @@ -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) ``` diff --git a/SPEC.md b/SPEC.md index d9f25a9..3d10d61 100644 --- a/SPEC.md +++ b/SPEC.md @@ -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` | diff --git a/asm/test.r8asm b/asm/test.r8asm index 4838f23..96d077e 100644 --- a/asm/test.r8asm +++ b/asm/test.r8asm @@ -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 diff --git a/asm/undigits.r8asm b/asm/undigits.r8asm new file mode 100644 index 0000000..de5178c --- /dev/null +++ b/asm/undigits.r8asm @@ -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 diff --git a/drv/undigits.r8asm b/drv/undigits.r8asm new file mode 100644 index 0000000..82e1e19 --- /dev/null +++ b/drv/undigits.r8asm @@ -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 diff --git a/drv/undigits_byte.r8asm b/drv/undigits_byte.r8asm new file mode 100644 index 0000000..d1b9af5 --- /dev/null +++ b/drv/undigits_byte.r8asm @@ -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 diff --git a/examples/undigits_demo.r8asm b/examples/undigits_demo.r8asm new file mode 100644 index 0000000..60d44e7 --- /dev/null +++ b/examples/undigits_demo.r8asm @@ -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 diff --git a/tests/byte_op_test.cc b/tests/byte_op_test.cc index d39f5b8..c590a4e 100644 --- a/tests/byte_op_test.cc +++ b/tests/byte_op_test.cc @@ -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");