Files
R8Forge/README.md
T
dsh b4ea79ba91 %synth: the cost model is a run option, not a per block metric line
`metric chars|flat|blocks` inside %synth meant the same truth table could be
searched twice for two call sites, and every library block had to spell out
`metric flat` to avoid the default.  The cost model belongs to the whole
assembly, so it is one now:

    r8forge <file.r8asm>                  flat (layout free), the default
    r8forge --synth-chars <file.r8asm>    charge the real .tp walk

flat stays the default because a library block is expanded at dozens of call
sites with different layouts: only a layout free result can share one cache
entry, and it is usually within a few percent (full_add: 95 vs 90 characters).
The chars search is far more expensive (full_add: 415M states, ~21 minutes,
~10 GB), which is exactly why it should be asked for on the command line.

`metric blocks` goes with it: block count is a poor proxy for tape length (and
it was only another way to ask for mode layers).

Implementation: the metric lives in the assembler (ast::synth_metric, default
1) and is set through r8asm::set_synth_metric() before import_file; the CLI in
tests/asm_test.cc parses --synth-chars / --synth-flat.  The cache key already
carried metric, so the committed entries still hit: assembling the library and
asm/test.r8asm gives byte identical tapes (28729 characters, byte_op_test all
green, all 13 examples green, synth_test still 8/8).

A `metric` line now fails with a message that names the flag instead of being
silently ignored.  examples/full_add_flat.r8asm and full_add_flat_spaced.r8asm
are removed: they only existed to demonstrate the per block metric (the flat
default makes them copies of full_add.r8asm).

Also repairs the mojibake in README's metric section: an earlier tool wrote
\x0c / \x08 / \x0d where \f, \b and \r belonged, which ate characters out of
"flat", "blocks", "biz/flb/rnz" and "rnz".  The section is rewritten for the
flag, and the %synth numbers in README/SPEC/AGENTS now match what the tree
prints.

New cache entry c16bf083bb0ccbc8.txt is full_add's stat table with mode layers
+ flat, which full_add_stat.r8asm now produces.
2026-11-07 23:44:01 +08:00

23 KiB
Raw Blame History

R8Forge

R8ASM 汇编器 + R8Veritas 搜索器,合成一个仓库。

搜索器不再是独立程序:%synth 是汇编期指令,描述一张真值表,汇编器现场搜出最短的块 序列直接拼进纸带。代价模型和发射器从此是同一份代码,不用再维护两套「这个块要花多少条 指令」的估算。

用法

%include "asm/lib.r8asm"

%synth fulladd
	params 6
	map  0 1 1 2 1 2 2 3    ; 8 个输入组合各自的输出位取值,%1..%3 是输入
	layout 0 1 2 3 4 5      ; 可选:各参数所在 cell 的地址(默认 0..n-1)
%endsynth

.var A 0
.var B 1
.var Ci 2
.var S 3
.var Co 4
.var T 5

fulladd A B Ci S Co T       ; 这一行展开成汇编期合成的最短纸带
output S
output Co

%synth 会跑两遍:先用层数搜索拿到一个解(7 秒),再拿它的代价当上界跑纸带长度搜索 (Dijkstra),第二遍弹出目标即停。默认按"布局无关"口径搜(见下一节),所以库里那些块 的结果早就缓存在 .r8forge_cache/ 里;想按真实 .tp 行走重新搜,加 --synth-chars。

layout 只在 --synth-chars 下有用:写真实地址就按真实 .tp 距离算,不写就假设参数 cell 紧邻。

汇编:

$ r8forge examples/full_add.r8asm                 # 默认 flat:95 字符
$ r8forge --synth-chars examples/full_add.r8asm   # 按这份布局最优:90 字符

两个结果都已在 .r8forge_cache/ 里,所以这两条现在都是秒出;第一次搜的时候 --synth-chars 那版是 4.15 亿状态、约 21 分钟、峰值约 10 GB。

tests/synth_test.cc 把纸带丢进一台小 ROT-8 虚拟机,8 种组合全对:

tape: 95 characters
  000 -> 00  expect 00  ok
  ...
  111 -> 11  expect 11  ok
all eight combinations ok

map 的项数决定输入个数:2^K 项就是 %1..%K 为输入,值的第 j 位落到 %(K+j+1),剩下 的参数是必须结束为 0 的草稿。想要完全显式(或输入不在最前面)就改用 stat,那是整张状态表。

代价口径:默认 flat,--synth-chars 切到真实布局

%synth 里没有 metric 了 —— 这是整次汇编的属性,不是某个块的属性:

口径 怎么开 计什么 依赖 cell 布局? 缓存能否跨调用点复用
flat(默认) 什么都不用加 biz / flb / rnz 和 op 本身 否 能
chars r8forge --synth-chars <file> 真实纸带字符数,含 .tp 行走 是(layout,不写按相邻) 只有同一份布局

默认 flat 的理由:库里的块会被几十个调用点展开,布局到处不同,只有"步长无关"的结果能 一份缓存复用。代价是纸带比按实际布局最优的长一点 —— full_add 上 flat 是 95 字符, --synth-chars 是 90 字符。

两个口径的缓存分开存(键里带 metric),所以第一次跑 --synth-chars 会真的去搜。库里的块 全是 flat,仓库里已经带好了缓存,所以 cmake --build 之后第一次汇编不用等。

早先那个 metric blocks(只按块数)删掉了:块数不是纸带长度的好代理 —— 层数最少不等 于纸带最短,块数最少也不是。

从零开始

cmake -S . -B build -G "Visual Studio 18 2026" -A x64   # 或者用 Ninja / Makefile
cmake --build build --config Release

写一个 adder.r8asm:

%include "asm/lib.r8asm"

%synth fulladd
	params 6
	map  0 1 1 2 1 2 2 3    ; 8 个输入组合各自的输出位取值
	mode tape               ; tape = 最短纸带(默认),layers = 只求层数最少(快)
%endsynth

.var A 0
.var B 1
.var Ci 2
.var S 3
.var Co 4
.var T 5

fulladd A B Ci S Co T
output S
output Co

map 一项就说明了谁是谁:项数是 2^K,就意味着 %1..%K 是输入;值里的第 j 位 落到 %(K+j+1);剩下的参数都是必须结束为 0 的草稿。所以不需要再声明 inputs/outputs。

要完全显式也可以,直接给整张状态表(每个输入组合下 6 个参数的取值),一个声明都不用:

%synth fulladd_stat
	params 6
	stat 0 1 2 3 4 5 6 ...
	mode layers
%endsynth

examples/full_add.r8asm 是 map 版,examples/full_add_stat.r8asm 是 stat 版, 两者合成的纸带逐字节相同(95 字符)。

汇编:

build/Release/r8forge adder.r8asm > adder.rot8

stderr 上会告诉你它查到了什么,stdout 就是纸带:

r8asm: %synth fulladd: cached, 5 blocks

第一次搜(缓存里没有这张表 + 这个口径)会先打一行层数搜索,再打一行纸带搜索;之后再编 同一张表就直接命中缓存。mode layers 只跑到层数为止,mode tape(默认)才是纸带长度 搜索。结果按真值表 + 口径缓存在 .r8forge_cache/ 里,所以同一张表只贵一次;要重算就删掉 那个目录。

标准库现在也是合成的

asm/ 里的 8 个 bit 宏(clb_bit_and、bit_raw_and、clb_bit_or、bit_raw_or、 clb_bit_xor、bit_raw_xor、bit_raw_inc、bit_raw_add)全部换成了 %synth 块,宏名、 参数顺序、调用方式都没动,上层的 %rep 驱动照旧。

stat 那张表不是手写的,是 r8forge_derive 从旧实现本身跑出来的:

build/Release/r8forge_derive drv/bit_raw_add.r8asm 6
# stat 0 9 10 19 12 21 22 31 0 9 10 ...

它把 6 个参数摆到 cell 0..5,穷举 64 个输入组合各跑一遍旧纸带,读回 6 个 bit 的终值。 所以合成结果与旧实现逐位一致(连旧实现里"某个输入没被清掉"这类怪癖都保住了),只是更短。 要改语义,改那张表就行,不用碰代码。

放进自己的库里

%synth 块定义完就是一个普通宏,所以在库里写一次即可:

; asm/my_adder.r8asm
%synth bit_add
	params 6
	map 0 1 1 2 1 2 2 3
%endsynth

调用点和普通宏调用一样:bit_add A B Ci S Co tmp —— 替换掉现有实现就是改这一行。

三条要注意的

  1. 输入永远是排在最前面的参数(%1..%K,K 由 map 项数得出)。搜索器把真值表索引直接 当输入值,靠的就是这个顺序;输入不在最前面就用 stat。
  2. map 一项里的 bit0 落在 %(K+1)、bit1 落在 %(K+2)……超出 params 会直接报错。
  3. stat 必须给 2^params 项,每项是那个输入组合下所有参数的取值。

字节级运算:一个 cell 一个机器字

机械字默认 11 位、纸带 259 格,都定义在 include/r8forge/geometry.hh (kDefaultCellSize / kDefaultMemoryCells)。指令集本身不规定位宽,宏里用 %rep _CELL_SIZE 的地方会自动跟着变,所以下面说的"字节级"其实是"机器字级"; 下面引用的纸带长度是 8 位时代的实测值,11 位下这些宏会长一些(raw_add 2199 字符、 fibonacci 11959 字符,完整数字见 AGENTS.md)。

%include "asm/raw_add.r8asm"

.var A 0
.var B 2
.var Ci 4
.var S 6
.var Co 8
.var tmp 1

raw_add A B Ci S Co tmp     ; S = A + B,Co = 进位,A、B 保留

output A
output B
output Ci
output S
output Co

raw_add 把 A、B、S 各当一个字节:每轮把当前最低位送进 4~6 cell 的位级切片, 然后把整个字节 ror 一格,8 轮走完。raw_and / raw_or / raw_xor / raw_inc 同理。

r8forge_byte_op_test 在 ROT-8 虚拟机上把每种输入都跑一遍(0.7 秒):

raw_xor: 463 characters     all 65536 combinations ok
raw_or: 575 characters      all 65536 combinations ok
raw_and: 639 characters     all 65536 combinations ok
clb_sub_nc: 725 characters  all 65536 combinations ok
clb_neg_nc (carry 0): 467   all 256 combinations ok      ~A
clb_neg_nc: 468 characters  all 256 combinations ok      -A
clb_inc_nc: 430 characters  all 256 combinations ok
clb_add_nc: 688 characters  all 65536 combinations ok
raw_inc: 1214 characters    all 512 combinations ok
raw_add: 1647 characters    all 65536 combinations ok
byte level library ok

省 cell 的那一族:clb_*_nc

raw_add 要 6 个 cell(A、B、进位、S、进位输出、草稿)是因为它保留 A、B。 如果调用者不在乎操作数被吃掉,4 个 cell 就够:

宏 含义 cell 纸带
clb_add_nc A B S Ci S = A + B + Ci 4 688
clb_inc_nc A S Ci S = A + Ci(Ci=1 就是自增) 3 430
clb_neg_nc A S Ci S = ~A + Ci(Ci=1 → -A,Ci=0 → ~A) 3 448
clb_sub_nc A B S Ci S = A + ~B + Ci(Ci=1 → A-B) 4 707
clb_not_ip A A = ~A(反码,原地,不占额外 cell) 1 17
clb_inc_ip A T A = A + 1(原地,T 是草稿) 2 74
clb_neg_ip A T A = -A(原地补码取负) 2 90
clb_dec_ip A T A = A - 1(原地;B-1 = ~(-B)) 2 106
clb_nonzero B F T F = (B != 0),B 不动 3 209
clb_add_ip A B T F A += B(原地,B 被吃掉) 4 558
clb_mul MC MUL PL PH … (PH:PL) = MC * MUL,一个 cell × 一个 cell → 两个 cell 的积 10 3977

进位 cell 是真正的进位输入:宏不动它的初值,由调用者给。所以可以串 —— 上一字节的 进位输出直接接到下一字节的进位输入,多字节加法/减法/取负都能这么拼。 clb_sub_nc 的进位输出是"没有借位"(A >= B 时为 1),顺带就是无符号比较。

补码那两个 _nc 宏是先原地取反、再走加法/自增:取反整个字节一次(clb_not_ip)比 "每 bit 取反一次"短 20 来个字符,而且 B 本来就会被加法吃掉,取反它没有代价。

原地取补码:两个 cell,90 字符

clb_neg_ip A T 直接把 A 变成 -A,不需要单独的 S —— 比 clb_neg_nc(3 cell、448 字符) 少一个 cell、短 5 倍。clb_inc_ip 是它的核心: clb_inc_ip A T 74 字符,clb_inc_nc 是 430。

做法不是逐位测进位(那在只有两个 cell 时确实不行),而是:

  1. 用 [ ... ] 的自然语义把最低位连续的 1 清掉(flb + ror),遇到第一个 0 退出;
  2. 那个 0 翻成 1(全 1 输入时跳过,正好是回绕那一格);
  3. 剩下的位置只旋转。

"还要转几格"用 T 的位计数:T 先做 0xFF,每转一格 set_0 + ror 消掉一个 1, 一串 1 的长度就是剩余圈数。于是两个 cell 就够,而且没有"无条件翻转"那种表达不出的动作。

原地加法:只算长度,不算步数

clb_add_ip A B T F 把 A += B 做在 4 个 cell 里,558 字符(raw_add 是 1647 / 6 cell)。 没有逐位写进位链(全加器的进位是 maj(a,b,c),两两的合取,而每次条件测试都会吃掉被测的 那一位),而是利用了本仓库的一个取舍 —— 只有纸带长度是目标,运行步数不是:

while B != 0:  A += 1 ; B -= 1

循环体在纸带里只出现一次,长度与 B 的大小无关;代价是运行 O(B)(B=255 时约 30 万步, 上限 500 万)。clb_nonzero 负责"B != 0"的判断(biz 只测最低位,得把八位都看一遍, 还不能把 B 吃掉)。

乘法器:(PH:PL) = MC * MUL

clb_mul 用的是二进制移位-加法(竖式乘法),一位一位串:

A:PH = 0 ; C:F = 0 ; Q:PL = MUL
repeat _CELL_SIZE:
    if Q & 1:  (C:PH) += MC      ; 一次 W 位加法,进位出到 F
    (C:PH:PL) >>= 1              ; 跨格右移,最高位补 0,最低位(刚看的那位)丢掉

3977 字符、10 个 cell。轮数 = 位宽,跟两个操作数的值都无关:11 位下封顶 26123 步。

早先那版是重复加法(while MUL != 0: (PH:PL) += MC ; MUL -= 1),轮数 = MUL 的值, 所以代价随乘数线性长大 —— 255 × 255 是 73 万步,2047 × 2047 直接跑不完(撞 500 万步 上限,tape_run 报 HANG after 5000000 steps)。换成移位-加法之后同一批算式都在 1 万步 上下,纸带还短了 1000 字符(5007 → 3977),只有小乘数(0/1)比旧版慢一点点 —— 新版固定要 转满位宽那么多轮。

255 × 255 = 65025 = 31*2048 + 1473 ✓,r8forge_byte_op_test 现在穷举 65536 组 (0..255 × 0..255)全对 —— 步数不再随乘数增长,才敢这么放开测。

这个设计本身是一条经验:上一轮把移位-加法否掉了,理由是「重复加法更短」。实测反了: 移位-加法短 1000 字符,步数还少一到两个数量级。先看目标函数(纸带长度)再选算法没错, 但目标函数里得把「运行步数有 500 万上限」这一条写进去。

asm/fibonacci.r8asm 也是这条路上的:11 位下 11959 字符,跑出 1 1 2 3 5 8 13 21 34 55 89 144 233(13 项,位宽变大以后不再在 256 处回绕)。

一个坑:biz/rnz 看的是最低位

biz:  最低位 == 0 -> 跳到匹配的 ']' 之后
rnz:  最低位 == 1 -> 跳回匹配的 '['

不是 Brainfuck 那种"整格是否为零"。所以 set_0 = [-] 是清最低位:255 → 254、 128 → 128、5 → 4;要清整个字节得 %rep _CELL_SIZE { set_0; ror }(就是 erase)。

仓库里曾经有三份解释器把它写成整格零判断,于是所有字节级程序看起来都在死循环 —— 顺着那个错误还得出过"字节级运算只能一位一 cell"的结论,是错的。权威语义见 ROT-8-viz/src/rot8.c:

void rot8_biz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 0) { ... } }
void rot8_rnz(rot8_iter *iter) { if ((*(iter->mem_now) & 1) == 1) { ... } }

顺带一个被删掉的方向

"每个 bit 一个 cell 再拼字节级运算"能跑通(32 cell,1308 字符,65536 组合全对),但既然 一个 cell 就能放一个字节、位也读得出来,就没必要为每个 bit 花一个 cell —— 那份实现已经 删了,要拼字节级运算就用 raw_*。

例程:examples/ 里每组宏一份

examples/ 下每个 .r8asm 都是能跑的程序,头部 ; out ... 写它打印什么:

build/Release/r8forge examples/digits_demo.r8asm > t.rot8
build/Release/r8forge_tape_run t.rot8        # 打印 out 和步数
文件 演示什么
base_macros.r8asm set_0 只清一位 / erase 清整格 / rol/ror 转圈 / copy/bit_copy 保留源 / clb_bit_mov 吃源 / step
bit_adder.r8asm 用 clb_bit_add_nc 串 4 位行波加法器;再对比 bit_raw_add 保留操作数
byte_raw_ops.r8asm raw_add / raw_inc / raw_and / raw_or / raw_xor / raw_sub:操作数都还回来
byte_clobber.r8asm clb_add_nc / clb_sub_nc / clb_neg_nc / clb_inc_nc:操作数被吃;clb_and 的 B 残留
byte_in_place.r8asm clb_not_ip / inc / neg / dec / clb_add_ip / clb_nonzero
sum_loop.r8asm clb_ones + loop/endloop 算 1+2+...+N(次数来自数据)
mul_demo.r8asm 82×141、2047×2047 的 (PH:PL)
divmod_demo.r8asm 2047/10、2047/1(旧版会 HANG)
digits_demo.r8asm 1234 和 7 的 4 位 ASCII
full_add*.r8asm %synth 的四种写法(map / stat / layers / 手写);--synth-chars 那版见上一节

r8forge_examples_test 会把它们全跑一遍,实跑的 out 和头部那行逐项比 —— 例程不会悄悄腐掉。 宏的契约(吃什么、留什么、几个 cell、纸带多长)看 SPEC.md。

实现方式

%synth 在 parse() 里被读成一张真值表,随即调用搜索器;得到的块序列写成

%macro fulladd 6
.tp %1
biz
...
%endmacro

这样一个临时文件(<名字>.synth.r8asm),再 import_file 进来、删掉。于是合成出来的代码 走的是正常宏展开路径,不是手工拼 AST —— 少一套容易写错的代码。

生成的块体里 set_1 展开成 biz/flb/rnz + flb(即 set_0 + 翻转),所以生成文件不依赖 lib.r8asm。

搜索器

  • 状态 = 位平面真值表,只留影响答案的输入(加法器类问题通常 3 个,48 bit 一个 uint64_t)
  • 前向 BFS 到 d−1 层,最后一层不展开:枚举目标的一步前驱反查表
  • proven_optimal 为真表示长度已被穷尽证明

full_add(r8veritas<6>):5 层,2038 万状态,7.7 秒,穷尽搜索下最短。

比它更宽松的指令语义也没有 4 层解(都做过穷尽搜索):

放宽 指令数 搜索规模 4 层?
每目的地独立 OR/XOR 1,458 前向 3 层 173 万 + 反向 20,096 前驱 无
再加 set_0 6,144 前向 3 层 956 万 + 反向 40,928 无
参数 6 → 7 → 8 个 2,040 穷尽 540 万 / 4410 万状态 无
条件位 ≠ 牺牲位 2,304 前向 3 层 317 万 + 反向 1,280 无

按纸带长度搜(solve_cost)

结论先说:full_add 上 5 层那版是 95 字符,按纸带长度搜出来的 6 块版是 90 字符 (后者就是 --synth-chars 的结果;缓存里已经有,所以不用再跑十几分钟)。两个都在 examples/ 里,都跑过那台 ROT-8 虚拟机,8 种输入组合全对:

版本 层数 模型代价 真实纸带
层数最优(full_add_layers.r8asm / full_add_stat.r8asm) 5 82 95 字符
代价最优(full_add_cost.r8asm;--synth-chars 搜出来的是同一份) 6 75 90 字符

代价最优解:

sacrifice B,  FLIP {S,T}
sacrifice A,  FLIP {B}
sacrifice B,  FLIP {A,Ci,S}
sacrifice Ci, FLIP {B,Co,T}
sacrifice S,  SET1 {Ci,Co}
sacrifice T,  FLIP {B,Ci,S,Co}

层数最优不等于纸带最优:多一层反而少 5 个字符。Dijkstra 在弹出代价 75 之前已经把 < 75 的 区域穷尽,所以 75 是模型内的最小值。

层数最少不等于纸带最短。solve_cost 用同一张状态图跑 Dijkstra,边权就是这个块汇编出来 多少字符:

w(block) = 3 (biz + flb + rnz) + 2 × span(cell 地址) + Σ op   # flb=1, set_1=4

桶队列(Dial),按代价递增弹出,第一次弹出目标态就是最短纸带。给一个 max_cost 上界就变成 分支限界,超出上界的状态不入队。

full_add、6 个 cell 紧邻时,搜索推进到某个代价时已经攒下的状态数:

代价 状态数
20 1,086
40 128,528
50 999,448
58 80,000,000
62 140,000,000
66 220,000,000
70 280,000,000

每状态约 27 字节(8 key + 2 距离 + 4 父 + 2 指令 + 哈希表),到代价 70 约 7.5 GB,速度约 65 万状态/秒。所以这台机器上能跑到的上限大约就是「代价 75 左右 / 4.5 亿状态 / 12 GB」, 再往上就超出内存了 —— 这正是当初估的 13 GB 量级。

因为 Dijkstra 按代价递增弹出,停在哪儿就证明了「比它更短的纸带不存在」:跑到代价 d 就 停,等于给出「没有短于 d 字符的程序」这个下界。

注意:模型里的 w 不含「上一块的牺牲位跳到这一块」的那几步(|s_i − s_{i−1}|),因为那让 代价依赖历史、Dijkstra 就不能用了。发射器会把这部分加上再报真实长度,5 层程序是模型 82 / 实际 87。

为什么合在一起

代价 = 汇编出来多少条指令,而这只有发射器知道:

cost(layer) = 2                   # biz + rnz
            + Σ (|Δ| 移动 + op)   # flb=1, set_0=3, set_1=4

|Δ| 来自调用点的 cell 布局:同一份 5 层程序,cell 紧邻是 87 字符,隔两格是 136 字符。 这是「程序 × 布局」的属性,只有看得见调用点的那一方算得出来 —— 也就是汇编期。所以默认 不把它算进代价(flat);--synth-chars 才是把这部分算进去的那一版。

坑

  • ROT-8 的字符映射是 "><+-[].,",也就是 - 是 flb,+ 是 ror。写仿真器时按常识 猜会反(我第一次就反了,纸带看起来「死循环」)。
  • %synth 的名字不能和 ROT-8 助记符重名(out、flb、biz…),否则词法先认成指令。

下一次要做的事

  1. 搜索的代价从「1/层」换成真实指令数(Dijkstra + 每层目的地访问顺序的 TSP),这样嵌套条件 块(A AND B 门控)也能公平参与竞争。注意嵌套会降低层数但拉长纸带 —— 层数不是长度 的好代理。
  2. 缓存:现在每次汇编都要重跑搜索(full_add 是 7.7 秒)。按真值表 + 布局落盘缓存。
  3. %synth 只支持 8 位以内的参数(状态要塞进 64 位字里)。

给接手的 agent / 新会话

先读 AGENTS.md。那里有这个仓库实测过的指令集语义、%synth 用法、缓存机制, 以及一列已经确认走不通的方案(3 cell 加法切片、轮转配合成切片、字节级真值表交给搜索……)。 那些都是失败换来的结论,别重试。

要查"某个宏到底怎么调、吃什么、留什么、占几个 cell、纸带多长、谁验证的",看 SPEC.md:%synth 的完整语法 + asm/ 里 42 个宏的契约表。

构建

cmake -S . -B build -G "Visual Studio 18 2026" -A x64
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_macro_docs_test.exe # 宏注释格式(asm/ 下每个 %macro)

build/ 已经有生成器了,重编译时别用 PATH 上的另一个 cmake(版本不一致会重新配置, 然后死在 No preprocessor test for "PellesC");用配这个目录的那个:

& "C:\Program Files\Microsoft Visual Studio\18\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe" --build build --config Release

CMakeLists.txt 里没有 set(CMAKE_CXX_FLAGS ...):那会把默认 flag 整个换掉,MSVC 下丢 /EHsc、还把 -O3 塞进 Debug 和 /RTC1 打架。

布局

SPEC.md                       规格:%synth + asm/ 里每个宏的契约
include/r8forge/r8asm.hh      汇编器 + %synth 指令
include/r8forge/r8veritas.hh  搜索器
src/r8asm.cc                  汇编器实现
src/synth.cc                  真值表 -> 搜索
tests/asm_test.cc             汇编器自检(纸带不变)
tests/synth_test.cc           合成 + ROT-8 虚拟机自检
tests/byte_op_test.cc         字节级库穷举自检(65536×4 + 512)
tests/macro_docs_test.cc      宏注释格式自检(asm/ 下每个 %macro)
tests/examples_test.cc        例程自检(examples/ 每个程序的 `;   out` 与实跑逐项比)
tests/tape_run.cc             第二个 ROT-8 解释器,直接跑 .rot8 交叉验证
asm/                          标准库与既有实现
examples/*.r8asm              能跑的程序:每组宏一份例程 + %synth 的六种写法