diff options
Diffstat (limited to 'examples')
| -rw-r--r-- | examples/live/README.md | 123 | ||||
| -rw-r--r-- | examples/live/build.zig | 67 | ||||
| -rw-r--r-- | examples/live/build.zig.zon | 16 | ||||
| -rw-r--r-- | examples/live/grammar/grammar.js | 24 | ||||
| -rw-r--r-- | examples/live/grammar/src/parser.c | 918 | ||||
| -rw-r--r-- | examples/live/grammar/src/tree_sitter/alloc.h | 54 | ||||
| -rw-r--r-- | examples/live/grammar/src/tree_sitter/array.h | 330 | ||||
| -rw-r--r-- | examples/live/grammar/src/tree_sitter/parser.h | 286 | ||||
| -rw-r--r-- | examples/live/queries/highlights.scm | 6 | ||||
| -rw-r--r-- | examples/live/queries/indents.scm | 5 | ||||
| -rw-r--r-- | examples/live/shaders/fullscreen.vert | 6 | ||||
| -rw-r--r-- | examples/live/shaders/picture.frag | 14 | ||||
| -rw-r--r-- | examples/live/shaders/synth.comp | 28 | ||||
| -rw-r--r-- | examples/live/shaders/vm.glsl | 93 | ||||
| -rw-r--r-- | examples/live/src/Lang.zig | 754 | ||||
| -rw-r--r-- | examples/live/src/main.zig | 458 | ||||
| -rw-r--r-- | examples/live/src/probe.zig | 133 | ||||
| -rw-r--r-- | examples/live/test/grammar.zig | 54 | ||||
| -rw-r--r-- | examples/live/test/live.script | 111 | ||||
| -rw-r--r-- | examples/live/test/probe.script | 4 | ||||
| -rw-r--r-- | examples/live/test/story.script | 157 |
21 files changed, 3641 insertions, 0 deletions
diff --git a/examples/live/README.md b/examples/live/README.md new file mode 100644 index 0000000..ea62cec --- /dev/null +++ b/examples/live/README.md @@ -0,0 +1,123 @@ +# live + +A program typed over its own picture, and heard, in pardes's editor +(helix's keys, the language's grammar colouring it). Each line names an +expression; the `out` line is what you hear (-1..1), the `color` line what +you see. At every keystroke that leaves a program that parses, the +program is compiled into two tapes of at most 128 instructions, and one +interpreter on the GPU runs them per sample and per pixel. While a line +is broken, the last good program keeps playing and the problem is marked +under its byte. + +``` +bpm = 120 +beat = t * bpm / 60 +kick = exp(-7 * fract(beat)) +thump = sin(tau * 48 * t * (1 + 2 * kick)) * kick * 0.5 +out = thump +r = sqrt(x * x + y * y) +color = hsv(fract(beat / 16 + r), 0.6, smoothstep(0.06, 0, abs(r - 0.4 - 0.2 * kick))) +``` + +The picture pulses with the kick because both lines say `kick`. + +## Running it + +`zig build run` (with `zig build lib --watch -fincremental` beside it for +hot reload: an edit of main.zig is back in 0.07-0.09 s). It needs pardes +beside sketchbook (`../02-pardes-code` of sketchbook's directory), whose +editor it takes as a library. + +**Keys** are helix's: `i` (or `a`, `o`, `O`) to type, Escape back to +normal mode, where `h j k l w b` move, `x` takes a line, `d` deletes, `c` +changes, `r` replaces a character, `u` and `U` undo and redo, `%` takes +it all. The mode is in the corner (NOR, INS, SEL). The pointer drags. + +**Hear this.** Alt-o grows the selection to the expression around it, +Alt-i shrinks it back, Alt-n and Alt-p go to the next and previous: after +any of them, that expression alone is heard (as `out`) and seen (grey, +unless it is a colour) until the next key. Escape, or any edit, goes back +to the program. `f*` then `;` then `mi(` then Alt-o, in +`thump = sin(tau * 48 * t ...)`, hears the sine alone. + +**Drag a number.** Press on a number and drag sideways: it moves a step +every 4 pixels, its step from how it is written (`220` by ones, `0.25` +by hundredths), and the program follows as you drag. The whole drag is +one step to undo. + +**Scrub** through the console (backtick): `sessions` lists the sessions +recorded, `play session N` plays one back (`play session N at 12` paused +at 12 s in), +`pause`, `seek 5000` (to 5 s in), `step -60` (60 frames back), `stop` +(live again from that moment, the session kept as it was). A seek brings back the text, the tapes and +the picture of that moment, and the sound with them. `capture` appends +what is heard to `capture.f32` beside the save (mono f32 at the +device's rate) until `capture` again; `set crossfade false` lets an edit +click. + +`zig build test` runs the language's tests, the grammar against the +language (test/grammar.zig), and test/live.script and test/story.script +(the storyboard: a tone, a drag, a gradient, a kick, a `)` broken and +mended, a probe, a bass and a ring, the session played back and sought) +headless; `zig build probe` times the interpreter on the GPU +(`--profile-gpu`). + +## The language + +A line is `name = expression`, a name defined once and before it is used, +so a program has no loops or recursion and always ends. Expressions: +numbers (`0.5`, `120`, `1e-3`), names, `+ - * /`, unary `-`, parentheses, +calls; `#` starts a comment. The builtins (src/Lang.zig's one table): + +| | | +| --- | --- | +| `t` | seconds | +| `x`, `y` | across and up from the centre, in half the window's height (`y` -1 to 1, `x` -1.78 to 1.78 on 16:9: a circle is round); 0 in sound | +| `tau`, `pi` | a turn and half a turn, in radians | +| `sin(a)`, `cos(a)` | of radians | +| `exp(a)`, `log(a)`, `pow(a, b)`, `sqrt(a)` | e to the a, its inverse, a to the b (a not negative), square root | +| `abs(a)`, `floor(a)`, `fract(a)` | without its sign, the whole number at or below, a - floor(a) | +| `min(a, b)`, `max(a, b)`, `clamp(v, lo, hi)` | the smaller, the larger, v kept between | +| `mix(a, b, w)` | a + (b - a) * w | +| `step(edge, v)` | 0 below edge, 1 from it on | +| `smoothstep(lo, hi, v)` | 0 to 1 smoothly as v goes from lo to hi, either way round | +| `atan2(y, x)` | the angle of the point (x, y) | +| `noise(x, y, z)` | smooth noise, -1..1, a new value about every 1; y and z 0 when left out | +| `saw(p)`, `sqr(p)`, `tri(p)` | waves of period 1 (cycles, not radians), -1..1; saw and tri rise through 0 at 0, sqr is 1 then -1 | +| `seq(i, v0, v1, ...)` | the value at floor(i), round the list: a step pattern, 16 values at most | +| `hsv(h, s, v)`, `rgb(r, g, b)` | a colour (hue 0..1 round the wheel); only as the whole `color` line | + +Capacities: 128 instructions a tape (a line reaches only what it uses), +512 terms and 128 names in the text, nesting 32 deep, 4 KiB of text. Past +any of them is a problem like a syntax error, in words, at its byte. + +## What it cannot say + +No state between samples or between frames: every sample is a function of +its time alone, every pixel of x, y and t. So no filters, feedback, delay +lines or reverb, and no picture that remembers the last frame. That is the +price of computing every sample alone on the GPU, and what makes a replayed +moment sound and look as it did. An echo can be said by evaluating again +at an earlier time (`t - 0.25` in a copy of the line). No user functions, +no vectors but the final colour, and `t` is a 32-bit float: past ten +minutes or so a high pitch begins to roughen. + +## How it works + +src/Lang.zig compiles the text in `update` (no allocation: fixed arrays on +the stack) into tapes of `{op, a, b, c}`, instruction i writing register +i; State keeps the editor's value (pardes-editor: 39 KiB of plain data, +4 KiB of text), both tapes, the probe's, the problem, the drag and the +time. grammar/grammar.js, generated into the committed grammar/src/parser.c, +is the same language for tree-sitter: its parse colours the text +(queries/highlights.scm, in pardes's orchard theme), gives Alt-o its +nodes and a new line its indent (queries/indents.scm). The tapes +go to the GPU as data: the color tape as picture.frag's uniforms, the out +tape (with the one it replaces, for the crossfade) in a storage buffer for +synth.comp, both including shaders/vm.glsl, a loop over the tape with a +switch per op. No shader is compiled after the first frame, so typing +never stalls one. A color tape over 64 instructions is drawn at half +resolution: on an RTX 3050, 128 instructions took 2.7 ms at 1280x720 and +0.85 at half; 60 took 1.4 at full. The sound is `pub const audio_pull = +256` and a block a frame, as much as keeps the host's lead queued: a +change is heard a pull or so after the frame that made it. diff --git a/examples/live/build.zig b/examples/live/build.zig new file mode 100644 index 0000000..cd686c0 --- /dev/null +++ b/examples/live/build.zig @@ -0,0 +1,67 @@ +const std = @import("std"); +const sketchbook = @import("sketchbook"); +const Lang = @import("src/Lang.zig"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + const sb = sketchbook.init(b, .{ .target = target, .optimize = optimize }); + + // The interpreter's op numbers, from Lang.Op: one definition. + const ops = b.addWriteFiles(); + _ = ops.add("ops.glsl", comptime blk: { + var glsl: []const u8 = "// Generated from Lang.Op by build.zig; do not edit.\n"; + for (std.enums.values(Lang.Op)) |op| glsl = glsl ++ std.fmt.comptimePrint("const uint OP_{t} = {d}u;\n", .{ op, @backingInt(op) }); + break :blk glsl; + }); + const lang = b.createModule(.{ .root_source_file = b.path("src/Lang.zig") }); + const shaders = sb.addShaders(.{ + .layouts = .{ .module = lang, .types = &.{ "Picture", "Synth" } }, + .include_dirs = &.{ops.getDirectory()}, + .sources = &.{ + b.path("shaders/fullscreen.vert"), + b.path("shaders/picture.frag"), + b.path("shaders/synth.comp"), + }, + }); + const imports: []const std.Build.Module.Import = &.{ + .{ .name = "Lang", .module = lang }, + .{ .name = "shaders", .module = shaders.module }, + .{ .name = "scope", .module = sb.modules.scope }, + }; + + // The editor: helix's keys over a value kept in State. Its tree-sitter + // set is the smallest there is (Zig's grammar), as the language's own + // grammar is handed in at run time. + const pardes = b.dependency("pardes", .{ .target = target, .optimize = optimize, .@"tree-sitter" = .zig, .editor = true }); + const app = sb.app(.{ .name = "live", .root_source_file = b.path("src/main.zig"), .imports = &.{ + .{ .name = "Lang", .module = lang }, + .{ .name = "shaders", .module = shaders.module }, + .{ .name = "scope", .module = sb.modules.scope }, + .{ .name = "pardes-editor", .module = pardes.module("pardes-editor") }, + } }); + // The language's tree-sitter grammar: grammar/grammar.js and the + // parser.c generated from it, committed (the build never runs the + // generator); its colours and a new line's indent, queries/. + const grammar = b.addLibrary(.{ .name = "tree-sitter-live", .linkage = .static, .root_module = b.createModule(.{ .target = target, .optimize = .ReleaseFast, .link_libc = true, .pic = true }) }); + grammar.root_module.addCSourceFile(.{ .file = b.path("grammar/src/parser.c") }); + grammar.root_module.addIncludePath(b.path("grammar/src")); + app.module.linkLibrary(grammar); + app.module.addAnonymousImport("highlights.scm", .{ .root_source_file = b.path("queries/highlights.scm") }); + app.module.addAnonymousImport("indents.scm", .{ .root_source_file = b.path("queries/indents.scm") }); + const steps = app.addSteps(.{ .scripts = &.{ b.path("test/live.script"), b.path("test/story.script") }, .tests = &.{b.path("test/grammar.zig")} }); + const lang_test = b.addTest(.{ .root_module = b.createModule(.{ .root_source_file = b.path("src/Lang.zig"), .target = target, .optimize = optimize }) }); + steps.test_step.dependOn(&b.addRunArtifact(lang_test).step); + + // The interpreter's GPU time over made-up tapes (`--profile-gpu`). + const probe = sb.app(.{ .name = "live-probe", .root_source_file = b.path("src/probe.zig"), .imports = imports }); + const run_probe = b.addRunArtifact(probe.addExecutable()); + run_probe.addArgs(&.{ "--headless", "--fresh", "--profile-gpu", "--script" }); + run_probe.addFileArg(b.path("test/probe.script")); + run_probe.addArg("--state"); + _ = run_probe.addOutputFileArg("probe.xitdb"); + run_probe.setCwd(b.path(".")); + run_probe.stdio = .inherit; + run_probe.has_side_effects = true; + b.step("probe", "Time the interpreter on the GPU over made-up tapes").dependOn(&run_probe.step); +} diff --git a/examples/live/build.zig.zon b/examples/live/build.zig.zon new file mode 100644 index 0000000..d5d265a --- /dev/null +++ b/examples/live/build.zig.zon @@ -0,0 +1,16 @@ +.{ + .name = .live, + .version = "0.0.1", + .dependencies = .{ + // `../..` spelled as pardes spells it (its `../sketchbook`): a + // package is told by its path's spelling, and one file cannot be + // in two. + .sketchbook = .{ .path = "../../../sketchbook" }, + // pardes's editor as a library (`pardes-editor`), from the checkout + // beside sketchbook's. + .pardes = .{ .path = "../../../02-pardes-code" }, + }, + .minimum_zig_version = "0.17.0", + .paths = .{""}, + .fingerprint = 0x530f2caf5c8f14ab, +} diff --git a/examples/live/grammar/grammar.js b/examples/live/grammar/grammar.js new file mode 100644 index 0000000..31f50b1 --- /dev/null +++ b/examples/live/grammar/grammar.js @@ -0,0 +1,24 @@ +// The language as src/Lang.zig parses it, for tree-sitter: lines of +// `name = expression`, `+ -` below `* /` below unary `-`, calls, numbers, +// names, `#` comments. `tree-sitter generate` here writes src/parser.c, +// which is committed: the build compiles it and never runs the generator. +module.exports = grammar({ + name: 'live', + extras: $ => [/[ \t\r]/, $.comment], + word: $ => $.name, + rules: { + source_file: $ => seq(optional($.definition), repeat(seq('\n', optional($.definition)))), + definition: $ => seq(field('name', $.name), '=', field('value', $._expression)), + _expression: $ => choice($.binary, $.unary, $.call, $.parenthesized, $.number, $.name), + binary: $ => choice( + prec.left(1, seq(field('left', $._expression), field('operator', choice('+', '-')), field('right', $._expression))), + prec.left(2, seq(field('left', $._expression), field('operator', choice('*', '/')), field('right', $._expression))), + ), + unary: $ => prec(3, seq('-', field('operand', $._expression))), + call: $ => seq(field('function', $.name), '(', optional(seq($._expression, repeat(seq(',', $._expression)))), ')'), + parenthesized: $ => seq('(', $._expression, ')'), + number: $ => /(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?/, + name: $ => /[a-zA-Z_][a-zA-Z0-9_]*/, + comment: $ => /#[^\n]*/, + }, +}); diff --git a/examples/live/grammar/src/parser.c b/examples/live/grammar/src/parser.c new file mode 100644 index 0000000..e694827 --- /dev/null +++ b/examples/live/grammar/src/parser.c @@ -0,0 +1,918 @@ +/* Automatically @generated by tree-sitter */ + +#include "tree_sitter/parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 14 +#define STATE_COUNT 31 +#define LARGE_STATE_COUNT 2 +#define SYMBOL_COUNT 22 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 13 +#define EXTERNAL_TOKEN_COUNT 0 +#define FIELD_COUNT 7 +#define MAX_ALIAS_SEQUENCE_LENGTH 5 +#define MAX_RESERVED_WORD_SET_SIZE 0 +#define PRODUCTION_ID_COUNT 5 +#define SUPERTYPE_COUNT 0 + +enum ts_symbol_identifiers { + sym_name = 1, + anon_sym_LF = 2, + anon_sym_EQ = 3, + anon_sym_PLUS = 4, + anon_sym_DASH = 5, + anon_sym_STAR = 6, + anon_sym_SLASH = 7, + anon_sym_LPAREN = 8, + anon_sym_COMMA = 9, + anon_sym_RPAREN = 10, + sym_number = 11, + sym_comment = 12, + sym_source_file = 13, + sym_definition = 14, + sym__expression = 15, + sym_binary = 16, + sym_unary = 17, + sym_call = 18, + sym_parenthesized = 19, + aux_sym_source_file_repeat1 = 20, + aux_sym_call_repeat1 = 21, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [sym_name] = "name", + [anon_sym_LF] = "\n", + [anon_sym_EQ] = "=", + [anon_sym_PLUS] = "+", + [anon_sym_DASH] = "-", + [anon_sym_STAR] = "*", + [anon_sym_SLASH] = "/", + [anon_sym_LPAREN] = "(", + [anon_sym_COMMA] = ",", + [anon_sym_RPAREN] = ")", + [sym_number] = "number", + [sym_comment] = "comment", + [sym_source_file] = "source_file", + [sym_definition] = "definition", + [sym__expression] = "_expression", + [sym_binary] = "binary", + [sym_unary] = "unary", + [sym_call] = "call", + [sym_parenthesized] = "parenthesized", + [aux_sym_source_file_repeat1] = "source_file_repeat1", + [aux_sym_call_repeat1] = "call_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [sym_name] = sym_name, + [anon_sym_LF] = anon_sym_LF, + [anon_sym_EQ] = anon_sym_EQ, + [anon_sym_PLUS] = anon_sym_PLUS, + [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_SLASH] = anon_sym_SLASH, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [sym_number] = sym_number, + [sym_comment] = sym_comment, + [sym_source_file] = sym_source_file, + [sym_definition] = sym_definition, + [sym__expression] = sym__expression, + [sym_binary] = sym_binary, + [sym_unary] = sym_unary, + [sym_call] = sym_call, + [sym_parenthesized] = sym_parenthesized, + [aux_sym_source_file_repeat1] = aux_sym_source_file_repeat1, + [aux_sym_call_repeat1] = aux_sym_call_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [sym_name] = { + .visible = true, + .named = true, + }, + [anon_sym_LF] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [sym_number] = { + .visible = true, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [sym_source_file] = { + .visible = true, + .named = true, + }, + [sym_definition] = { + .visible = true, + .named = true, + }, + [sym__expression] = { + .visible = false, + .named = true, + }, + [sym_binary] = { + .visible = true, + .named = true, + }, + [sym_unary] = { + .visible = true, + .named = true, + }, + [sym_call] = { + .visible = true, + .named = true, + }, + [sym_parenthesized] = { + .visible = true, + .named = true, + }, + [aux_sym_source_file_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_call_repeat1] = { + .visible = false, + .named = false, + }, +}; + +enum ts_field_identifiers { + field_function = 1, + field_left = 2, + field_name = 3, + field_operand = 4, + field_operator = 5, + field_right = 6, + field_value = 7, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_function] = "function", + [field_left] = "left", + [field_name] = "name", + [field_operand] = "operand", + [field_operator] = "operator", + [field_right] = "right", + [field_value] = "value", +}; + +static const TSMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [1] = {.index = 0, .length = 2}, + [2] = {.index = 2, .length = 1}, + [3] = {.index = 3, .length = 1}, + [4] = {.index = 4, .length = 3}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_name, 0}, + {field_value, 2}, + [2] = + {field_operand, 1}, + [3] = + {field_function, 0}, + [4] = + {field_left, 0}, + {field_operator, 1}, + {field_right, 2}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 6, + [7] = 7, + [8] = 8, + [9] = 9, + [10] = 10, + [11] = 11, + [12] = 12, + [13] = 13, + [14] = 14, + [15] = 15, + [16] = 16, + [17] = 17, + [18] = 18, + [19] = 19, + [20] = 20, + [21] = 21, + [22] = 22, + [23] = 23, + [24] = 24, + [25] = 25, + [26] = 26, + [27] = 27, + [28] = 28, + [29] = 29, + [30] = 30, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(4); + ADVANCE_MAP( + '\n', 5, + '#', 18, + '(', 11, + ')', 13, + '*', 9, + '+', 7, + ',', 12, + '-', 8, + '.', 2, + '/', 10, + '=', 6, + ); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') SKIP(0); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(14); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(17); + END_STATE(); + case 1: + if (lookahead == '+' || + lookahead == '-') ADVANCE(3); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(16); + END_STATE(); + case 2: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(15); + END_STATE(); + case 3: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(16); + END_STATE(); + case 4: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 5: + ACCEPT_TOKEN(anon_sym_LF); + END_STATE(); + case 6: + ACCEPT_TOKEN(anon_sym_EQ); + END_STATE(); + case 7: + ACCEPT_TOKEN(anon_sym_PLUS); + END_STATE(); + case 8: + ACCEPT_TOKEN(anon_sym_DASH); + END_STATE(); + case 9: + ACCEPT_TOKEN(anon_sym_STAR); + END_STATE(); + case 10: + ACCEPT_TOKEN(anon_sym_SLASH); + END_STATE(); + case 11: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 12: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 13: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 14: + ACCEPT_TOKEN(sym_number); + if (lookahead == '.') ADVANCE(15); + if (lookahead == 'e') ADVANCE(1); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(14); + END_STATE(); + case 15: + ACCEPT_TOKEN(sym_number); + if (lookahead == 'e') ADVANCE(1); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(15); + END_STATE(); + case 16: + ACCEPT_TOKEN(sym_number); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(16); + END_STATE(); + case 17: + ACCEPT_TOKEN(sym_name); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(17); + END_STATE(); + case 18: + ACCEPT_TOKEN(sym_comment); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(18); + END_STATE(); + default: + return false; + } +} + +static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + default: + return false; + } +} + +static const TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0}, + [1] = {.lex_state = 0}, + [2] = {.lex_state = 0}, + [3] = {.lex_state = 0}, + [4] = {.lex_state = 0}, + [5] = {.lex_state = 0}, + [6] = {.lex_state = 0}, + [7] = {.lex_state = 0}, + [8] = {.lex_state = 0}, + [9] = {.lex_state = 0}, + [10] = {.lex_state = 0}, + [11] = {.lex_state = 0}, + [12] = {.lex_state = 0}, + [13] = {.lex_state = 0}, + [14] = {.lex_state = 0}, + [15] = {.lex_state = 0}, + [16] = {.lex_state = 0}, + [17] = {.lex_state = 0}, + [18] = {.lex_state = 0}, + [19] = {.lex_state = 0}, + [20] = {.lex_state = 0}, + [21] = {.lex_state = 0}, + [22] = {.lex_state = 0}, + [23] = {.lex_state = 0}, + [24] = {.lex_state = 0}, + [25] = {.lex_state = 0}, + [26] = {.lex_state = 0}, + [27] = {.lex_state = 0}, + [28] = {.lex_state = 0}, + [29] = {.lex_state = 0}, + [30] = {.lex_state = 0}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [STATE(0)] = { + [ts_builtin_sym_end] = ACTIONS(1), + [sym_name] = ACTIONS(1), + [anon_sym_LF] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [anon_sym_PLUS] = ACTIONS(1), + [anon_sym_DASH] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_SLASH] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [sym_number] = ACTIONS(1), + [sym_comment] = ACTIONS(3), + }, + [STATE(1)] = { + [sym_source_file] = STATE(30), + [sym_definition] = STATE(22), + [aux_sym_source_file_repeat1] = STATE(23), + [ts_builtin_sym_end] = ACTIONS(5), + [sym_name] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(9), + [sym_comment] = ACTIONS(3), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(17), 1, + anon_sym_RPAREN, + ACTIONS(19), 1, + sym_number, + STATE(17), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [26] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(21), 1, + sym_number, + STATE(10), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [49] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(23), 1, + sym_number, + STATE(18), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [72] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + sym_number, + STATE(20), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [95] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(29), 1, + anon_sym_LPAREN, + ACTIONS(27), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [112] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + sym_number, + STATE(13), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [135] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_number, + STATE(19), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [158] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(11), 1, + sym_name, + ACTIONS(13), 1, + anon_sym_DASH, + ACTIONS(15), 1, + anon_sym_LPAREN, + ACTIONS(35), 1, + sym_number, + STATE(14), 5, + sym__expression, + sym_binary, + sym_unary, + sym_call, + sym_parenthesized, + [181] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(37), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [195] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(39), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [209] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(41), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [223] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [237] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(45), 2, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(43), 6, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [253] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(47), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [267] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(49), 8, + ts_builtin_sym_end, + anon_sym_LF, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_COMMA, + anon_sym_RPAREN, + [281] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(53), 1, + anon_sym_COMMA, + ACTIONS(55), 1, + anon_sym_RPAREN, + STATE(26), 1, + aux_sym_call_repeat1, + ACTIONS(45), 2, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(51), 2, + anon_sym_PLUS, + anon_sym_DASH, + [302] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(45), 2, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(51), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(57), 2, + ts_builtin_sym_end, + anon_sym_LF, + [318] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(45), 2, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(51), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(59), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [334] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(61), 1, + anon_sym_RPAREN, + ACTIONS(45), 2, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(51), 2, + anon_sym_PLUS, + anon_sym_DASH, + [349] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + sym_name, + STATE(28), 1, + sym_definition, + ACTIONS(63), 2, + ts_builtin_sym_end, + anon_sym_LF, + [363] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(9), 1, + anon_sym_LF, + ACTIONS(65), 1, + ts_builtin_sym_end, + STATE(24), 1, + aux_sym_source_file_repeat1, + [376] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(9), 1, + anon_sym_LF, + ACTIONS(65), 1, + ts_builtin_sym_end, + STATE(25), 1, + aux_sym_source_file_repeat1, + [389] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(9), 1, + anon_sym_LF, + ACTIONS(67), 1, + ts_builtin_sym_end, + STATE(25), 1, + aux_sym_source_file_repeat1, + [402] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(69), 1, + ts_builtin_sym_end, + ACTIONS(71), 1, + anon_sym_LF, + STATE(25), 1, + aux_sym_source_file_repeat1, + [415] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(53), 1, + anon_sym_COMMA, + ACTIONS(74), 1, + anon_sym_RPAREN, + STATE(27), 1, + aux_sym_call_repeat1, + [428] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_RPAREN, + ACTIONS(76), 1, + anon_sym_COMMA, + STATE(27), 1, + aux_sym_call_repeat1, + [441] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(69), 2, + ts_builtin_sym_end, + anon_sym_LF, + [449] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(79), 1, + anon_sym_EQ, + [456] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(81), 1, + ts_builtin_sym_end, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(2)] = 0, + [SMALL_STATE(3)] = 26, + [SMALL_STATE(4)] = 49, + [SMALL_STATE(5)] = 72, + [SMALL_STATE(6)] = 95, + [SMALL_STATE(7)] = 112, + [SMALL_STATE(8)] = 135, + [SMALL_STATE(9)] = 158, + [SMALL_STATE(10)] = 181, + [SMALL_STATE(11)] = 195, + [SMALL_STATE(12)] = 209, + [SMALL_STATE(13)] = 223, + [SMALL_STATE(14)] = 237, + [SMALL_STATE(15)] = 253, + [SMALL_STATE(16)] = 267, + [SMALL_STATE(17)] = 281, + [SMALL_STATE(18)] = 302, + [SMALL_STATE(19)] = 318, + [SMALL_STATE(20)] = 334, + [SMALL_STATE(21)] = 349, + [SMALL_STATE(22)] = 363, + [SMALL_STATE(23)] = 376, + [SMALL_STATE(24)] = 389, + [SMALL_STATE(25)] = 402, + [SMALL_STATE(26)] = 415, + [SMALL_STATE(27)] = 428, + [SMALL_STATE(28)] = 441, + [SMALL_STATE(29)] = 449, + [SMALL_STATE(30)] = 456, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [27] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [37] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary, 2, 0, 2), + [39] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized, 3, 0, 0), + [41] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call, 3, 0, 3), + [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary, 3, 0, 4), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [47] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call, 4, 0, 3), + [49] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call, 5, 0, 3), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [57] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_definition, 3, 0, 1), + [59] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_call_repeat1, 2, 0, 0), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [63] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), + [65] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [67] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 2, 0, 0), + [69] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [71] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(21), + [74] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [76] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_call_repeat1, 2, 0, 0), SHIFT_REPEAT(8), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [81] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), +}; + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_live(void) { + static const TSLanguage language = { + .abi_version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = ts_field_map_slices, + .field_map_entries = ts_field_map_entries, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = (const void*)ts_lex_modes, + .lex_fn = ts_lex, + .keyword_lex_fn = ts_lex_keywords, + .keyword_capture_token = sym_name, + .primary_state_ids = ts_primary_state_ids, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/examples/live/grammar/src/tree_sitter/alloc.h b/examples/live/grammar/src/tree_sitter/alloc.h new file mode 100644 index 0000000..1abdd12 --- /dev/null +++ b/examples/live/grammar/src/tree_sitter/alloc.h @@ -0,0 +1,54 @@ +#ifndef TREE_SITTER_ALLOC_H_ +#define TREE_SITTER_ALLOC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> + +// Allow clients to override allocation functions +#ifdef TREE_SITTER_REUSE_ALLOCATOR + +extern void *(*ts_current_malloc)(size_t size); +extern void *(*ts_current_calloc)(size_t count, size_t size); +extern void *(*ts_current_realloc)(void *ptr, size_t size); +extern void (*ts_current_free)(void *ptr); + +#ifndef ts_malloc +#define ts_malloc ts_current_malloc +#endif +#ifndef ts_calloc +#define ts_calloc ts_current_calloc +#endif +#ifndef ts_realloc +#define ts_realloc ts_current_realloc +#endif +#ifndef ts_free +#define ts_free ts_current_free +#endif + +#else + +#ifndef ts_malloc +#define ts_malloc malloc +#endif +#ifndef ts_calloc +#define ts_calloc calloc +#endif +#ifndef ts_realloc +#define ts_realloc realloc +#endif +#ifndef ts_free +#define ts_free free +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ALLOC_H_ diff --git a/examples/live/grammar/src/tree_sitter/array.h b/examples/live/grammar/src/tree_sitter/array.h new file mode 100644 index 0000000..56fc8cd --- /dev/null +++ b/examples/live/grammar/src/tree_sitter/array.h @@ -0,0 +1,330 @@ +#ifndef TREE_SITTER_ARRAY_H_ +#define TREE_SITTER_ARRAY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "./alloc.h" + +#include <assert.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4101) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + +#define Array(T) \ + struct { \ + T *contents; \ + uint32_t size; \ + uint32_t capacity; \ + } + +/// Initialize an array. +#define array_init(self) \ + ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) + +/// Create an empty array. +#define array_new() \ + { NULL, 0, 0 } + +/// Get a pointer to the element at a given `index` in the array. +#define array_get(self, _index) \ + (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index]) + +/// Get a pointer to the first element in the array. +#define array_front(self) array_get(self, 0) + +/// Get a pointer to the last element in the array. +#define array_back(self) array_get(self, (self)->size - 1) + +/// Clear the array, setting its size to zero. Note that this does not free any +/// memory allocated for the array's contents. +#define array_clear(self) ((self)->size = 0) + +/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is +/// less than the array's current capacity, this function has no effect. +#define array_reserve(self, new_capacity) \ + ((self)->contents = _array__reserve( \ + (void *)(self)->contents, &(self)->capacity, \ + array_elem_size(self), new_capacity) \ + ) + +/// Free any memory allocated for this array. Note that this does not free any +/// memory allocated for the array's contents. +#define array_delete(self) \ + do { \ + if ((self)->contents) ts_free((self)->contents); \ + (self)->contents = NULL; \ + (self)->size = 0; \ + (self)->capacity = 0; \ + } while (0) + +/// Push a new `element` onto the end of the array. +#define array_push(self, element) \ + do { \ + (self)->contents = _array__grow( \ + (void *)(self)->contents, (self)->size, &(self)->capacity, \ + 1, array_elem_size(self) \ + ); \ + (self)->contents[(self)->size++] = (element); \ + } while(0) + +/// Increase the array's size by `count` elements. +/// New elements are zero-initialized. +#define array_grow_by(self, count) \ + do { \ + if ((count) == 0) break; \ + (self)->contents = _array__grow( \ + (self)->contents, (self)->size, &(self)->capacity, \ + count, array_elem_size(self) \ + ); \ + memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \ + (self)->size += (count); \ + } while (0) + +/// Append all elements from one array to the end of another. +#define array_push_all(self, other) \ + array_extend((self), (other)->size, (other)->contents) + +/// Append `count` elements to the end of the array, reading their values from the +/// `contents` pointer. +#define array_extend(self, count, other_contents) \ + (self)->contents = _array__splice( \ + (void*)(self)->contents, &(self)->size, &(self)->capacity, \ + array_elem_size(self), (self)->size, 0, count, other_contents \ + ) + +/// Remove `old_count` elements from the array starting at the given `index`. At +/// the same index, insert `new_count` new elements, reading their values from the +/// `new_contents` pointer. +#define array_splice(self, _index, old_count, new_count, new_contents) \ + (self)->contents = _array__splice( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + array_elem_size(self), _index, old_count, new_count, new_contents \ + ) + +/// Insert one `element` into the array at the given `index`. +#define array_insert(self, _index, element) \ + (self)->contents = _array__splice( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + array_elem_size(self), _index, 0, 1, &(element) \ + ) + +/// Remove one element from the array at the given `index`. +#define array_erase(self, _index) \ + _array__erase((void *)(self)->contents, &(self)->size, array_elem_size(self), _index) + +/// Pop the last element off the array, returning the element by value. +#define array_pop(self) ((self)->contents[--(self)->size]) + +/// Assign the contents of one array to another, reallocating if necessary. +#define array_assign(self, other) \ + (self)->contents = _array__assign( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + (const void *)(other)->contents, (other)->size, array_elem_size(self) \ + ) + +/// Swap one array with another +#define array_swap(self, other) \ + do { \ + void *_array_swap_tmp = (void *)(self)->contents; \ + (self)->contents = (other)->contents; \ + (other)->contents = _array_swap_tmp; \ + _array__swap(&(self)->size, &(self)->capacity, \ + &(other)->size, &(other)->capacity); \ + } while (0) + +/// Get the size of the array contents +#define array_elem_size(self) (sizeof *(self)->contents) + +/// Search a sorted array for a given `needle` value, using the given `compare` +/// callback to determine the order. +/// +/// If an existing element is found to be equal to `needle`, then the `index` +/// out-parameter is set to the existing value's index, and the `exists` +/// out-parameter is set to true. Otherwise, `index` is set to an index where +/// `needle` should be inserted in order to preserve the sorting, and `exists` +/// is set to false. +#define array_search_sorted_with(self, compare, needle, _index, _exists) \ + _array__search_sorted(self, 0, compare, , needle, _index, _exists) + +/// Search a sorted array for a given `needle` value, using integer comparisons +/// of a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_with`. +#define array_search_sorted_by(self, field, needle, _index, _exists) \ + _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists) + +/// Insert a given `value` into a sorted array, using the given `compare` +/// callback to determine the order. +#define array_insert_sorted_with(self, compare, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +/// Insert a given `value` into a sorted array, using integer comparisons of +/// a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_by`. +#define array_insert_sorted_by(self, field, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_by(self, field, (value) field, &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +// Private + +// Pointers to individual `Array` fields (rather than the entire `Array` itself) +// are passed to the various `_array__*` functions below to address strict aliasing +// violations that arises when the _entire_ `Array` struct is passed as `Array(void)*`. +// +// The `Array` type itself was not altered as a solution in order to avoid breakage +// with existing consumers (in particular, parsers with external scanners). + +/// This is not what you're looking for, see `array_erase`. +static inline void _array__erase(void* self_contents, uint32_t *size, + size_t element_size, uint32_t index) { + assert(index < *size); + char *contents = (char *)self_contents; + memmove(contents + index * element_size, contents + (index + 1) * element_size, + (*size - index - 1) * element_size); + (*size)--; +} + +/// This is not what you're looking for, see `array_reserve`. +static inline void *_array__reserve(void *contents, uint32_t *capacity, + size_t element_size, uint32_t new_capacity) { + void *new_contents = contents; + if (new_capacity > *capacity) { + if (contents) { + new_contents = ts_realloc(contents, new_capacity * element_size); + } else { + new_contents = ts_malloc(new_capacity * element_size); + } + *capacity = new_capacity; + } + return new_contents; +} + +/// This is not what you're looking for, see `array_assign`. +static inline void *_array__assign(void* self_contents, uint32_t *self_size, uint32_t *self_capacity, + const void *other_contents, uint32_t other_size, size_t element_size) { + void *new_contents = _array__reserve(self_contents, self_capacity, element_size, other_size); + *self_size = other_size; + memcpy(new_contents, other_contents, *self_size * element_size); + return new_contents; +} + +/// This is not what you're looking for, see `array_swap`. +static inline void _array__swap(uint32_t *self_size, uint32_t *self_capacity, + uint32_t *other_size, uint32_t *other_capacity) { + uint32_t tmp_size = *self_size; + uint32_t tmp_capacity = *self_capacity; + *self_size = *other_size; + *self_capacity = *other_capacity; + *other_size = tmp_size; + *other_capacity = tmp_capacity; +} + +/// This is not what you're looking for, see `array_push` or `array_grow_by`. +static inline void *_array__grow(void *contents, uint32_t size, uint32_t *capacity, + uint32_t count, size_t element_size) { + void *new_contents = contents; + uint32_t new_size = size + count; + if (new_size > *capacity) { + uint32_t new_capacity = *capacity * 2; + if (new_capacity < 8) new_capacity = 8; + if (new_capacity < new_size) new_capacity = new_size; + new_contents = _array__reserve(contents, capacity, element_size, new_capacity); + } + return new_contents; +} + +/// This is not what you're looking for, see `array_splice`. +static inline void *_array__splice(void *self_contents, uint32_t *size, uint32_t *capacity, + size_t element_size, + uint32_t index, uint32_t old_count, + uint32_t new_count, const void *elements) { + uint32_t new_size = *size + new_count - old_count; + uint32_t old_end = index + old_count; + uint32_t new_end = index + new_count; + assert(old_end <= *size); + + void *new_contents = _array__reserve(self_contents, capacity, element_size, new_size); + + char *contents = (char *)new_contents; + if (*size > old_end) { + memmove( + contents + new_end * element_size, + contents + old_end * element_size, + (*size - old_end) * element_size + ); + } + if (new_count > 0) { + if (elements) { + memcpy( + (contents + index * element_size), + elements, + new_count * element_size + ); + } else { + memset( + (contents + index * element_size), + 0, + new_count * element_size + ); + } + } + *size += new_count - old_count; + + return new_contents; +} + +/// A binary search routine, based on Rust's `std::slice::binary_search_by`. +/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`. +#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \ + do { \ + *(_index) = start; \ + *(_exists) = false; \ + uint32_t size = (self)->size - *(_index); \ + if (size == 0) break; \ + int comparison; \ + while (size > 1) { \ + uint32_t half_size = size / 2; \ + uint32_t mid_index = *(_index) + half_size; \ + comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \ + if (comparison <= 0) *(_index) = mid_index; \ + size -= half_size; \ + } \ + comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \ + if (comparison == 0) *(_exists) = true; \ + else if (comparison < 0) *(_index) += 1; \ + } while (0) + +/// Helper macro for the `_sorted_by` routines below. This takes the left (existing) +/// parameter by reference in order to work with the generic sorting function above. +#define _compare_int(a, b) ((int)*(a) - (int)(b)) + +#ifdef _MSC_VER +#pragma warning(pop) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ARRAY_H_ diff --git a/examples/live/grammar/src/tree_sitter/parser.h b/examples/live/grammar/src/tree_sitter/parser.h new file mode 100644 index 0000000..858107d --- /dev/null +++ b/examples/live/grammar/src/tree_sitter/parser.h @@ -0,0 +1,286 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +typedef struct TSLanguageMetadata { + uint8_t major_version; + uint8_t minor_version; + uint8_t patch_version; +} TSLanguageMetadata; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +// Used to index the field and supertype maps. +typedef struct { + uint16_t index; + uint16_t length; +} TSMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); + void (*log)(const TSLexer *, const char *, ...); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; + uint16_t reserved_word_set_id; +} TSLexerMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t abi_version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexerMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; + const char *name; + const TSSymbol *reserved_words; + uint16_t max_reserved_word_set_size; + uint32_t supertype_count; + const TSSymbol *supertype_symbols; + const TSMapSlice *supertype_map_slices; + const TSSymbol *supertype_map_entries; + TSLanguageMetadata metadata; +}; + +static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + const TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + const TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ diff --git a/examples/live/queries/highlights.scm b/examples/live/queries/highlights.scm new file mode 100644 index 0000000..f02ec48 --- /dev/null +++ b/examples/live/queries/highlights.scm @@ -0,0 +1,6 @@ +; The language's colours, in pardes's four classes (its themes' inks): +; the name a line defines, a builtin called, numbers, comments. +(definition name: (name) @keyword) +(call function: (name) @string) +(number) @number +(comment) @comment diff --git a/examples/live/queries/indents.scm b/examples/live/queries/indents.scm new file mode 100644 index 0000000..9ddd784 --- /dev/null +++ b/examples/live/queries/indents.scm @@ -0,0 +1,5 @@ +; A new line's indent (helix's indent queries): a level inside a call or +; parentheses left open, none else, so a line ending in `)` does not push +; the next one in. +[(call) (parenthesized)] @indent +")" @outdent diff --git a/examples/live/shaders/fullscreen.vert b/examples/live/shaders/fullscreen.vert new file mode 100644 index 0000000..f45ee09 --- /dev/null +++ b/examples/live/shaders/fullscreen.vert @@ -0,0 +1,6 @@ +#version 450 +// One triangle covering the target. +void main() { + vec2 p = vec2(float((gl_VertexIndex << 1) & 2), float(gl_VertexIndex & 2)); + gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0); +} diff --git a/examples/live/shaders/picture.frag b/examples/live/shaders/picture.frag new file mode 100644 index 0000000..4621b31 --- /dev/null +++ b/examples/live/shaders/picture.frag @@ -0,0 +1,14 @@ +#version 450 +#extension GL_GOOGLE_include_directive : require +// The color tape at every pixel; x and y in half the target's height, 0 at +// its centre, y up: a circle is round on any window. +#include "Picture.glsl" +#define TAPE(i) u.tape[i] +#include "vm.glsl" + +layout(location = 0) out vec4 out_color; + +void main() { + vec2 p = vec2(gl_FragCoord.x - 0.5 * u.size.x, 0.5 * u.size.y - gl_FragCoord.y) / (0.5 * u.size.y); + out_color = vec4(clamp(vm(0u, u.len, u.time, p.x, p.y), 0.0, 1.0), 1.0); +} diff --git a/examples/live/shaders/synth.comp b/examples/live/shaders/synth.comp new file mode 100644 index 0000000..0e7ab02 --- /dev/null +++ b/examples/live/shaders/synth.comp @@ -0,0 +1,28 @@ +#version 450 +#extension GL_GOOGLE_include_directive : require +// One audio block, one thread per sample: the out tape at each sample's +// time, crossing over the first `fade` samples from the tape it replaces +// (at its own time, which differs after a seek), so an edit or a seek +// does not click. x and y are 0. +layout(local_size_x = 64) in; + +#include "Synth.glsl" +// The new tape, then the old one. +layout(set = 0, binding = 0) readonly buffer Tapes { uvec4 tape[]; }; +#define TAPE(i) tape[i] +#include "vm.glsl" + +layout(set = 1, binding = 0) buffer Block { float block[]; }; + +// A sample the device can take: no NaN or infinity, -1..1. +float heard(float v) { + return isnan(v) || isinf(v) ? 0.0 : clamp(v, -1.0, 1.0); +} + +void main() { + uint n = gl_GlobalInvocationID.x; + if (n >= u.count) return; + float v = heard(vm(0u, u.len, u.start + float(n) / u.rate, 0.0, 0.0).x); + if (n < u.fade) v = mix(heard(vm(MAX_TAPE, u.old_len, u.old_start + float(n) / u.rate, 0.0, 0.0).x), v, (float(n) + 0.5) / float(u.fade)); + block[n] = v; +} diff --git a/examples/live/shaders/vm.glsl b/examples/live/shaders/vm.glsl new file mode 100644 index 0000000..06319ec --- /dev/null +++ b/examples/live/shaders/vm.glsl @@ -0,0 +1,93 @@ +// The interpreter of Lang.zig's tapes, included by picture.frag (a pixel) +// and synth.comp (a sample), which define TAPE(i), instruction i as a uvec4 +// (op, a, b, c). Instruction i writes register r[i] from earlier registers +// a, b and c; a constant's a is its value's bits, seq's b and c a first +// register and a count. Every thread runs the same instructions, so the +// switch never diverges. The registers are a local array (in the GPU's +// local memory): an array of 16 kept in registers measured twice as slow, +// its indexing turned into selects (the probe, in the package's README). +#include "ops.glsl" + +const uint MAX_TAPE = 128u; + +// An integer hash (no tables), to -1..1. +float lattice(vec3 p) { + uvec3 q = uvec3(ivec3(p)); + uint h = (q.x * 0x8da6b343u) ^ (q.y * 0xd8163841u) ^ (q.z * 0xcb1ab31fu); + h ^= h >> 16; + h *= 0x7feb352du; + h ^= h >> 15; + h *= 0x846ca68bu; + h ^= h >> 16; + return float(h) * (2.0 / 4294967295.0) - 1.0; +} + +// Value noise, smooth, -1..1. +float noise(vec3 p) { + vec3 i = floor(p); + vec3 f = p - i; + vec3 w = f * f * f * (f * (f * 6.0 - 15.0) + 10.0); + return mix( + mix(mix(lattice(i), lattice(i + vec3(1, 0, 0)), w.x), mix(lattice(i + vec3(0, 1, 0)), lattice(i + vec3(1, 1, 0)), w.x), w.y), + mix(mix(lattice(i + vec3(0, 0, 1)), lattice(i + vec3(1, 0, 1)), w.x), mix(lattice(i + vec3(0, 1, 1)), lattice(i + vec3(1, 1, 1)), w.x), w.y), + w.z); +} + +vec3 hsv(float h, float s, float v) { + vec3 k = clamp(abs(fract(h + vec3(1.0, 2.0 / 3.0, 1.0 / 3.0)) * 6.0 - 3.0) - 1.0, 0.0, 1.0); + return v * mix(vec3(1.0), k, s); +} + +// The tape at TAPE(base) .. TAPE(base + len - 1) at one point: a colour if +// it ends in one, else its last register, grey. +vec3 vm(uint base, uint len, float t, float x, float y) { + float r[MAX_TAPE]; + vec3 color = vec3(0.0); + for (uint i = 0u; i < len; i++) { + uvec4 k = TAPE(base + i); + float a = r[k.y & 127u]; + float b = r[k.z & 127u]; + float c = r[k.w & 127u]; + float v = 0.0; + switch (k.x) { + case OP_constant: v = uintBitsToFloat(k.y); break; + case OP_t: v = t; break; + case OP_x: v = x; break; + case OP_y: v = y; break; + case OP_add: v = a + b; break; + case OP_sub: v = a - b; break; + case OP_mul: v = a * b; break; + case OP_div: v = a / b; break; + case OP_neg: v = -a; break; + case OP_copy: v = a; break; + case OP_seq: v = r[(k.z + uint(mod(floor(a), float(k.w)))) & 127u]; break; + case OP_sin: v = sin(a); break; + case OP_cos: v = cos(a); break; + case OP_exp: v = exp(a); break; + case OP_log: v = log(a); break; + case OP_pow: v = pow(a, b); break; + case OP_sqrt: v = sqrt(a); break; + case OP_abs: v = abs(a); break; + case OP_floor: v = floor(a); break; + case OP_fract: v = fract(a); break; + case OP_min: v = min(a, b); break; + case OP_max: v = max(a, b); break; + case OP_clamp: v = clamp(a, b, c); break; + case OP_mix: v = mix(a, b, c); break; + case OP_step: v = step(a, b); break; + // GLSL leaves smoothstep undefined for lo > hi; this one is not. + case OP_smoothstep: v = clamp((c - a) / (b - a), 0.0, 1.0); v = v * v * (3.0 - 2.0 * v); break; + case OP_atan2: v = atan(a, b); break; + case OP_noise: v = noise(vec3(a, b, c)); break; + case OP_saw: v = 2.0 * fract(a + 0.5) - 1.0; break; + case OP_sqr: v = fract(a) < 0.5 ? 1.0 : -1.0; break; + case OP_tri: v = 4.0 * abs(fract(a - 0.25) - 0.5) - 1.0; break; + case OP_hsv: color = hsv(a, b, c); break; + case OP_rgb: color = vec3(a, b, c); break; + } + r[i] = v; + } + if (len == 0u) return vec3(0.0); + uint last = TAPE(base + len - 1u).x; + return last == OP_hsv || last == OP_rgb ? color : vec3(r[len - 1u]); +} diff --git a/examples/live/src/Lang.zig b/examples/live/src/Lang.zig new file mode 100644 index 0000000..4ce504e --- /dev/null +++ b/examples/live/src/Lang.zig @@ -0,0 +1,754 @@ +//! The language: lines of `name = expression` over `t`, `x` and `y`, +//! 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. +//! +//! 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) { + /// `a` is the value's bits. + constant, + t, + x, + y, + neg, + sin, + cos, + exp, + log, + sqrt, + abs, + floor, + fract, + saw, + sqr, + tri, + /// 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 the values. + seq, + add, + sub, + mul, + div, + pow, + min, + max, + step, + atan2, + clamp, + mix, + smoothstep, + noise, + /// A colour, only as the color tape's last instruction. + hsv, + 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 = "across, in half the window's height: 0 at the centre, -1.78 to 1.78 on 16:9; 0 in sound" }, + .{ .call = "y", .op = .y, .doc = "up, in half the window's height: -1 at the bottom, 0 at the centre, 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, + b: u32 = 0, + c: u32 = 0, +}; + +pub const Tape = struct { + len: u32 = 0, + code: Code = @splat(.{}), + + pub const Code = [max_tape]Instruction; + + 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)]; + } +}; + +/// `probe` is what is heard and seen instead of the program while a +/// selection is on an expression (main.zig): empty when none is asked for, +/// none holds it, or it is longer than a tape. +pub const Program = struct { out: Tape = .{}, color: Tape = .{}, probe: Tape = .{} }; + +pub const Result = union(enum) { program: Program, problem: Problem }; + +/// `probe`: bytes from..to of the text, a selection; the smallest +/// expression holding them is compiled as `Program.probe`. +pub fn compile(text: []const u8, probe: ?[2]u32) Result { + var c: Compiler = .{ .text = text, .probe = probe }; + var program: Program = .{}; + c.lines() catch return .{ .problem = c.problem }; + for ([_]struct { *Tape, []const u8 }{ .{ &program.out, "out" }, .{ &program.color, "color" } }) |line| { + const name = c.lookup(line[1]) orelse continue; + var registers: [max_terms]u16 = @splat(none); + _ = c.emit(line[0], name.term, ®isters) catch + return .{ .problem = (c.fail(name.at, "the {s} line needs more than {d} instructions", .{ line[1], max_tape }) catch c.problem) }; + } + if (c.heard != none) { + var registers: [max_terms]u16 = @splat(none); + _ = c.emit(&program.probe, c.heard, ®isters) catch { + program.probe = .{}; + }; + } + 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 = .{}, + /// The bytes probed, and the smallest expression found holding them. + probe: ?[2]u32 = null, + heard: u16 = none, + heard_len: u32 = std.math.maxInt(u32), + + /// The expression from byte `from` to where the parse is, its term `t`: + /// the probe's, if it is the smallest yet that holds the probed bytes. + fn spanned(c: *Compiler, from: u32, t: u16) u16 { + const p = c.probe orelse return t; + if (from <= p[0] and p[1] <= c.pos and c.pos - from < c.heard_len) { + c.heard = t; + c.heard_len = c.pos - from; + } + return t; + } + + 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 = c.spanned(first.at, 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 { + const from = c.peek().at; + try c.enter(from); + 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 = c.spanned(from, try c.call(op, tok.at, &.{ left, try c.product() })); + } + } + + fn product(c: *Compiler) !u16 { + const from = c.peek().at; + 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 = c.spanned(from, 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 c.spanned(tok.at, a); + } + return c.spanned(tok.at, try 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.spanned(tok.at, try c.term(.{ .op = .constant, .value = value, .at = tok.at })); + }, + .name => { + const name = c.span(tok); + if (c.peek().is('(')) return c.spanned(tok.at, try 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 c.spanned(tok.at, 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.spanned(tok.at, try 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.spanned(tok.at, 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 c.spanned(tok.at, 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; + } + + 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). +pub const Picture = extern struct { + tape: [max_tape][4]u32, + len: u32, + /// Seconds. + time: f32, + /// The target, pixels. + size: [2]f32, + + pub const glsl = .{ .uniform = .{ .set = 3, .instance = "u" } }; +}; + +/// synth.comp's uniforms (SDL_GPU's compute set). Its tapes, the new one +/// and the one it replaces, which the first `fade` samples cross from, are +/// a storage buffer: SDL_GPU's Vulkan backend binds a uniform block 4 KiB +/// at a time, and two tapes are 4 KiB alone. +pub const Synth = extern struct { + len: u32, + old_len: u32, + /// Samples in the block. + count: u32, + fade: u32, + /// The block's first sample, seconds; the old tape's, which differs + /// after a jump (a seek: the old tape where the device was). + start: f32, + old_start: f32, + rate: f32, + pad: f32 = 0, + + pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } }; +}; + +// --------------------------------------------------------------------------- +// Tests. + +const testing = std.testing; + +fn compiled(text: []const u8) !Program { + return switch (compile(text, null)) { + .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); main.zig's test of the +/// grammar parses it too. +pub 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, null)) { + .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(), null)) { + .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, null)) { + .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(), null)) { + .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(), null)) { + .program => return error.TestUnexpectedResult, + .problem => |p| try testing.expectEqualStrings("nested more than 32 deep", p.text()), + } +} + +test "a probe: the smallest expression holding the bytes, its own tape" { + const text = "kick = exp(-7 * fract(t * 2))\nout = sin(tau * 220 * t) * kick"; + for ([_]struct { [2]u32, []const Op }{ + // `tau * 220 * t`, a selection Alt-o grew to + .{ .{ 40, 53 }, &.{ .constant, .constant, .mul, .t, .mul } }, + // `220` alone, and a cursor on its `2` + .{ .{ 46, 49 }, &.{.constant} }, + .{ .{ 46, 47 }, &.{.constant} }, + // `kick` where it is used: the line that defines it + .{ .{ 57, 61 }, &.{ .constant, .t, .constant, .mul, .fract, .mul, .exp } }, + // an argument + .{ .{ 22, 27 }, &.{ .t, .constant, .mul } }, + // the out line from its name, and the whole of it + .{ .{ 30, 33 }, &.{ .constant, .constant, .mul, .t, .mul, .sin, .constant, .constant, .mul, .fract, .mul, .exp, .mul } }, + }) |case| { + const p = try switch (compile(text, case[0])) { + .program => |p| p, + .problem => error.TestUnexpectedResult, + }; + expectOps(p.probe, case[1]) catch |e| { + std.debug.print("probe {any}\n", .{case[0]}); + return e; + }; + } + // nothing holds the newline between the lines: no probe + try testing.expectEqual(@as(u32, 0), compile(text, .{ 29, 30 }).program.probe.len); +} diff --git a/examples/live/src/main.zig b/examples/live/src/main.zig new file mode 100644 index 0000000..d7a514f --- /dev/null +++ b/examples/live/src/main.zig @@ -0,0 +1,458 @@ +//! live: a program typed over its own picture and heard. Each line is +//! `name = expression` over t, x and y (src/Lang.zig); the `out` line is +//! what is heard, the `color` line what is seen. At every keystroke that +//! leaves a program that parses, `update` compiles it into two tapes kept +//! in State, which one interpreter on the GPU (shaders/vm.glsl) runs per +//! pixel and per sample. While a line is broken the last good tapes keep +//! playing and the problem is marked at its byte. +//! +//! State is the text, the tapes, the problem and the time, all changed by +//! `update` from recorded keys and ticks, so a replay or a seek brings back +//! the text, the tape and the picture of that moment. The sound runs on a +//! sample clock in Session, set from State's time at every jump (a seek, +//! a replay's start) and free-running otherwise, so a paused replay keeps +//! sounding its moment. Session holds it, the GPU objects and the scope. +const std = @import("std"); +const sk = @import("sketch"); +const gpu = sk.abi.gpu; +const Lang = @import("Lang"); +const shaders = @import("shaders"); +const scope = @import("scope"); +const pe = @import("pardes-editor"); + +pub const name = "live"; +pub const width = 1280; +pub const height = 720; +/// A change is heard about 6.5 ms after `draw`, not 19-27 (README, sound). +pub const audio_pull = 256; +pub const commands = .{"capture"}; + +/// The sound's stream, and its readback's key. +const stream = 1; +/// The most samples synthesised in one frame. +const max_block = 8192; + +/// The text: pardes's editor, helix's keys over a value of plain data +/// (src/lib_editor.zig in pardes), its capacities sized to the language's +/// 4 KiB of text. The undo ring keeps whole texts, the oldest dropped: four +/// at the most text, hundreds of a short program. 39,264 bytes in all, of a +/// State of 43,480. +pub const Editor = pe.Editor(.{ .text = 4096, .undo = 16 * 1024, .registers = 1024, .selections = 64 }); + +pub const State = struct { + ed: Editor = .{}, + /// The last program that parsed. + out: Lang.Tape = .{}, + color: Lang.Tape = .{}, + /// Hear this: after a node walk (Alt-o, Alt-i, Alt-n, Alt-p), the + /// expression the primary range is on, heard and seen (grey) instead of + /// out and color until the next key; empty otherwise. + probe: Lang.Tape = .{}, + /// A number the pointer was pressed on and drags. + drag: Drag = .{}, + /// What is wrong with the text, if it does not parse (`len` 0: nothing). + problem: Lang.Problem = .{}, + /// Seconds, from recorded ticks: a replay draws the same frames. + time: f32 = 0, + /// A new out tape crosses from the old one over a block; `set + /// crossfade false` hears (and measures) the click it saves. + crossfade: bool = true, +}; + +/// Drag a number: its literal's bytes, at..at + len, rewritten as the +/// pointer moves, a step for every 4 pixels to the right (left, down) from +/// where it was pressed: its own precision, `220` by ones, `0.25` by +/// hundredths. The drag is one step to undo. +pub const Drag = struct { + active: bool = false, + /// Rewritten once: the next frames join its step to undo. + moved: bool = false, + at: u32 = 0, + len: u32 = 0, + x: f32 = 0, + value: f64 = 0, + decimals: u8 = 0, +}; + +pub const Session = struct { + picture: sk.Image = .none, + size: [2]u32 = .{ 0, 0 }, + block: sk.Buffer = .none, + /// The out tape and the one it replaces, for synth.comp. + tapes: sk.Buffer = .none, + /// Seconds: where the next block starts. + clock: f64 = 0, + /// The tape the last block played. + heard: Lang.Tape = .{}, + scope: scope.Scope = .{}, + /// `capture` appends what is heard to `<stem>.capture.f32`. + capturing: bool = false, +}; + +/// `capture` starts or stops appending what is heard to the sketch's file +/// `capture.f32` (mono f32 at the device's rate, beside its save). +pub fn command(ss: *Session, c: *sk.Console, line: []const u8) !bool { + if (!std.mem.eql(u8, std.mem.trim(u8, line, " \t"), "capture")) return false; + ss.capturing = !ss.capturing; + c.log(if (ss.capturing) "capturing what is heard to capture.f32" else "capture stopped"); + return true; +} + +/// What the editor thaws its value into for each call, reset after it: +/// `update` may not allocate from the host, and a fixed buffer keeps a +/// call deterministic and bounded. A key at the most text took 29 KiB of it. +var scratch: [128 * 1024]u8 = undefined; + +/// The language's grammar (grammar/, its parser.c compiled in by build.zig), +/// handed to the editor at run time. +pub extern fn tree_sitter_live() *const pe.syntax.ts.Language; +pub fn language() pe.Language { + return .{ .name = "live", .ext = ".live", .ts = tree_sitter_live(), .highlights = @embedFile("highlights.scm"), .indents = @embedFile("indents.scm") }; +} + +/// The text's parse, for the editor's node walks (Alt-o, Alt-i, ...): +/// derived, so not in State, and kept between calls, as Alt-i goes back the +/// way Alt-o came only through its history; forgotten at a jump (`draw`). +/// A reload starts it again, with the code its grammar is in. +// ponytail: the tree a reload leaves behind is leaked (tree-sitter's +// malloc, a few KiB a reload). +var syn: pe.Syntax = .{}; + +pub fn update(s: *State, in: *const sk.Input) void { + const revision = s.ed.revision; + syn.lang = language(); + // a chord's key_down may come with its letter as text too: not typed + var chord = false; + for (in.events) |e| { + var fba: std.heap.FixedBufferAllocator = .init(&scratch); + var utf8: [4]u8 = undefined; + const k: pe.Key = switch (e.kind) { + .tick => { + s.time += e.x; + continue; + }, + .mouse_down => { + // the number token under the pointer, by the grammar's parse + if (e.code != 1 or e.x < margin or e.y < margin) continue; + var text: [Editor.capacity.text]u8 = undefined; + const t = s.ed.read(&text); + const row: usize = @intFromFloat((e.y - margin) / cell[1]); + const col: usize = @intFromFloat((e.x - margin) / cell[0]); + var start: usize = 0; + for (0..row) |_| start = (std.mem.indexOfScalarPos(u8, t, start, '\n') orelse t.len) + 1; + if (start > t.len) continue; + const end = std.mem.indexOfScalarPos(u8, t, start, '\n') orelse t.len; + if (start + col >= end) continue; + const tree = syn.parse(fba.allocator(), &s.ed, language()) orelse continue; + const n = tree.rootNode().descendantForByteRange(@intCast(start + col), @intCast(start + col + 1)) orelse continue; + if (!std.mem.eql(u8, n.kind(), "number")) continue; + const literal = t[n.startByte()..n.endByte()]; + // ponytail: a number with an exponent is not dragged + if (std.mem.indexOfScalar(u8, literal, 'e') != null) continue; + const point = std.mem.indexOfScalar(u8, literal, '.'); + s.drag = .{ + .active = true, + .at = n.startByte(), + .len = @intCast(literal.len), + .x = e.x, + .value = std.fmt.parseFloat(f64, literal) catch continue, + .decimals = @intCast(if (point) |p| literal.len - p - 1 else 0), + }; + continue; + }, + .mouse_move => { + if (!s.drag.active) continue; + const d = &s.drag; + const steps = @round((e.x - d.x) / 4); + var buf: [32]u8 = undefined; + const num = std.fmt.bufPrint(&buf, "{[0]d:.[1]}", .{ d.value + steps * std.math.pow(f64, 10, -@as(f64, @floatFromInt(d.decimals))), d.decimals }) catch continue; + var text: [Editor.capacity.text]u8 = undefined; + if (std.mem.eql(u8, s.ed.read(&text)[d.at..][0..d.len], num)) continue; + if (s.ed.replace(fba.allocator(), d.at, d.at + d.len, num, d.moved) != .done) continue; + d.len = @intCast(num.len); + d.moved = true; + continue; + }, + .mouse_up, .cancel => { + s.drag.active = false; + continue; + }, + .text => text: { + const n = std.unicode.utf8Encode(@intCast(@min(e.value, 0x10ffff)), &utf8) catch continue; + if (chord) { + chord = false; + continue; + } + break :text .{ .cp = @intCast(@min(e.value, 0x10ffff)), .text = utf8[0..n] }; + }, + .key_down => chord: { + const k = key(e) orelse continue; + chord = (k.ctrl or k.alt) and k.cp >= ' ' and k.cp < 0x7f; + break :chord k; + }, + else => continue, + }; + // ponytail: a key the text has no room for is dropped, as part 1's + // buffer dropped it; the editor leaves the value as it was. + const outcome = s.ed.key(fba.allocator(), &syn, k); + s.probe = .{}; + if (k.alt and outcome == .done and (k.cp == 'o' or k.cp == 'i' or k.cp == 'n' or k.cp == 'p')) probe: { + fba.reset(); + const ranges = fba.allocator().create([pe.max_selections]pe.Selection) catch break :probe; + const got = s.ed.ranges(fba.allocator(), ranges) catch break :probe; + const r = ranges[got.primary]; + var text: [Editor.capacity.text]u8 = undefined; + switch (Lang.compile(s.ed.read(&text), .{ @intCast(@min(r.anchor, r.head)), @intCast(@max(r.anchor, r.head)) })) { + .program => |p| s.probe = p.probe, + .problem => {}, + } + } + } + if (s.ed.revision == revision) return; + var text: [Editor.capacity.text]u8 = undefined; + switch (Lang.compile(s.ed.read(&text), null)) { + .program => |p| { + s.out = p.out; + s.color = p.color; + s.problem = .{}; + }, + .problem => |p| s.problem = p, + } +} + +/// A key_down as the editor takes it: the specials, and chords (ctrl or alt +/// with a letter, digit or sign), helix's `A-I` an upper-case letter with +/// alt. A printable without a chord comes as `text`, so it is not one here. +fn key(e: sk.Event) ?pe.Key { + const mods = e.value; + const ctrl = mods & sk.Key.Mod.ctrl != 0; + const alt = mods & sk.Key.Mod.alt != 0; + const shift = mods & sk.Key.Mod.shift != 0; + const special: u21 = switch (e.key()) { + .escape => pe.Key.escape, + .@"return", .keypad_enter, .return2 => pe.Key.enter, + .backspace => pe.Key.backspace, + .tab => pe.Key.tab, + .delete => pe.Key.delete, + .left => pe.Key.left, + .right => pe.Key.right, + .up => pe.Key.up, + .down => pe.Key.down, + .home => pe.Key.home, + .end => pe.Key.end, + .page_up => pe.Key.page_up, + .page_down => pe.Key.page_down, + else => 0, + }; + if (special != 0) return .{ .cp = special, .ctrl = ctrl, .alt = alt, .shift = shift }; + if (!ctrl and !alt) return null; + const scan = @backingInt(e.key()); + const cp: u21 = switch (e.key()) { + .a, .b, .c, .d, .e, .f, .g, .h, .i, .j, .k, .l, .m, .n, .o, .p, .q, .r, .s, .t, .u, .v, .w, .x, .y, .z => @as(u21, if (shift) 'A' else 'a') + scan - @backingInt(sk.Key.a), + .@"1", .@"2", .@"3", .@"4", .@"5", .@"6", .@"7", .@"8", .@"9" => '1' + @as(u21, scan - @backingInt(sk.Key.@"1")), + .@"0" => '0', + .space => ' ', + .minus => '-', + .equals => '=', + .left_bracket => '[', + .right_bracket => ']', + .semicolon => ';', + .comma => ',', + .period => '.', + .slash => '/', + else => return null, + }; + return .{ .cp = cp, .ctrl = ctrl, .alt = alt }; +} + +const synth: gpu.Kernel = .{ .code = shaders.synth_comp, .readonly_buffers = 1, .readwrite_buffers = 1, .uniform_buffers = 1 }; +const picture_pipeline: gpu.Pipeline = .{ + .vertex = .{ .code = shaders.fullscreen_vert }, + .fragment = .{ .code = shaders.picture_frag, .uniform_buffers = 1 }, + .stride = 0, + .attributes = &.{}, + .blend = .none, +}; + +pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void { + if (f.in.jumped) syn.forget(); + f.clear(0x000000); + if (!f.host.gpu()) { + f.text(16, 16, 2, "live needs a GPU: the host has none.", 0xff8080); + return; + } + // A tape past 64 instructions is drawn at half resolution: at 1280x720 + // 128 instructions took 2.7 ms of the GPU, at half 0.85 (the probe). + const seen = if (s.probe.len > 0) &s.probe else &s.color; + const half: u32 = if (seen.len > 64) 2 else 1; + const size: [2]u32 = .{ width / half, height / half }; + if (!std.meta.eql(ss.size, size)) { + if (ss.picture != .none) f.host.freeImage(ss.picture); + ss.picture = f.host.newImage(size[0], size[1]); + ss.size = size; + } + f.gpu(.{ + .label = "picture", + .image = ss.picture, + .width = size[0], + .height = size[1], + .pipelines = &.{picture_pipeline}, + .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, Lang.Picture{ + .tape = std.mem.bytesToValue([Lang.max_tape][4]u32, &seen.code), + .len = seen.len, + .time = s.time, + .size = .{ @floatFromInt(size[0]), @floatFromInt(size[1]) }, + }) }}, + }); + f.image(ss.picture, .{ .x = 0, .y = 0, .w = width, .h = height }, .{}); + sound(s, ss, f); + code(s, f); +} + +/// The out tape over the sample clock, as much as keeps the host's lead +/// queued, streamed from the GPU's block; and read back for the scope. +fn sound(s: *const State, ss: *Session, f: *sk.Frame) void { + const in = f.in; + for (in.downloads) |d| if (d.key == stream) { + const samples = f.scratch.alloc(f32, d.bytes.len / 4) catch continue; + @memcpy(std.mem.sliceAsBytes(samples), d.bytes[0 .. samples.len * 4]); + ss.scope.push(samples); + if (ss.capturing) _ = f.host.appendFile("capture.f32", d.bytes); + }; + if (ss.block == .none) { + ss.block = f.host.newBuffer(max_block * @sizeOf(f32)); + ss.tapes = f.host.newBuffer(2 * @sizeOf(Lang.Tape.Code)); + } + // A jump is heard at once: what was queued from before it is dropped, + // and the block crosses from where the device was to the new time. + const rate: f64 = @floatFromInt(in.sample_rate); + var queued = in.stream(stream).queued; + const was = ss.clock - @as(f64, @floatFromInt(queued)) / rate; + if (in.jumped) { + ss.clock = s.time; + queued = 0; + f.audio(stream, &.{}, .{ .clear = true }); + } + const want: u32 = @min(in.lead -| queued, max_block); + if (want > 0) { + const heard = if (s.probe.len > 0) &s.probe else &s.out; + const new = std.mem.sliceAsBytes(heard.slice()); + const changed = in.jumped or !std.mem.eql(u8, new, std.mem.sliceAsBytes(ss.heard.slice())); + const tapes = f.scratch.create([2]Lang.Tape.Code) catch return; + tapes.* = .{ heard.code, ss.heard.code }; + f.upload(ss.tapes, 0, std.mem.asBytes(tapes)); + f.compute(.{ + .label = "synth", + .kernel = synth, + .readonly = &.{ss.tapes}, + .readwrite = &.{ss.block}, + .uniforms = gpu.uniform(f.scratch, Lang.Synth{ + .len = heard.len, + .old_len = ss.heard.len, + .count = want, + .fade = if (changed and s.crossfade) want else 0, + .start = @floatCast(ss.clock), + .old_start = @floatCast(if (in.jumped) was else ss.clock), + .rate = @floatCast(rate), + }), + .groups = .{ (want + 63) / 64, 1, 1 }, + }); + f.audioBuffer(stream, ss.block, .{ .count = want }); + f.download(ss.block, .{ .size = want * @sizeOf(f32), .key = stream }); + ss.clock += @as(f64, @floatFromInt(want)) / rate; + ss.heard = heard.*; + } + ss.scope.draw(f, .{ + .oscilloscope = .{ .rect = .{ .x = 16, .y = height - 104, .w = 480, .h = 88 }, .samples = 1024 }, + .spectrum = .{ .x = 512, .y = height - 104, .w = 480, .h = 88 }, + }); +} + +const scale = 1.25; +/// A character of the code face at `scale`, wide and high, in pixels: +/// measured (`f.host.textSizeIn(.code, 1.25, "M")` natively, and ten of +/// them are 100), so `update` finds the byte under the pointer as `code` +/// lays it out. +const cell: [2]f32 = .{ 10, 22 }; +const margin = 16; +const ink = 0xe8e8e8; +const red = 0xff5a50; +const selected: sk.Color = .{ .r = 0x3c, .g = 0x6e, .b = 0xc8, .a = 170 }; +const also_selected: sk.Color = .{ .r = 0x3c, .g = 0x6e, .b = 0xc8, .a = 90 }; +/// pardes's own theme: its text's ink and a class's. +const theme = &pe.syntax.themes[0]; + +/// The editor's text over the picture on a dark band: its lines coloured +/// by the grammar in pardes's theme, every +/// range (the primary stronger), a caret at each range's head that says +/// the mode (a block in normal and select, a bar in insert), the mode's +/// name in the corner; the problem as a red mark under its byte and its +/// words under the text. +// ponytail: one face at one size, a column a fixed advance and a byte of +// this ASCII language a column; sketchbook's paragraph call (spans, any +// byte's place) takes the place of the measuring and the textIn here. +fn code(s: *const State, f: *sk.Frame) void { + const text = s.ed.bytes(f.scratch) catch return; + const ranges = f.scratch.create([pe.max_selections]pe.Selection) catch return; + const got = s.ed.ranges(f.scratch, ranges) catch return; + // a class a byte, from the grammar's highlights (none if it fails) + const colors = pe.Syntax.colors(f.scratch, &s.ed, language(), 0, text.len) catch &.{}; + const problem = s.problem.len > 0; + var lines: usize = 1; + var widest: usize = 24; + var it = std.mem.splitScalar(u8, text, '\n'); + while (it.next()) |line| : (lines += 1) widest = @max(widest, line.len + 1); + if (problem) widest = @max(widest, s.problem.len); + f.fill(.{ .x = 0, .y = 0, .w = @as(f32, @floatFromInt(widest)) * cell[0] + 2 * margin, .h = @as(f32, @floatFromInt(lines - 1 + @intFromBool(problem))) * cell[1] + 2 * margin }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 }); + + var y: f32 = margin; + var start: usize = 0; + it = std.mem.splitScalar(u8, text, '\n'); + while (it.next()) |line| : (y += cell[1]) { + // a line's bytes and its newline, start..end + const end = start + line.len + 1; + for (ranges[0..got.n], 0..) |r, i| { + const from = @max(@min(r.anchor, r.head), start); + const to = @min(@max(r.anchor, r.head), end); + if (from < to) f.fill(.{ .x = margin + @as(f32, @floatFromInt(from - start)) * cell[0], .y = y, .w = @as(f32, @floatFromInt(to - from)) * cell[0], .h = cell[1] }, if (i == got.primary) selected else also_selected); + } + // a run of bytes of one class at a time, in the theme's inks + var a: usize = 0; + while (a < line.len) { + const class = if (start + a < colors.len) colors[start + a] else .none; + var b = a + 1; + while (b < line.len and (if (start + b < colors.len) colors[start + b] else .none) == class) b += 1; + const c = pe.syntax.synInk(theme, class) orelse pe.syntax.ink(theme); + f.textIn(.code, margin + @as(f32, @floatFromInt(a)) * cell[0], y, scale, line[a..b], sk.Color{ .r = c[0], .g = c[1], .b = c[2] }); + a = b; + } + for (ranges[0..got.n], 0..) |r, i| { + // the head's character: the one before it in a range that + // grows forward + const at = if (r.head > r.anchor) r.head - 1 else r.head; + if (at < start or at >= end) continue; + const x = margin + @as(f32, @floatFromInt(at - start)) * cell[0]; + const caret: sk.Color = .{ .r = 0xe8, .g = 0xe8, .b = 0xe8, .a = if (i == got.primary) 200 else 110 }; + if (s.ed.mode() == .insert) { + f.fill(.{ .x = x - 1, .y = y, .w = 2, .h = cell[1] }, caret); + } else f.fill(.{ .x = x, .y = y, .w = cell[0], .h = cell[1] }, caret.alpha(caret.a / 2)); + } + if (problem and s.problem.at >= start and s.problem.at < end) + f.fill(.{ .x = margin + @as(f32, @floatFromInt(s.problem.at - start)) * cell[0], .y = y + cell[1] - 2, .w = cell[0], .h = 2 }, red); + start = end; + } + if (problem) f.textIn(.code, margin, y, scale, s.problem.text(), red); + + const mode = switch (f.in.mode) { + .live => "live", + .recording => "recording", + .playing => "replay", + .paused => "paused", + }; + const lead = @as(f32, @floatFromInt(f.in.lead)) / @as(f32, @floatFromInt(f.in.sample_rate)) * 1000; + f.print(width - 300, 12, 1, ink, "{s} {s} {d:.1} s lead {d:.1} ms", .{ switch (s.ed.mode()) { + .normal => "NOR", + .insert => "INS", + .select => "SEL", + }, mode, s.time, lead }); +} diff --git a/examples/live/src/probe.zig b/examples/live/src/probe.zig new file mode 100644 index 0000000..4f816b2 --- /dev/null +++ b/examples/live/src/probe.zig @@ -0,0 +1,133 @@ +//! The probe: the interpreter alone over made-up tapes of 60 and 128 +//! instructions, each pass at 1280x720 and 1920x1080 (and 128 at half of +//! 1280x720, as the sketch draws a long tape), and the synth kernel over +//! blocks of 256 and 1024 samples. `zig build probe` plays +//! test/probe.script with `--profile-gpu`, which prints each label's time +//! at exit; the empty tape's is the cost of a pass doing nothing. +const std = @import("std"); +const sk = @import("sketch"); +const gpu = sk.abi.gpu; +const Lang = @import("Lang"); +const shaders = @import("shaders"); + +pub const name = "live-probe"; +pub const width = 640; +pub const height = 360; + +pub const Session = struct { + images: [3]sk.Image = .{ .none, .none, .none }, + block: sk.Buffer = .none, + tapes: sk.Buffer = .none, + time: f32 = 0, +}; + +const sizes = [3][2]u32{ .{ 1280, 720 }, .{ 1920, 1080 }, .{ 640, 360 } }; + +const Picture = struct { label: []const u8, len: u32, size: u2 }; +const pictures = [_]Picture{ + .{ .label = "picture 0 720p", .len = 0, .size = 0 }, + .{ .label = "picture 60 720p", .len = 60, .size = 0 }, + .{ .label = "picture 128 720p", .len = 128, .size = 0 }, + .{ .label = "picture 0 1080p", .len = 0, .size = 1 }, + .{ .label = "picture 60 1080p", .len = 60, .size = 1 }, + .{ .label = "picture 128 1080p", .len = 128, .size = 1 }, + .{ .label = "picture 128 360p", .len = 128, .size = 2 }, +}; + +const Block = struct { label: []const u8, len: u32, count: u32, fade: bool = false }; +const blocks = [_]Block{ + .{ .label = "synth 60 x256", .len = 60, .count = 256 }, + .{ .label = "synth 128 x256", .len = 128, .count = 256 }, + .{ .label = "synth 60 x1024", .len = 60, .count = 1024 }, + .{ .label = "synth 128 x1024", .len = 128, .count = 1024 }, + .{ .label = "synth 128 x1024 fading", .len = 128, .count = 1024, .fade = true }, +}; + +/// `len` instructions, every one reaching the last: x, y, t and a +/// constant, then a cycle of ops over the three before, a noise every +/// tenth, and hsv. +fn madeUp(comptime len: u32) [Lang.max_tape][4]u32 { + @setEvalBranchQuota(10_000); + var code: [Lang.max_tape][4]u32 = @splat(.{ 0, 0, 0, 0 }); + const cycle = [_]Lang.Op{ .mul, .add, .sin, .fract, .sub, .smoothstep, .abs, .mix, .cos }; + for (0..len) |i| { + const op: Lang.Op = switch (i) { + 0 => .x, + 1 => .y, + 2 => .t, + 3 => .constant, + 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] = .{ @backingInt(op), a, @intCast(i -| 2), @intCast(i -| 3) }; + } + return code; +} + +const tapes = .{ madeUp(0), madeUp(60), madeUp(128) }; + +fn tape(len: u32) [Lang.max_tape][4]u32 { + return switch (len) { + 0 => tapes[0], + 60 => tapes[1], + else => tapes[2], + }; +} + +const pipeline: gpu.Pipeline = .{ + .vertex = .{ .code = shaders.fullscreen_vert }, + .fragment = .{ .code = shaders.picture_frag, .uniform_buffers = 1 }, + .stride = 0, + .attributes = &.{}, + .blend = .none, +}; +const kernel: gpu.Kernel = .{ .code = shaders.synth_comp, .readonly_buffers = 1, .readwrite_buffers = 1, .uniform_buffers = 1 }; + +pub fn draw(ss: *Session, f: *sk.Frame) void { + f.clear(0x000000); + if (!f.host.gpu()) return f.text(8, 8, 2, "no GPU here", 0xffffff); + if (ss.block == .none) { + for (&ss.images, sizes) |*image, size| image.* = f.host.newImage(size[0], size[1]); + ss.block = f.host.newBuffer(1024 * @sizeOf(f32)); + ss.tapes = f.host.newBuffer(2 * Lang.max_tape * 16); + } + ss.time += @floatCast(@as(f64, @floatFromInt(f.in.dt)) / std.time.ns_per_s); + for (pictures) |p| { + const size = sizes[p.size]; + f.gpu(.{ + .label = p.label, + .image = ss.images[p.size], + .width = size[0], + .height = size[1], + .pipelines = &.{pipeline}, + .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, Lang.Picture{ + .tape = tape(p.len), + .len = p.len, + .time = ss.time, + .size = .{ @floatFromInt(size[0]), @floatFromInt(size[1]) }, + }) }}, + }); + } + for (blocks) |k| { + const both = f.scratch.create([2][Lang.max_tape][4]u32) catch return; + both.* = .{ tape(k.len), tape(k.len) }; + f.upload(ss.tapes, 0, std.mem.asBytes(both)); + f.compute(.{ + .label = k.label, + .kernel = kernel, + .readonly = &.{ss.tapes}, + .readwrite = &.{ss.block}, + .uniforms = gpu.uniform(f.scratch, Lang.Synth{ + .len = k.len, + .old_len = k.len, + .count = k.count, + .fade = if (k.fade) k.count else 0, + .start = ss.time, + .old_start = ss.time, + .rate = 48000, + }), + .groups = .{ (k.count + 63) / 64, 1, 1 }, + }); + } + f.image(ss.images[0], .{ .x = 0, .y = 0, .w = f.in.width, .h = f.in.height }, .{}); +} diff --git a/examples/live/test/grammar.zig b/examples/live/test/grammar.zig new file mode 100644 index 0000000..2fa982f --- /dev/null +++ b/examples/live/test/grammar.zig @@ -0,0 +1,54 @@ +//! The language's grammar (grammar/grammar.js, its parser.c compiled into +//! the sketch) against src/Lang.zig, which compiles the text: they must +//! agree on what is well formed, or what is coloured and walked would not +//! be the program that plays. +const std = @import("std"); +const app = @import("app"); +const Lang = @import("Lang"); +const pe = @import("pardes-editor"); + +test "the grammar and Lang.zig agree: both take a program, both refuse a broken line; what only Lang.zig refuses is its meaning" { + const parser = pe.syntax.ts.Parser.create(); + defer parser.destroy(); + try parser.setLanguage(app.tree_sitter_live()); + const Case = struct { text: []const u8, grammar: bool, lang: bool }; + for ([_]Case{ + .{ .text = Lang.survey, .grammar = true, .lang = true }, + .{ .text = "out = sin(tau * 220 * t) * 0.3\ncolor = hsv(x, 0.5, y)", .grammar = true, .lang = true }, + .{ .text = "\n # nothing\n a = 1 + 2 * -t / 4 - (5 - -6) # trailing\n\nout = a + 1e-3\n", .grammar = true, .lang = true }, + // broken lines: both refuse + .{ .text = "out = sin(tau * 220 * t * 0.3", .grammar = false, .lang = false }, + .{ .text = "out = 1 +", .grammar = false, .lang = false }, + .{ .text = "= 1", .grammar = false, .lang = false }, + .{ .text = "out 1", .grammar = false, .lang = false }, + .{ .text = "out", .grammar = false, .lang = false }, + .{ .text = "out = * 2", .grammar = false, .lang = false }, + .{ .text = "out = 1 2", .grammar = false, .lang = false }, + .{ .text = "out = sin(1 2)", .grammar = false, .lang = false }, + .{ .text = "out = 1.2.3", .grammar = false, .lang = false }, + .{ .text = "out = 1 $ 2", .grammar = false, .lang = false }, + .{ .text = "out = (1 + 2))", .grammar = false, .lang = false }, + // well formed, but meaning nothing: only Lang.zig knows its names, + // builtins and arities, and the problem it shows is the one drawn + .{ .text = "out = kick\nkick = 1", .grammar = true, .lang = false }, + .{ .text = "a = 1\na = 2", .grammar = true, .lang = false }, + .{ .text = "sin = 1", .grammar = true, .lang = false }, + .{ .text = "out = sin", .grammar = true, .lang = false }, + .{ .text = "out = foo(2)", .grammar = true, .lang = false }, + .{ .text = "out = mix(1, 2)", .grammar = true, .lang = false }, + .{ .text = "out = rgb(1, 1, 1)", .grammar = true, .lang = false }, + .{ .text = "a = 1\nout = a(2)", .grammar = true, .lang = false }, + }) |case| { + const tree = parser.parseString(case.text, null) orelse return error.NoTree; + defer tree.destroy(); + const lang = Lang.compile(case.text, null) == .program; + std.testing.expectEqual(case.grammar, !tree.rootNode().hasError()) catch |e| { + std.debug.print("the grammar on {s}\n", .{case.text}); + return e; + }; + std.testing.expectEqual(case.lang, lang) catch |e| { + std.debug.print("Lang.zig on {s}\n", .{case.text}); + return e; + }; + } +} diff --git a/examples/live/test/live.script b/examples/live/test/live.script new file mode 100644 index 0000000..1ddcec2 --- /dev/null +++ b/examples/live/test/live.script @@ -0,0 +1,111 @@ +# A program typed through the editor (helix's keys: `i`, text, Escape, +# motions), its tapes after each line, a broken line and its mend (an +# undo); then this run's session played back, and sought to two moments +# marked as they happened. (A mark ends a clip, `record`, so the session is +# replayed.) +# Screenshots land in .zig-cache/live/ for review; they are compared over +# the picture alone (640,300 600x300: not the text, the scope or the time). +frames 2 +type i +type out = sin(tau * 220 * t) * 0.3 +expect problem.len 0 +expect out.len 8 +expect out.code[5].op sin +expect out.code[7].op mul +# The GPU's blocks reach the speakers' stream (SDL's dummy driver here). +frames 10 +expect-audio 1 +key return +type color = hsv(x, 0.5, y) +expect color.len 4 +expect color.code[0].op x +expect color.code[3].op hsv +key escape +expect ed.cursor.mode normal +frames 2 +console save typed +screenshot .zig-cache/live/gradient.png +# An edit: y becomes x (to the line's end, a character left, replaced), +# and the picture changes. +type gl +type h +type rx +expect color.len 3 +expect color.code[2].op hsv +expect color.code[2].c 0 +frames 2 +screenshot .zig-cache/live/edited.png +expect-different-screenshot .zig-cache/live/gradient.png .zig-cache/live/edited.png 640 300 600 300 +# Broken: the ) deleted; the tape and the picture stay, the problem is set +# at its byte. +type l +type d +expect problem.at 52 +expect color.len 3 +expect color.code[2].c 0 +frames 2 +screenshot .zig-cache/live/broken.png +expect-same-screenshot .zig-cache/live/edited.png .zig-cache/live/broken.png 0 640 300 600 300 +# Mended: undone. +type u +expect problem.len 0 +expect color.len 3 +console save end +# Played back from the start, then sought: each moment's text, tapes and +# time as they were live, leaf by leaf (a mark is taken before its frame's +# tick: 0.3 s and 0.5333 s; a seek lands on the last frame at or before). +console play session 0 +frames 100 +console seek 538 +expect-snapshot end +console seek 305 +expect-snapshot typed +expect color.len 4 +screenshot .zig-cache/live/sought.png +expect-same-screenshot .zig-cache/live/gradient.png .zig-cache/live/sought.png 0 0 0 1000 600 +# Live again from there: the typed program, before its edit. +console stop +expect ed.front 53 +expect ed.back 0 +expect color.code[3].op hsv +# Hear this: Alt-o from the 2 of 220 to the number, then to `tau * 220`, +# which alone is heard and seen until the next key. +type gg +type 16l +hold left_alt +key o +expect probe.len 1 +key o +release left_alt +expect probe.len 3 +expect probe.code[2].op mul +key escape +expect probe.len 0 +# Drag a number: 220 (line 1, columns 16..18; a column 10 pixels from 16, +# a line 22 from 16) pressed and dragged 40 pixels right is 230, then 12 +# left of where it was pressed is 217; the program follows; the drag is one +# step to undo. +down 181 27 +move 201 27 +move 221 27 +expect out.code[1].a 1130758144 +move 169 27 +expect out.code[1].a 1129906176 +up 169 27 +type u +expect out.code[1].a 1130102784 +# Square units: a disc of radius 0.5 (half the window's height is 1) is +# 180 pixels across each way from the centre, round on 16:9. +type % +type c +type color = step(x * x + y * y, 0.25) +key escape +expect color.len 7 +frames 2 +screenshot .zig-cache/live/disc.png +expect-pixel .zig-cache/live/disc.png 810 360 255 255 255 255 2 +expect-pixel .zig-cache/live/disc.png 640 190 255 255 255 255 2 +expect-pixel .zig-cache/live/disc.png 470 360 255 255 255 255 2 +expect-pixel .zig-cache/live/disc.png 830 360 0 0 0 255 2 +expect-pixel .zig-cache/live/disc.png 640 170 0 0 0 255 2 +expect-pixel .zig-cache/live/disc.png 640 550 0 0 0 255 2 diff --git a/examples/live/test/probe.script b/examples/live/test/probe.script new file mode 100644 index 0000000..fc2e162 --- /dev/null +++ b/examples/live/test/probe.script @@ -0,0 +1,4 @@ +# The probe (src/probe.zig): frames enough for steady means, and what the +# 60-instruction tape draws, to see that the interpreter runs. +frames 600 +screenshot .zig-cache/live/probe.png diff --git a/examples/live/test/story.script b/examples/live/test/story.script new file mode 100644 index 0000000..25e66f5 --- /dev/null +++ b/examples/live/test/story.script @@ -0,0 +1,157 @@ +# The storyboard (reports/demo1.md, section 4), two minutes typed through +# the editor: a tone, its pitch dragged, a gradient, a kick shared by sound +# and picture, a `)` deleted and put back, a probe, a bass line and a ring; +# then the session played back, sought, stepped back and branched. State +# is asserted at each beat; each beat's screenshot lands in +# .zig-cache/story/, named by the beat. +console capture +frames 2 +# 0:05 a tone +type i +type out = sin(tau * 220 * t) * 0.3 +key escape +expect problem.len 0 +expect out.len 8 +frames 30 +expect-audio 1 +console save tone +screenshot .zig-cache/story/1-tone.png +# 0:15 the pitch dragged, 220 to 330 (columns 16..18 of line 1; a step +# every 4 pixels: 245 on the way) +down 181 27 +move 281 27 +expect out.code[1].a 1131741184 +move 621 27 +up 621 27 +expect out.code[1].a 1134886912 +frames 10 +screenshot .zig-cache/story/2-drag.png +# 0:25 a gradient behind the code +type o +type color = hsv(x / 4, 0.5, y / 2 + 0.5) +key escape +expect color.len 10 +expect color.code[9].op hsv +frames 10 +screenshot .zig-cache/story/3-gradient.png +# 0:35 a kick, shared: the picture pulses because it says kick too +type gg +type O +type beat = t * 2 +key return +type kick = exp(-7 * fract(beat)) +key return +type thump = sin(tau * 48 * t * (1 + 2 * kick)) * kick * 0.5 +key escape +type j +type x +type c +type out = thump +key return +key escape +type x +type c +type color = hsv(x / 4, 0.5, (y / 2 + 0.5) * (0.5 + kick)) +key escape +expect problem.len 0 +expect out.len 20 +expect out.code[19].op mul +expect color.len 20 +expect color.code[19].op hsv +# the picture's tape has the kick's exp in it, as the sound's does +expect color.code[16].op exp +console save kick +frames 20 +screenshot .zig-cache/story/4-kick.png +# 0:55 a ) deleted: marked, and the last good program plays on +type gl +type d +expect problem.at 162 +expect color.len 20 +frames 10 +screenshot .zig-cache/story/5-broken.png +# 1:00 put back +type a +type ) +key escape +expect problem.len 0 +frames 10 +screenshot .zig-cache/story/6-mended.png +# 1:05 inside thump's sin, Alt-o: only the call is heard and seen; Alt-i +# back inside it; Escape, the program again +type gg +type jj +type f* +type ; +type mi( +hold left_alt +key o +expect probe.len 17 +expect probe.code[16].op sin +frames 10 +screenshot .zig-cache/story/7-probe.png +key i +expect probe.len 16 +expect probe.code[15].op mul +release left_alt +key escape +expect probe.len 0 +# 1:15 a bass line under it, and the ring +type o +type root = seq(beat / 4, 55, 55, 65.4, 49) +key return +type bass = saw(root * t) * (1 - kick) * 0.25 +key escape +type j +type x +type c +type out = bass + thump +key return +key escape +type O +type r = sqrt(x * x + y * y) +key escape +type j +type x +type c +type color = hsv(fract(beat / 16 + r), 0.6, smoothstep(0.06, 0, abs(r - 0.4 - 0.2 * kick)) + 0.2 * kick) +key escape +expect problem.len 0 +expect out.len 35 +expect out.code[34].op add +expect color.len 31 +expect color.code[30].op hsv +console save end +frames 60 +screenshot .zig-cache/story/8-bass-ring.png +# 1:40 played back, paused, sought to the tone and to the kick (each +# moment's text, tapes and time as they were live, leaf by leaf), stepped +# back half a second +console play session 0 +frames 30 +console pause +console seek 590 +expect-snapshot tone +screenshot .zig-cache/story/9-sought-tone.png +console seek 1405 +expect-snapshot kick +console step -30 +expect time 0.9 ~0.001 +expect color.len 10 +screenshot .zig-cache/story/9-stepped-back.png +# 1:55 live again at the kick, another way on: the beat a third faster +console seek 1405 +console stop +type gg +type f2 +type ; +type r3 +expect problem.len 0 +expect out.code[8].a 1077936128 +frames 30 +screenshot .zig-cache/story/10-branched.png +# nothing was overwritten: the first session still ends as it did +console play session 0 +frames 10 +console seek 2890 +expect-snapshot end |
