loop/endloop: the other half of clb_ones, runtime loop counts

clb_ones turns a count into that many ones, and these two macros spend those ones
one per iteration, so a tape can loop a number of times that only exists at run
time:

    clb_ones N C T F
    loop C
        ... body ...
    endloop C

\loop c\ is .tp c + biz + set_0 + ror: test the low bit, spend it, rotate the
next one into place.  \endloop c\ is .tp c + rnz.  No .anchor is used, so the
pair nests, and endloop puts dp back on the counter whatever the body did with
it; the body must not touch c, and c is all zeros once the loop is over.

Checked with verify_loop.r8asm (939 characters): N = 0..11 makes the body run
exactly N times, A = N and C = 0 -- including N = 0, where biz skips the body
entirely.  Nesting checked too: an inner loop rebuilt from a copy of its count
gives NO * MI (11 * 11 = 121, and 0 when either count is 0).

One trap found on the way, written into SPEC 5.1: in .r8asm source a loop is
spelled biz/rnz, not [ / ] -- the brackets are the tape encoding, and writing
them makes the assembler say " unknown macro [ \.
This commit is contained in:
dsh committed 2026-11-07 16:33:31 +08:00
1 parent bfad4b5d34
commit 3cfdad4313
4 files changed
+97 -1

No files matched your search

+3
View File
@@ -79,6 +79,7 @@ r8forge asm/test.r8asm # 应 exit 0,28729 字符(
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 # 字节级库:18 个操作穷举/抽样,1.5 秒
r8forge_macro_docs_test # asm/ 里每个宏的注释格式
```
@@ -416,6 +417,7 @@ 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_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 项 |
@@ -476,6 +478,7 @@ SPEC 第 136-150 行的标准宏前缀:
| `clb_not_ip` / `clb_inc_ip` / `clb_neg_ip` / `clb_dec_ip` / `clb_add_ip` | 同上再加 `_ip`(in place):结果回到原来的 cell,草稿 cell 由调用者传 |
| `clb_nonzero` | 破坏性的纯计算(把 B 抄成"非零"标志),不带 `_ip` 后缀 |
| `clb_ones` | 破坏性的纯计算(把"数量"展开成从末位起的一串 1,输入被吃干净);结果写在另一个 cell 里,所以也不带 `_ip` |
| `loop` / `endloop` | 结构性的**宏对**(开/收一个运行时循环),不带前缀;不开 anchor 所以能嵌套,收口后 dp 停在计数器上 |
| `clb_bit_mov` | 位级搬运,并且把源吃掉 |
| `bit_copy` / `copy` | 位级/字节级拷贝,缓冲由调用者传(历史命名,少了 `raw`) |
| `set_0` / `set_1` / `erase` / `rol` / `step` / `back` / `output` | 基础操作,不带前缀 |
+32 -1
View File
@@ -204,6 +204,8 @@ R8Forge 唯一的语言扩展:在汇编期现场搜出一段最短的块序列
| `bit_copy_to_buffer` | `bit_copy_to_buffer t`(`%this` 是 UnitBit) | 位拷到 Unit 的辅助格,`t` 是缓冲 | 3 | 40 |
| `copy_to_buffer` | `copy_to_buffer t`(`%this` 是 Unit) | 整 cell 拷到 Unit 的辅助格 | 3 | 497 |
| `output` | `output c` | `.tp` 到 `c` 再 `out`(输出整个 cell 的值) | 1 | 1 |
| `loop` | `loop c` | 动态循环开口:按 `c` 里 1 的个数跑,每轮吃掉一个 1 | 1 | 4 + `.tp` |
| `endloop` | `endloop c` | 动态循环收口(`rnz` 判 `c` 的最低位) | 1 | 1 + `.tp` |
要点:
@@ -213,6 +215,34 @@ R8Forge 唯一的语言扩展:在汇编期现场搜出一段最短的块序列
- `clb_bit_mov` 会把源位清掉 —— 它顺手就"吃条件",这正是 `set_0`/`clb_bit_mov`
身体里那个 `flb` 的作用(见 §2 第 2 条)。
### 5.1 动态循环:`clb_ones` 配 `loop`/`endloop`
`%rep` 是**汇编期**的。要按**运行期**算出来的次数循环,用这一对:
```
clb_ones N C T F ; C = N 个 1(N 被吃掉,§7.5)
loop C
... body ... ; 想干几次就干几次
endloop C
```
- `loop c` = `.tp c` + `biz` + `set_0` + `ror`:进来时测最低位,进去就**把这一位吃掉再转一格**,
把下一个 1 送到最低位。于是"配额"就是那串 1 的长度,一圈用掉一个。
- `endloop c` = `.tp c` + `rnz`。
- 三条约定:**循环体不许碰 `c`**;不开 `.anchor`,所以**能嵌套**;`endloop` 之后 dp 停在 `c`
上(不管循环体把 dp 指到哪儿,收口都会指回来)。
- 跑完 `c` 是 0。`n = 0` 时 `biz` 直接跳过,一圈不跑 ✓。
实测(`verify_loop.r8asm`,**939 字符**):`n = 0..11` 循环体正好跑 `n` 次,`A = n`、`C = 0`。
嵌套也验过:内层每轮用 `copy` 重新造一份计数器,`NO × MI` 得到 121(11×11)、`MI = 0` 时 0、
`NO = 0` 时 0 —— 就是普通的双层循环。
纸带代价是 `loop` 4 字符 + `endloop` 1 字符 + 两次 `.tp`(跟布局有关),**和次数无关**;
运行是 O(n)。
> 在 `.r8asm` 源码里循环要写 `biz` / `rnz`,**不是** `[` / `]` —— 后者是纸带上的编码。
> 直接手写 `[` 会报 `unknown macro '['`(`lib.r8asm` 里就是这么踩的)。
---
## 6. 位级宏(一个 cell 装一位)
@@ -433,8 +463,9 @@ clb_add_ip PH Ci S F ; 把进位加进高字节(Ci 被吃)
| `r8forge_synth_test examples/full_add.r8asm` | `%synth` 端到端:汇编 + 跑 8 种输入 | `all eight combinations ok` |
| `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` |
| `r8forge verify_set_0.r8asm` | `set_0` 只清 LSB | `-1 0=255 → 254`、`0=128 → 128` |
| `r8forge_macro_docs_test` | `asm/` 里 42 个宏的注释格式 | 全绿或报错行号 |
| `r8forge_macro_docs_test` | `asm/` 里 44 个宏的注释格式 | 全绿或报错行号 |
| `r8forge_tape_run <tape.rot8>` | 第二个解释器,直接跑纸带 | 与 `r8forge_derive` 对答案 |
| `r8forge_derive <src> -1/-2` | 拿汇编源码跑,打印 `out` / 非零 cell | 人工/脚本比对 |
+34
View File
@@ -151,3 +151,37 @@ copy copy_to_buffer_buf_1 %1
out
.tp before_output
%endmacro
; Macro loop
; %1: Cell C
;
; 动态循环的开口:按 C 里 1 的个数跑,每轮吃掉最低位的一个 1。
; C 一般由 clb_ones 从"次数"算出来 —— 这样循环次数就是**运行期**的值,
; 不再是汇编期的常数:
;
; clb_ones N C T F ; C = N 个 1,N 被吃成 0
; loop C
; ... body ...
; endloop C
;
; 两条约定:
; * 不开 anchor(所以能嵌套),`endloop` 之后 dp 停在 C 上;
; * 循环体不许碰 C。循环跑完 C 是 0 —— "配额"正好用完。
;
; 为什么循环体不能省掉那个 set_0: `biz`/`rnz` 判的是最低位,body 里不把它吃掉,
; `rnz` 看到还是 1 就跳回去,循环永远不结束。吃掉一格 = 用掉一轮配额。
%macro loop 1
.tp %1
biz
set_0
ror
%endmacro
; Macro endloop
; %1: Cell C
;
; loop 的收口。`rnz` 判的还是 C 的最低位,所以先把 dp 指回 C。
%macro endloop 1
.tp %1
rnz
%endmacro
+28
View File
@@ -0,0 +1,28 @@
%include "asm/ones.r8asm"
; 动态循环:循环次数是**运行期**才知道的值,不是汇编期常数。
;
; 0 号 cell 放次数 N(`r8forge_derive ... -1 0=N` 给),clb_ones 把它变成 N 个 1
; 的计数器 C,然后 loop/endloop 按 C 里 1 的个数跑 —— 每轮吃掉一个 1。
; 循环体每轮给 A 加一,所以跑完 A = N、C = 0。
;
; r8forge_derive verify_loop.r8asm -1 0=5 # out 应该是 5 0
; r8forge_derive verify_loop.r8asm -1 0=0 # out 应该是 0 0(一圈都不跑)
; r8forge_derive verify_loop.r8asm -1 0=11 # out 应该是 11 0
;
; 注意这里的"11 次"跟 `%rep 11` 的区别:那个在汇编期就定死了,这个能由前面
; 算出来的数据决定 —— 比如"乘以 MUL 的位数""输入字符串多长"这种。
.var N 0
.var C 1
.var T 2
.var F 3
.var A 4
clb_ones N C T F ; C = N 个 1
loop C
clb_inc_ip A T ; 每轮干一点活;这里就是 A += 1
endloop C
output A
output C