diff options
Diffstat (limited to 'examples/live/src')
| -rw-r--r-- | examples/live/src/Lang.zig | 617 | ||||
| -rw-r--r-- | examples/live/src/probe.zig | 2 |
2 files changed, 611 insertions, 8 deletions
diff --git a/examples/live/src/Lang.zig b/examples/live/src/Lang.zig index 644ff61..a6db8b9 100644 --- a/examples/live/src/Lang.zig +++ b/examples/live/src/Lang.zig @@ -1,14 +1,35 @@ //! The language: lines of `name = expression` over `t`, `x` and `y`, -//! compiled into two tapes, `out` (heard) and `color` (seen), that one -//! interpreter (shaders/vm.glsl) runs per sample and per pixel. +//! compiled into two tapes, `out` (heard, -1..1) and `color` (seen), that +//! one interpreter (shaders/vm.glsl) runs per sample and per pixel. Names +//! are shared by both lines; a name is defined once, before it is used, so +//! a program is a graph without cycles and every program ends. //! -//! A tape is at most `max_tape` instructions; instruction i writes register -//! i from earlier ones. Its GPU form is the uniform blocks at the end of -//! this file, and build.zig writes `Op` out as ops.glsl for the shaders: -//! this file is the one definition of both. +//! beat = t * 2 +//! kick = exp(-7 * fract(beat)) +//! out = sin(tau * 48 * t) * kick # heard +//! color = hsv(x, 0.5, y * kick) # seen +//! +//! `+ - * /`, unary `-` and parentheses; numbers like 0.5, 120, 1e-3; +//! `#` to the end of the line is a comment; the builtins are `builtins`. +//! +//! A tape is at most `max_tape` instructions, holding only what its line +//! reaches; instruction i writes register i from earlier ones. Its GPU +//! form is the uniform blocks at the end of this file, and build.zig +//! writes `Op` out as ops.glsl for the shaders: this file is the one +//! definition of both. `compile` allocates nothing: its work is a few +//! fixed arrays on the stack (`max_terms`, `max_names`, `max_depth`), and a +//! program past any of them is a problem like any other, in words. const std = @import("std"); pub const max_tape = 128; +/// Numbers, names used and operations in the whole text. +pub const max_terms = 512; +/// Lines that define a name. +pub const max_names = 128; +/// Parentheses and unary minuses inside each other. +pub const max_depth = 32; +/// seq's index and values. +pub const max_args = 17; /// By how many registers an instruction reads: none, one, two, three. pub const Op = enum(u32) { @@ -32,7 +53,7 @@ pub const Op = enum(u32) { /// Register `a`, so that seq's values sit side by side. copy, /// Register `b + floor(a) mod c`: `b` and `c` are numbers, not - /// registers it reads, and registers b.. hold copies. + /// registers it reads, and registers b.. hold the values. seq, add, sub, @@ -52,6 +73,59 @@ pub const Op = enum(u32) { rgb, }; +pub const Builtin = struct { + /// As it is called, for the manual. + call: []const u8, + op: Op, + /// Arguments; 0 for an input or a constant, used without parentheses. + min: u8 = 0, + max: u8 = 0, + value: f32 = 0, + doc: []const u8, + + pub fn name(b: Builtin) []const u8 { + return b.call[0 .. std.mem.indexOfScalar(u8, b.call, '(') orelse b.call.len]; + } +}; + +/// The builtins, the one table: a name is added here and in vm.glsl's +/// switch, and only for a program that needs it. +pub const builtins = [_]Builtin{ + .{ .call = "t", .op = .t, .doc = "seconds" }, + .{ .call = "x", .op = .x, .doc = "0 at the left to 1 at the right; 0 in sound" }, + .{ .call = "y", .op = .y, .doc = "0 at the bottom to 1 at the top; 0 in sound" }, + .{ .call = "tau", .op = .constant, .value = std.math.tau, .doc = "a turn in radians, 6.283..." }, + .{ .call = "pi", .op = .constant, .value = std.math.pi, .doc = "half a turn, 3.141..." }, + .{ .call = "sin(a)", .op = .sin, .min = 1, .max = 1, .doc = "sine, of radians" }, + .{ .call = "cos(a)", .op = .cos, .min = 1, .max = 1, .doc = "cosine, of radians" }, + .{ .call = "exp(a)", .op = .exp, .min = 1, .max = 1, .doc = "e to the a" }, + .{ .call = "log(a)", .op = .log, .min = 1, .max = 1, .doc = "natural logarithm" }, + .{ .call = "pow(a, b)", .op = .pow, .min = 2, .max = 2, .doc = "a to the b (a not negative)" }, + .{ .call = "sqrt(a)", .op = .sqrt, .min = 1, .max = 1, .doc = "square root" }, + .{ .call = "abs(a)", .op = .abs, .min = 1, .max = 1, .doc = "a without its sign" }, + .{ .call = "floor(a)", .op = .floor, .min = 1, .max = 1, .doc = "the whole number at or below a" }, + .{ .call = "fract(a)", .op = .fract, .min = 1, .max = 1, .doc = "a - floor(a): 0..1, again every 1" }, + .{ .call = "min(a, b)", .op = .min, .min = 2, .max = 2, .doc = "the smaller" }, + .{ .call = "max(a, b)", .op = .max, .min = 2, .max = 2, .doc = "the larger" }, + .{ .call = "clamp(v, lo, hi)", .op = .clamp, .min = 3, .max = 3, .doc = "v kept between lo and hi" }, + .{ .call = "mix(a, b, w)", .op = .mix, .min = 3, .max = 3, .doc = "a + (b - a) * w" }, + .{ .call = "step(edge, v)", .op = .step, .min = 2, .max = 2, .doc = "0 below edge, 1 from it on" }, + .{ .call = "smoothstep(lo, hi, v)", .op = .smoothstep, .min = 3, .max = 3, .doc = "0 to 1, smoothly, as v goes from lo to hi (either way round)" }, + .{ .call = "atan2(y, x)", .op = .atan2, .min = 2, .max = 2, .doc = "the angle of the point (x, y), radians" }, + .{ .call = "noise(x, y, z)", .op = .noise, .min = 1, .max = 3, .doc = "smooth noise, -1..1, a new value about every 1; y and z are 0 when left out" }, + .{ .call = "saw(p)", .op = .saw, .min = 1, .max = 1, .doc = "a sawtooth, -1..1, of period 1 (cycles, not radians), rising through 0 at 0" }, + .{ .call = "sqr(p)", .op = .sqr, .min = 1, .max = 1, .doc = "a square wave, 1 then -1, of period 1" }, + .{ .call = "tri(p)", .op = .tri, .min = 1, .max = 1, .doc = "a triangle wave, -1..1, of period 1, rising through 0 at 0" }, + .{ .call = "seq(i, v0, v1, ...)", .op = .seq, .min = 2, .max = max_args, .doc = "the value at floor(i), round the list: a step pattern (16 values at most)" }, + .{ .call = "hsv(h, s, v)", .op = .hsv, .min = 3, .max = 3, .doc = "a colour: hue round the wheel 0..1, saturation, value; only as the whole color line" }, + .{ .call = "rgb(r, g, b)", .op = .rgb, .min = 3, .max = 3, .doc = "a colour, red, green and blue 0..1; only as the whole color line" }, +}; + +fn builtin(name: []const u8) ?Builtin { + for (builtins) |b| if (std.mem.eql(u8, b.name(), name)) return b; + return null; +} + pub const Instruction = extern struct { op: Op = .constant, a: u32 = 0, @@ -62,6 +136,328 @@ pub const Instruction = extern struct { pub const Tape = struct { len: u32 = 0, code: [max_tape]Instruction = @splat(.{}), + + pub fn slice(tape: *const Tape) []const Instruction { + return tape.code[0..@min(tape.len, max_tape)]; + } +}; + +/// What is wrong with a program, and where: a byte of its text. +pub const Problem = struct { + at: u32 = 0, + len: u32 = 0, + words: [96]u8 = @splat(0), + + pub fn text(p: *const Problem) []const u8 { + return p.words[0..@min(p.len, p.words.len)]; + } +}; + +pub const Program = struct { out: Tape = .{}, color: Tape = .{} }; + +pub const Result = union(enum) { program: Program, problem: Problem }; + +pub fn compile(text: []const u8) Result { + var c: Compiler = .{ .text = text }; + var program: Program = .{}; + c.lines() catch return .{ .problem = c.problem }; + c.tape(&program.out, "out") catch return .{ .problem = c.problem }; + c.tape(&program.color, "color") catch return .{ .problem = c.problem }; + return .{ .program = program }; +} + +const none = std.math.maxInt(u16); + +const Term = struct { + op: Op, + value: f32 = 0, + /// Where it was written. + at: u32, + len: u8 = 0, + args: [max_args]u16 = undefined, +}; + +const Name = struct { text: []const u8, term: u16, at: u32 }; + +const Token = struct { + kind: enum { name, number, symbol, newline, end }, + at: u32, + end: u32, + symbol: u8 = 0, + + fn is(tok: Token, symbol: u8) bool { + return tok.kind == .symbol and tok.symbol == symbol; + } +}; + +const Compiler = struct { + text: []const u8, + pos: u32 = 0, + terms: [max_terms]Term = undefined, + term_count: u16 = 0, + names: [max_names]Name = undefined, + name_count: u16 = 0, + /// The term of t, x and y, made once. + inputs: [3]u16 = .{ none, none, none }, + depth: u8 = 0, + /// The line's hsv or rgb, if it called one. + colour: u16 = none, + problem: Problem = .{}, + + fn fail(c: *Compiler, at: u32, comptime fmt: []const u8, args: anytype) error{Problem} { + c.problem = .{ .at = at }; + var w: std.Io.Writer = .fixed(&c.problem.words); + w.print(fmt, args) catch {}; + c.problem.len = @intCast(w.end); + return error.Problem; + } + + fn span(c: *const Compiler, tok: Token) []const u8 { + return c.text[tok.at..tok.end]; + } + + fn next(c: *Compiler) Token { + const s = c.text; + var i = c.pos; + while (i < s.len and (s[i] == ' ' or s[i] == '\t' or s[i] == '\r')) i += 1; + if (i < s.len and s[i] == '#') while (i < s.len and s[i] != '\n') : (i += 1) {}; + const at = i; + defer c.pos = i; + if (i == s.len) return .{ .kind = .end, .at = at, .end = at }; + switch (s[i]) { + '\n' => { + i += 1; + return .{ .kind = .newline, .at = at, .end = i }; + }, + 'a'...'z', 'A'...'Z', '_' => { + while (i < s.len and (std.ascii.isAlphanumeric(s[i]) or s[i] == '_')) i += 1; + return .{ .kind = .name, .at = at, .end = i }; + }, + '0'...'9', '.' => { + while (i < s.len and (std.ascii.isDigit(s[i]) or s[i] == '.' or s[i] == 'e' or + ((s[i] == '-' or s[i] == '+') and s[i - 1] == 'e'))) i += 1; + return .{ .kind = .number, .at = at, .end = i }; + }, + else => { + i += 1; + return .{ .kind = .symbol, .at = at, .end = i, .symbol = s[at] }; + }, + } + } + + fn peek(c: *Compiler) Token { + const pos = c.pos; + defer c.pos = pos; + return c.next(); + } + + fn describe(c: *const Compiler, tok: Token) []const u8 { + return switch (tok.kind) { + .newline, .end => "the end of the line", + else => c.span(tok), + }; + } + + fn term(c: *Compiler, t: Term) !u16 { + if (c.term_count == max_terms) return c.fail(t.at, "the program is longer than {d} terms", .{max_terms}); + c.terms[c.term_count] = t; + c.term_count += 1; + return c.term_count - 1; + } + + fn call(c: *Compiler, op: Op, at: u32, args: []const u16) !u16 { + var t: Term = .{ .op = op, .at = at, .len = @intCast(args.len) }; + @memcpy(t.args[0..args.len], args); + return c.term(t); + } + + fn lookup(c: *const Compiler, name: []const u8) ?Name { + for (c.names[0..c.name_count]) |n| if (std.mem.eql(u8, n.text, name)) return n; + return null; + } + + fn lines(c: *Compiler) !void { + while (true) { + const first = c.next(); + switch (first.kind) { + .end => return, + .newline => continue, + .name => {}, + else => return c.fail(first.at, "a line is a name, =, and an expression", .{}), + } + const name = c.span(first); + const eq = c.next(); + if (!eq.is('=')) return c.fail(eq.at, "expected = after {s}, found {s}", .{ name, c.describe(eq) }); + if (builtin(name) != null) return c.fail(first.at, "{s} is a builtin: call yours something else", .{name}); + if (c.lookup(name) != null) return c.fail(first.at, "{s} is defined twice: a name is given once", .{name}); + c.colour = none; + const root = try c.expr(); + const after = c.next(); + if (after.kind != .newline and after.kind != .end) return c.fail(after.at, "expected the end of the line, found {s}", .{c.describe(after)}); + if (c.colour != none and (c.colour != root or !std.mem.eql(u8, name, "color"))) + return c.fail(c.terms[c.colour].at, "a colour (hsv, rgb) can only be the whole color line", .{}); + if (c.name_count == max_names) return c.fail(first.at, "more than {d} names", .{max_names}); + c.names[c.name_count] = .{ .text = name, .term = root, .at = first.at }; + c.name_count += 1; + } + } + + fn enter(c: *Compiler, at: u32) !void { + if (c.depth == max_depth) return c.fail(at, "nested more than {d} deep", .{max_depth}); + c.depth += 1; + } + + fn expr(c: *Compiler) error{Problem}!u16 { + try c.enter(c.peek().at); + defer c.depth -= 1; + var left = try c.product(); + while (true) { + const tok = c.peek(); + const op: Op = if (tok.is('+')) .add else if (tok.is('-')) .sub else return left; + _ = c.next(); + left = try c.call(op, tok.at, &.{ left, try c.product() }); + } + } + + fn product(c: *Compiler) !u16 { + var left = try c.unary(); + while (true) { + const tok = c.peek(); + const op: Op = if (tok.is('*')) .mul else if (tok.is('/')) .div else return left; + _ = c.next(); + left = try c.call(op, tok.at, &.{ left, try c.unary() }); + } + } + + fn unary(c: *Compiler) error{Problem}!u16 { + const tok = c.peek(); + if (!tok.is('-')) return c.primary(); + _ = c.next(); + try c.enter(tok.at); + defer c.depth -= 1; + const a = try c.unary(); + // A negative number is a number (each literal is a term of its own). + if (c.terms[a].op == .constant) { + c.terms[a].value = -c.terms[a].value; + return a; + } + return c.call(.neg, tok.at, &.{a}); + } + + fn primary(c: *Compiler) !u16 { + const tok = c.next(); + switch (tok.kind) { + .number => { + const value = std.fmt.parseFloat(f32, c.span(tok)) catch return c.fail(tok.at, "{s} is not a number", .{c.span(tok)}); + return c.term(.{ .op = .constant, .value = value, .at = tok.at }); + }, + .name => { + const name = c.span(tok); + if (c.peek().is('(')) return c.callOf(tok); + if (c.lookup(name)) |n| { + if (c.terms[n.term].op == .hsv or c.terms[n.term].op == .rgb) return c.fail(tok.at, "{s} is a colour: only the color line can be one", .{name}); + return n.term; + } + const b = builtin(name) orelse return c.fail(tok.at, "{s} is not defined above", .{name}); + if (b.max > 0) return c.fail(tok.at, "{s} takes arguments: {s}", .{ name, b.call }); + const input: ?usize = switch (b.op) { + .t => 0, + .x => 1, + .y => 2, + else => null, + }; + const i = input orelse return c.term(.{ .op = b.op, .value = b.value, .at = tok.at }); + if (c.inputs[i] == none) c.inputs[i] = try c.term(.{ .op = b.op, .at = tok.at }); + return c.inputs[i]; + }, + .newline, .end => return c.fail(tok.at, "expected an expression before the end of the line", .{}), + .symbol => { + if (!tok.is('(')) { + if (c.text[tok.at] < 0x20 or c.text[tok.at] > 0x7e) return c.fail(tok.at, "byte 0x{x:0>2} is not part of the language", .{c.text[tok.at]}); + return c.fail(tok.at, "expected an expression, found {s}", .{c.span(tok)}); + } + const inner = try c.expr(); + const close = c.next(); + if (!close.is(')')) return c.fail(close.at, "expected ) to close the ( at byte {d}, found {s}", .{ tok.at, c.describe(close) }); + return inner; + }, + } + } + + /// `name(args)`, `name` being `tok`. + fn callOf(c: *Compiler, tok: Token) !u16 { + const name = c.span(tok); + _ = c.next(); + const b = builtin(name) orelse { + if (c.lookup(name) != null) return c.fail(tok.at, "{s} is a name, not a builtin: it takes no ( )", .{name}); + return c.fail(tok.at, "{s} is not a builtin", .{name}); + }; + if (b.max == 0) return c.fail(tok.at, "{s} takes no arguments", .{name}); + var args: [max_args]u16 = undefined; + var n: u8 = 0; + if (c.peek().is(')')) { + _ = c.next(); + } else while (true) { + const at = c.peek().at; + if (n == b.max) return c.fail(at, "{s} takes at most {d} arguments: {s}", .{ name, b.max, b.call }); + args[n] = try c.expr(); + n += 1; + const sep = c.next(); + if (sep.is(')')) break; + if (!sep.is(',')) return c.fail(sep.at, "expected , or ) in {s}(...), found {s}", .{ name, c.describe(sep) }); + } + if (n < b.min) return c.fail(tok.at, "{s} takes {d} arguments, not {d}: {s}", .{ name, b.min, n, b.call }); + if (b.op == .noise) while (n < 3) : (n += 1) { + args[n] = try c.term(.{ .op = .constant, .at = tok.at }); + }; + const t = try c.call(b.op, tok.at, args[0..n]); + if (b.op == .hsv or b.op == .rgb) c.colour = t; + return t; + } + + /// The tape of the line named `name` (empty without one). + fn tape(c: *Compiler, into: *Tape, name: []const u8) !void { + into.* = .{}; + const line = c.lookup(name) orelse return; + var registers: [max_terms]u16 = @splat(none); + _ = c.emit(into, line.term, ®isters) catch + return c.fail(line.at, "the {s} line needs more than {d} instructions", .{ name, max_tape }); + } + + fn push(into: *Tape, i: Instruction) !u32 { + if (into.len == max_tape) return error.Full; + into.code[into.len] = i; + into.len += 1; + return into.len - 1; + } + + fn emit(c: *const Compiler, into: *Tape, at: u16, registers: *[max_terms]u16) error{Full}!u32 { + if (registers[at] != none) return registers[at]; + const t = c.terms[at]; + var r: [max_args]u32 = @splat(0); + for (t.args[0..t.len], 0..) |arg, i| r[i] = try c.emit(into, arg, registers); + const i: Instruction = switch (t.op) { + .constant => .{ .op = .constant, .a = @bitCast(t.value) }, + .seq => seq: { + // The values in registers side by side: as they are when + // each was emitted just now, else copied. + const values = r[1..t.len]; + var first = values[0]; + for (values, 0..) |v, k| { + if (v != values[0] + k) { + first = @intCast(into.len); + for (values) |each| _ = try push(into, .{ .op = .copy, .a = each }); + break; + } + } + break :seq .{ .op = .seq, .a = r[0], .b = first, .c = @intCast(values.len) }; + }, + else => .{ .op = t.op, .a = r[0], .b = r[1], .c = r[2] }, + }; + const register = try push(into, i); + registers[at] = @intCast(register); + return register; + } }; /// picture.frag's uniforms (SDL_GPU's fragment set). @@ -93,3 +489,210 @@ pub const Synth = extern struct { pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } }; }; + +// --------------------------------------------------------------------------- +// Tests. + +const testing = std.testing; + +fn compiled(text: []const u8) !Program { + return switch (compile(text)) { + .program => |p| p, + .problem => |p| { + std.debug.print("unexpected problem at {d}: {s}\n", .{ p.at, p.text() }); + return error.TestUnexpectedResult; + }, + }; +} + +fn ops(tape: Tape) [max_tape]Op { + var out: [max_tape]Op = @splat(.constant); + for (tape.slice(), 0..) |i, k| out[k] = i.op; + return out; +} + +fn expectOps(tape: Tape, want: []const Op) !void { + try testing.expectEqualSlices(Op, want, ops(tape)[0..tape.len]); +} + +/// The survey's program (reports/demo1.md, ยง1 A). +const survey = + \\# the beat, shared by sound and picture + \\bpm = 120 + \\beat = t * bpm / 60 + \\kick = exp(-7 * fract(beat)) + \\bar = beat / 4 + \\# sound: out is what you hear, -1..1 + \\root = seq(bar, 55, 55, 65.4, 49) + \\bass = saw(root * t) * (1 - kick) * 0.25 + \\thump = sin(tau * 48 * t * (1 + 2 * kick)) * kick * 0.5 + \\hat = noise(t * 9000) * exp(-30 * fract(beat * 2 + 0.5)) * 0.08 + \\out = bass + thump + hat + \\# picture: color is what you see; x and y run 0..1 + \\dx = x - 0.5 + \\dy = y - 0.5 + \\r = sqrt(dx * dx + dy * dy) + \\ring = smoothstep(0.03, 0, abs(r - 0.2 - 0.1 * kick)) + \\glow = 0.15 * noise(x * 6, y * 6, t * 0.5) + \\color = hsv(fract(bar / 4 + r), 0.6, ring + glow) + \\ +; + +test "a tone, instruction by instruction" { + const p = try compiled("out = sin(tau * 220 * t) * 0.3"); + try expectOps(p.out, &.{ .constant, .constant, .mul, .t, .mul, .sin, .constant, .mul }); + const code = p.out.slice(); + try testing.expectEqual(@as(u32, @bitCast(@as(f32, std.math.tau))), code[0].a); + try testing.expectEqual(@as(u32, @bitCast(@as(f32, 220))), code[1].a); + try testing.expectEqual(Instruction{ .op = .mul, .a = 0, .b = 1 }, code[2]); + try testing.expectEqual(Instruction{ .op = .mul, .a = 2, .b = 3 }, code[4]); + try testing.expectEqual(Instruction{ .op = .sin, .a = 4 }, code[5]); + try testing.expectEqual(Instruction{ .op = .mul, .a = 5, .b = 6 }, code[7]); + try testing.expectEqual(@as(u32, 0), p.color.len); +} + +test "the survey's program: each tape holds only what its line reaches" { + const p = try compiled(survey); + const heard = ops(p.out)[0..p.out.len]; + const seen = ops(p.color)[0..p.color.len]; + // The sound never reads x or y, nor is coloured; the picture has no + // bass line or hat. + for (heard) |op| try testing.expect(op != .x and op != .y and op != .hsv); + for (seen) |op| try testing.expect(op != .saw and op != .seq and op != .sin); + try testing.expectEqual(Op.add, heard[heard.len - 1]); + try testing.expectEqual(Op.hsv, seen[seen.len - 1]); + // t is one instruction however often it is named; seq's four numbers + // were emitted side by side, so there are no copies. + try testing.expectEqual(@as(usize, 1), std.mem.count(Op, heard, &.{.t})); + try testing.expectEqual(@as(usize, 0), std.mem.count(Op, heard, &.{.copy})); + try testing.expectEqual(@as(u32, 54), p.out.len); + try testing.expectEqual(@as(u32, 46), p.color.len); + // Every operand is an earlier register. + for ([_]Tape{ p.out, p.color }) |tape| for (tape.slice(), 0..) |i, k| { + if (@backingInt(i.op) < @backingInt(Op.neg)) continue; + try testing.expect(i.a < k); + if (i.op == .seq) { + try testing.expect(i.b + i.c <= k); + } else if (@backingInt(i.op) >= @backingInt(Op.add)) try testing.expect(i.b < k); + }; +} + +test "every builtin" { + for (builtins) |b| { + var buf: [128]u8 = undefined; + var w: std.Io.Writer = .fixed(&buf); + try w.print("{s} = {s}", .{ if (b.op == .hsv or b.op == .rgb) "color" else "out", b.name() }); + if (b.max > 0) { + try w.writeAll("(t"); + for (1..b.min) |_| try w.writeAll(", t * 2"); + try w.writeAll(")"); + } + const p = try compiled(w.buffered()); + const tape = if (b.op == .hsv or b.op == .rgb) p.color else p.out; + const last = tape.slice()[tape.len - 1]; + try testing.expectEqual(b.op, last.op); + if (b.op == .constant) try testing.expectEqual(@as(u32, @bitCast(b.value)), last.a); + } + // noise's missing arguments are 0; seq copies values that were not + // emitted side by side. + const p = try compiled("a = t * 3\nout = noise(t) + seq(t, 1, a, 2)"); + try expectOps(p.out, &.{ .t, .constant, .constant, .noise, .constant, .constant, .mul, .constant, .copy, .copy, .copy, .seq, .add }); + try testing.expectEqual(Instruction{ .op = .seq, .a = 0, .b = 8, .c = 3 }, p.out.slice()[11]); + try testing.expectEqual(Instruction{ .op = .copy, .a = 6 }, p.out.slice()[9]); +} + +test "precedence, unary minus, numbers, comments, blank lines" { + const p = try compiled("\n # nothing\n a = 1 + 2 * -t / 4 - (5 - -6) # trailing\n\nout = a + 1e-3\n"); + // 1 + ((2 * -t) / 4) - (5 - -6) + try expectOps(p.out, &.{ .constant, .constant, .t, .neg, .mul, .constant, .div, .add, .constant, .constant, .sub, .sub, .constant, .add }); + try testing.expectEqual(@as(u32, @bitCast(@as(f32, -6))), p.out.slice()[9].a); + try testing.expectEqual(@as(u32, @bitCast(@as(f32, 1e-3))), p.out.slice()[12].a); +} + +test "every problem, with its byte" { + const cases = [_]struct { text: []const u8, at: u32, words: []const u8 }{ + .{ .text = "= 1", .at = 0, .words = "a line is a name, =, and an expression" }, + .{ .text = "out 1", .at = 4, .words = "expected = after out, found 1" }, + .{ .text = "out", .at = 3, .words = "expected = after out, found the end of the line" }, + .{ .text = "sin = 1", .at = 0, .words = "sin is a builtin: call yours something else" }, + .{ .text = "a = 1\na = 2", .at = 6, .words = "a is defined twice: a name is given once" }, + .{ .text = "out = 1 2", .at = 8, .words = "expected the end of the line, found 2" }, + .{ .text = "out = rgb(1, 1, 1)", .at = 6, .words = "a colour (hsv, rgb) can only be the whole color line" }, + .{ .text = "color = hsv(1, 1, 1) * 2", .at = 8, .words = "a colour (hsv, rgb) can only be the whole color line" }, + .{ .text = "color = hsv(1, 1, 1)\nout = color", .at = 27, .words = "color is a colour: only the color line can be one" }, + .{ .text = "out = 1.2.3", .at = 6, .words = "1.2.3 is not a number" }, + .{ .text = "out = kick\nkick = 1", .at = 6, .words = "kick is not defined above" }, + .{ .text = "out = sin", .at = 6, .words = "sin takes arguments: sin(a)" }, + .{ .text = "out = 1 +", .at = 9, .words = "expected an expression before the end of the line" }, + .{ .text = "out = * 2", .at = 6, .words = "expected an expression, found *" }, + .{ .text = "out = 1 $ 2", .at = 8, .words = "expected the end of the line, found $" }, + .{ .text = "out = \x01", .at = 6, .words = "byte 0x01 is not part of the language" }, + .{ .text = "out = (1 + 2", .at = 12, .words = "expected ) to close the ( at byte 6, found the end of the line" }, + .{ .text = "a = 1\nout = a(2)", .at = 12, .words = "a is a name, not a builtin: it takes no ( )" }, + .{ .text = "out = foo(2)", .at = 6, .words = "foo is not a builtin" }, + .{ .text = "out = t(2)", .at = 6, .words = "t takes no arguments" }, + .{ .text = "out = sin(1, 2)", .at = 13, .words = "sin takes at most 1 arguments: sin(a)" }, + .{ .text = "out = sin(1 2)", .at = 12, .words = "expected , or ) in sin(...), found 2" }, + .{ .text = "out = mix(1, 2)", .at = 6, .words = "mix takes 3 arguments, not 2: mix(a, b, w)" }, + .{ .text = "out = sin()", .at = 6, .words = "sin takes 1 arguments, not 0: sin(a)" }, + }; + for (cases) |case| switch (compile(case.text)) { + .program => { + std.debug.print("{s}: no problem\n", .{case.text}); + return error.TestUnexpectedResult; + }, + .problem => |p| { + testing.expectEqualStrings(case.words, p.text()) catch |e| { + std.debug.print("in {s}\n", .{case.text}); + return e; + }; + try testing.expectEqual(case.at, p.at); + }, + }; +} + +test "past the capacities: problems in words" { + var buf: [8192]u8 = undefined; + // A tape of 128 fits; one more instruction does not. + var w: std.Io.Writer = .fixed(&buf); + try w.writeAll("out = t"); + for (0..63) |_| try w.writeAll(" + 1"); + const fits = try compiled(w.buffered()); + try testing.expectEqual(@as(u32, 127), fits.out.len); + try w.writeAll(" + 1"); + switch (compile(w.buffered())) { + .program => return error.TestUnexpectedResult, + .problem => |p| { + try testing.expectEqualStrings("the out line needs more than 128 instructions", p.text()); + try testing.expectEqual(@as(u32, 0), p.at); + }, + } + // More terms than the compiler keeps, though no tape reaches them. + w = .fixed(&buf); + for (0..300) |_| try w.writeAll("1+"); + try w.writeAll("1"); + const long = w.buffered(); + var text: [8192]u8 = undefined; + const unused = try std.fmt.bufPrint(&text, "a = {s}\n", .{long}); + switch (compile(unused)) { + .program => return error.TestUnexpectedResult, + .problem => |p| try testing.expectEqualStrings("the program is longer than 512 terms", p.text()), + } + // Names. + w = .fixed(&buf); + for (0..max_names + 1) |i| try w.print("n{d} = {d}\n", .{ i, i }); + switch (compile(w.buffered())) { + .program => return error.TestUnexpectedResult, + .problem => |p| try testing.expectEqualStrings("more than 128 names", p.text()), + } + // Depth. + w = .fixed(&buf); + try w.writeAll("out = "); + for (0..40) |_| try w.writeAll("("); + try w.writeAll("1"); + for (0..40) |_| try w.writeAll(")"); + switch (compile(w.buffered())) { + .program => return error.TestUnexpectedResult, + .problem => |p| try testing.expectEqualStrings("nested more than 32 deep", p.text()), + } +} diff --git a/examples/live/src/probe.zig b/examples/live/src/probe.zig index 663bed3..5f6e8ee 100644 --- a/examples/live/src/probe.zig +++ b/examples/live/src/probe.zig @@ -58,7 +58,7 @@ fn madeUp(comptime len: u32) [Lang.max_tape][4]u32 { else => if (i == len - 1) .hsv else if (i % 10 == 9) .noise else cycle[i % cycle.len], }; const a: u32 = if (op == .constant) @bitCast(@as(f32, 6)) else @intCast(i -| 1); - code[i] = .{ @intFromEnum(op), a, @intCast(i -| 2), @intCast(i -| 3) }; + code[i] = .{ @backingInt(op), a, @intCast(i -| 2), @intCast(i -| 3) }; } return code; } |
