83 lines
2.4 KiB
Plaintext
83 lines
2.4 KiB
Plaintext
// mandelbrot — ASCII Mandelbrot set, printed via libc.
|
|
//
|
|
// What this proves:
|
|
// 1. ww does f64 arithmetic (mul, add, sub, div) end to end.
|
|
// 2. The @symbol FFI mechanism binds write() from libc.so.6.
|
|
// 3. w6l's dynamic linker (PT_INTERP + PT_DYNAMIC + PLT/GOT) reaches
|
|
// a real .so at runtime — `ldd mandelbrot` shows libc.so.6 as a
|
|
// NEEDED entry.
|
|
//
|
|
// We use libc's `write` (a thin syscall wrapper) rather than `putchar`
|
|
// because the runtime here doesn't call __libc_start_main, so stdio
|
|
// state stays uninitialised and putchar's buffer is never flushed.
|
|
//
|
|
// Build: see ./Makefile. No cc — pure ww toolchain.
|
|
|
|
@symbol("write") fn c_write(fd: i32, buf: *void, n: u64) i64;
|
|
|
|
def W: i32 = 78;
|
|
def H: i32 = 30;
|
|
def MAXI: i32 = 80;
|
|
|
|
// Number of iterations before |z| escapes |z|>2, capped at MAXI.
|
|
fn iterate(cr: f64, ci: f64) i32 = {
|
|
let zr: f64 = 0.0;
|
|
let zi: f64 = 0.0;
|
|
let i: i32 = 0;
|
|
for (i < MAXI) {
|
|
let zr2: f64 = zr * zr;
|
|
let zi2: f64 = zi * zi;
|
|
if (zr2 + zi2 > 4.0) { return i; };
|
|
let nz: f64 = zr2 - zi2 + cr;
|
|
zi = (2.0 * zr) * zi + ci;
|
|
zr = nz;
|
|
i += 1;
|
|
};
|
|
return MAXI;
|
|
};
|
|
|
|
// Pick an ASCII glyph by escape iteration count. Inside the set
|
|
// (n == MAXI) renders as space — the classic look.
|
|
fn shade(n: i32) i32 = {
|
|
if (n >= MAXI) { return ' ': i32; };
|
|
let chars: str = " .:-=+*#%@";
|
|
let idx: i32 = (n * chars.len) / MAXI;
|
|
if (idx >= chars.len) { idx = chars.len - 1; };
|
|
return chars[idx]: i32;
|
|
};
|
|
|
|
export fn main() i32 = {
|
|
// Classic Mandelbrot window. The y range is squashed to W/H so
|
|
// the picture looks roughly proportional in a terminal cell.
|
|
//
|
|
// XXX ww's compiler currently emits positive bit patterns for
|
|
// negative f64 literals (the unary minus is dropped during
|
|
// codegen). As a workaround we build negatives via 0.0 - x.
|
|
let z: f64 = 0.0;
|
|
let xmin: f64 = z - 2.5;
|
|
let xmax: f64 = 1.0;
|
|
let ymin: f64 = z - 1.1;
|
|
let ymax: f64 = 1.1;
|
|
let dx: f64 = (xmax - xmin) / (W: f64);
|
|
let dy: f64 = (ymax - ymin) / (H: f64);
|
|
|
|
// Compose the picture into a row buffer, then flush per row to
|
|
// avoid one libc call per character.
|
|
let row: [128]u8;
|
|
let y: i32 = 0;
|
|
for (y < H) {
|
|
let ci: f64 = ymin + (y: f64) * dy;
|
|
let x: i32 = 0;
|
|
for (x < W) {
|
|
let cr: f64 = xmin + (x: f64) * dx;
|
|
let n: i32 = iterate(cr, ci);
|
|
row[x] = (shade(n)): u8;
|
|
x += 1;
|
|
};
|
|
row[W] = 10u8; // '\n'
|
|
c_write(1, row.ptr: *void, (W + 1): u64);
|
|
y += 1;
|
|
};
|
|
return 0;
|
|
};
|