Motiejus Jakštys
7f58c766f8
air_gen: replace per-file symlink workaround with two-pass compilation.
Pass 1 compiles lib/std/std.zig as root with use_root_as_std=true
(one compilation, all lib/std/ functions). Pass 2 compiles non-lib/std/
files standalone. Symlink workaround eliminated entirely.
build.zig: pass all corpus.files (not 0..num_passing) to air_gen,
skipping lib/std/ files. Bumping num_passing no longer invalidates
the air_gen cache.
air_data.zig: route lib/std/ paths to the combined std.zig.air file.
sema_test.zig: switch to unidirectional comparison (C→Zig only) and
exact FQN matching. Remove stripModulePrefix, bare-name fallback, and
unused cNameSpan. Add pathToModulePrefix and pathStem helpers.
sema.h/sema.c: add root_fqn, module_prefix, and is_test fields to
Sema struct. Function names use "{root_fqn}[.{prefix}].{name}" format
to match Zig's FQN convention.
stages_test.zig: set root_fqn and module_prefix on C sema so FQNs
match Zig's naming. Remove symlink workaround — C sema uses real
paths directly. Set is_test=false to match air_gen.
corpus.zig: remove lib/init/src/main.zig (template file with
@import(".NAME") that cannot compile standalone).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
About
zig0 aspires to be an interpreter of zig 0.15.2 written in C.
This is written with help from LLM:
- Lexer:
- Datastructures 100% human.
- Helper functions 100% human.
- Lexing functions 50/50 human/bot.
- Parser:
- Datastructures 100% human.
- Helper functions 50/50.
- Parser functions 5/95 human/bot.
- AstGen: TBD.
Testing
Quick test:
zig build fmt-zig0 test-zig0
Static analysis (takes a while, run separately):
zig build lint-zig0
More elaborate (tries all compilers + static analysis + ReleaseSafe):
zig build all-zig0 -Doptimize=ReleaseSafe
Most elaborate, takes >10m:
zig build all-zig0 -Doptimize=ReleaseSafe -Dvalgrind |& grep -v Warning
Debugging tips
Test runs infinitely? Build the test program executable:
$ zig build test-zig0 -Dzig0-no-exec
And then run it, capturing the stack trace:
gdb -batch \
-ex "python import threading; threading.Timer(1.0, lambda: gdb.post_event(lambda: gdb.execute('interrupt'))).start()" \
-ex run \
-ex "bt full" \
-ex quit \
zig-out/bin/test
You are welcome to replace -ex "bt full" with anything other of interest.
Float handling
Float literals are parsed with strtold() (C11 standard, portable). On
x86-64 Linux, long double is 80-bit extended precision (63 fraction bits).
When a float doesn't round-trip through f64, it's emitted as f128 (ZIR
float128 instruction). The 80-bit extended value is converted to IEEE 754
binary128 encoding by bit manipulation — both formats share the same 15-bit
exponent with bias 16383. The top 63 of binary128's 112 fraction bits come
from the 80-bit value; the bottom 49 are zero-padded.
This means float128 literals lose ~49 bits of precision compared to the
upstream Zig implementation (which uses native f128). This is acceptable
because stage0 is a bootstrap tool — the real Zig compiler re-parses all
source with full f128 precision in later stages. The test comparison mask
in astgen_test.zig skips float128 payloads to account for this.
Previous approach used __float128/strtof128 (GCC/glibc extensions) for
full precision, but these are not portable to TCC and other C11 compilers.