const std = @import("std"); const plugin = @import("plugin.zig"); const custom = @import("custom.zig"); pub const ParseError = error{ OutOfMemory, ArgRequired, ParseFail, }; pub const CommandType = enum { /// "LV2 Commands" are commands that receive split, index, and then receive /// any f64 arguments. lv2_command, custom_command, }; fn LV2Command( comptime tag: Command.Tag, comptime plugin_url: []const u8, comptime LV2Parameters: type, ) type { return struct { pub const base_tag = tag; pub const command_type = CommandType.lv2_command; pub const lv2_url = plugin_url; base: Command, split: usize, index: usize, parameters: LV2Parameters, }; } fn CustomCommand( comptime tag: Command.Tag, comptime Plugin: type, comptime PluginParameters: type, ) type { return struct { pub const base_tag = tag; pub const command_type = CommandType.custom_command; pub const plugin_type = Plugin; base: Command, split: usize, index: usize, parameters: PluginParameters, }; } pub const Command = struct { tag: Tag, pub const Tag = enum { noop, load, quicksave, runqs, amp, rflanger, eq, phaser, mbeq, chorus, pitchscaler, reverb, highpass, delay, vinyl, revdelay, gate, detune, overdrive, degrade, repsycho, talkbox, dyncomp, thruzero, foverdrive, gverb, invert, tapedelay, moddelay, multichorus, saturator, vintagedelay, noise, wildnoise, write, embed, rotate, }; pub fn tagToType(tag: Tag) type { return switch (tag) { .noop => Noop, .load => Load, .quicksave => Quicksave, .runqs => RunQS, .amp => Amp, .rflanger => RFlanger, .eq => Eq, .phaser => Phaser, .mbeq => Mbeq, .chorus => Chorus, .pitchscaler => Pitchscaler, .reverb => Reverb, .highpass => Highpass, .delay => Delay, .vinyl => Vinyl, .revdelay => Revdelay, .gate => Gate, .detune => Detune, .overdrive => Overdrive, .degrade => Degrade, .repsycho => Repsycho, .talkbox => Talkbox, .dyncomp => Dyncomp, .thruzero => Thruzero, .foverdrive => Foverdrive, .gverb => Gverb, .invert => Invert, .tapedelay => Tapedelay, .moddelay => Moddelay, .multichorus => Multichorus, .saturator => Saturator, .vintagedelay => Vintagedelay, .noise => Noise, .wildnoise => Wildnoise, .write => Write, .embed => Embed, .rotate => Rotate, else => @panic("TODO"), }; } pub fn cast(base: *const @This(), comptime T: type) ?*const T { if (base.tag != T.base_tag) return null; return @fieldParentPtr(T, "base", base); } pub fn print(base: *const @This()) void { std.debug.warn("tag: {}\n", .{base.tag}); } pub const Noop = struct { pub const base_tag = Tag.noop; base: Command, }; pub const Load = struct { pub const base_tag = Tag.load; base: Command, path: []const u8, }; pub const Quicksave = struct { pub const base_tag = Tag.quicksave; base: Command, }; pub const RunQS = struct { pub const base_tag = Tag.runqs; base: Command, program: []const u8, }; pub const Noise = CustomCommand(Tag.noise, custom.RandomNoise, struct { seed: f32, fill_bytes: f32, }); pub const Wildnoise = CustomCommand(Tag.wildnoise, custom.WildNoise, struct { seed: f32, fill_bytes: f32, }); pub const Write = CustomCommand(Tag.write, custom.Write, struct { data: f32, }); pub const Embed = CustomCommand(Tag.write, custom.Embed, struct { path: []const u8, }); pub const Rotate = struct { pub const base_tag = Tag.rotate; base: Command, deg: f32, bgfill: []const u8, }; pub const Amp = LV2Command( .amp, "http://lv2plug.in/plugins/eg-amp", struct { gain: f32 }, ); pub const RFlanger = LV2Command( .rflanger, "http://plugin.org.uk/swh-plugins/retroFlange", struct { delay_depth_avg: f32, law_freq: f32 }, ); pub const Eq = LV2Command( .rflanger, "http://plugin.org.uk/swh-plugins/dj_eq_mono", struct { lo: f32, mid: f32, hi: f32 }, ); pub const Phaser = LV2Command( .phaser, "http://plugin.org.uk/swh-plugins/lfoPhaser", struct { lfo_rate: f32, lfo_depth: f32, fb: f32, spread: f32 }, ); pub const Mbeq = LV2Command( .mbeq, "http://plugin.org.uk/swh-plugins/mbeq", struct { band_1: f32, band_2: f32, band_3: f32, band_4: f32, band_5: f32, band_6: f32, band_7: f32, band_8: f32, band_9: f32, band_10: f32, band_11: f32, band_12: f32, band_13: f32, band_14: f32, band_15: f32, }, ); pub const Chorus = LV2Command( .chorus, "http://plugin.org.uk/swh-plugins/multivoiceChorus", struct { voices: f32, delay_base: f32, voice_spread: f32, detune: f32, law_freq: f32, attendb: f32, }, ); pub const Pitchscaler = LV2Command( .pitchscaler, "http://plugin.org.uk/swh-plugins/pitchScaleHQ", struct { mult: f32 }, ); pub const Reverb = LV2Command( .reverb, "http://invadarecords.com/plugins/lv2/erreverb/mono", struct { roomLength: f32, roomWidth: f32, roomHeight: f32, sourceLR: f32, sourceFB: f32, listLR: f32, listFB: f32, hpf: f32, warmth: f32, diffusion: f32, }, ); pub const Highpass = LV2Command(.highpass, "http://invadarecords.com/plugins/lv2/filter/hpf/mono", struct { freq: f32, gain: f32, noClip: f32, }); pub const Delay = LV2Command(.delay, "http://plugin.org.uk/swh-plugins/delayorama", struct { seed: f32, gain: f32, feedback_pc: f32, tap_count: f32, first_delay: f32, delay_range: f32, delay_scale: f32, delay_rand_pc: f32, gain_scale: f32, wet: f32, }); pub const Vinyl = LV2Command(.vinyl, "http://plugin.org.uk/swh-plugins/vynil", struct { year: f32, rpm: f32, warp: f32, click: f32, wear: f32, }); pub const Revdelay = LV2Command(.revdelay, "http://plugin.org.uk/swh-plugins/revdelay", struct { delay_time: f32, dry_level: f32, wet_level: f32, feedback: f32, xfade_samp: f32, }); // pub const Noise= LV2Command(.,,struct{}); pub const Gate = LV2Command(.gate, "http://hippie.lt/lv2/gate", struct { @"switch": f32, threshold: f32, attack: f32, hold: f32, decay: f32, gaterange: f32, }); pub const Detune = LV2Command(.detune, "http://drobilla.net/plugins/mda/Detune", struct { detune: f32, mix: f32, output: f32, latency: f32, }); pub const Overdrive = LV2Command(.overdrive, "http://drobilla.net/plugins/mda/Overdrive", struct { drive: f32, muffle: f32, output: f32, }); pub const Degrade = LV2Command(.degrade, "http://drobilla.net/plugins/mda/Degrade", struct { headroom: f32, quant: f32, rate: f32, post_filt: f32, non_lin: f32, output: f32, }); pub const Repsycho = LV2Command(.repsycho, "http://drobilla.net/plugins/mda/RePsycho", struct { tune: f32, fine: f32, decay: f32, thresh: f32, hold: f32, mix: f32, quality: f32, }); pub const Talkbox = LV2Command(.talkbox, "http://drobilla.net/plugins/mda/TalkBox", struct { wet: f32, dry: f32, carrier: f32, quality: f32, }); pub const Dyncomp = LV2Command(.dyncomp, "http://gareus.org/oss/lv2/darc#mono", struct { enable: f32, hold: f32, inputgain: f32, threshold: f32, ratio: f32, attack: f32, release: f32, gain_min: f32, gain_max: f32, rms: f32, }); pub const Foverdrive = LV2Command(.foverdrive, "http://plugin.org.uk/swh-plugins/foverdrive", struct { drive: f32, }); pub const Thruzero = LV2Command(.thruzero, "http://drobilla.net/plugins/mda/ThruZero", struct { rate: f32, mix: f32, feedback: f32, depth_mod: f32 }); pub const Gverb = LV2Command(.gverb, "http://plugin.org.uk/swh-plugins/gverb", struct { roomsize: f32, revtime: f32, damping: f32, inputbandwidth: f32, drylevel: f32, earlylevel: f32, taillevel: f32, }); pub const Invert = LV2Command(.invert, "http://plugin.org.uk/swh-plugins/inv", struct {}); pub const Tapedelay = LV2Command(.tapedelay, "http://plugin.org.uk/swh-plugins/tapeDelay", struct { speed: f32, da_db: f32, t1d: f32, t1a_db: f32, t2d: f32, t2a_db: f32, t3d: f32, t3a_db: f32, t4d: f32, t4a_db: f32, }); pub const Moddelay = LV2Command( .moddelay, "http://plugin.org.uk/swh-plugins/modDelay", struct { base: f32, }, ); pub const Multichorus = LV2Command(.multichorus, "http://calf.sourceforge.net/plugins/MultiChorus", struct { min_delay: f32, mod_depth: f32, mod_rate: f32, stereo: f32, voices: f32, vphase: f32, amount: f32, dry: f32, freq: f32, freq2: f32, q: f32, overlap: f32, level_in: f32, level_out: f32, lfo: f32, }); pub const Saturator = LV2Command(.saturator, "http://calf.sourceforge.net/plugins/Saturator", struct { bypass: f32, level_in: f32, level_out: f32, mix: f32, drive: f32, blend: f32, lp_pre_freq: f32, hp_pre_freq: f32, lp_post_freq: f32, hp_post_freq: f32, p_freq: f32, p_level: f32, p_q: f32, pre: f32, post: f32, }); pub const Vintagedelay = LV2Command(.vintagedelay, "http://calf.sourceforge.net/plugins/VintageDelay", struct { level_in: f32, level_out: f32, subdiv: f32, time_l: f32, time_r: f32, feedback: f32, amount: f32, mix_mode: f32, medium: f32, dry: f32, width: f32, fragmentation: f32, pbeats: f32, pfrag: f32, timing: f32, bpm: f32, ms: f32, hz: f32, bpm_host: f32, }); }; pub const CommandList = std.ArrayList(*Command); pub const ArgList = std.ArrayList([]const u8); pub const KeywordMap = std.StringHashMap(CommandType); /// A parser. pub const Lang = struct { allocator: *std.mem.Allocator, has_error: bool = false, line: usize = 0, pub fn init(allocator: *std.mem.Allocator) Lang { return Lang{ .allocator = allocator, }; } pub fn deinit(self: *Lang) void {} pub fn reset(self: *Lang) void { self.has_error = false; self.line = 0; } fn doError(self: *Lang, comptime fmt: []const u8, args: var) void { std.debug.warn("ERROR! at line {}: ", .{self.line}); std.debug.warn(fmt, args); std.debug.warn("\n", .{}); self.has_error = true; } fn parseCommandArguments( self: *@This(), comptime command_struct: type, tok_it: *std.mem.TokenIterator, commands: *CommandList, ) !void { // Based on the command struct fields, we can parse the arguments. var cmd = try self.allocator.create(command_struct); const is_lv2_command = switch (command_struct.base_tag) { .noop, .load, .quicksave, .runqs, .rotate => false, else => command_struct.command_type == .lv2_command, }; // TODO: crash when no arguments are left but we still need // arguments... if (is_lv2_command) { const split = tok_it.next(); if (split == null) { self.doError("Expected split parameter, got EOL", .{}); return; } const index = tok_it.next(); if (index == null) { self.doError("Expected index parameter, got EOL", .{}); return; } cmd.split = try std.fmt.parseInt(usize, split.?, 10); cmd.index = try std.fmt.parseInt(usize, index.?, 10); // All parameters for LV2 plugins are f32. inline for (@typeInfo(@TypeOf(cmd.parameters)).Struct.fields) |cmd_field| { const maybe_arg = tok_it.next(); if (maybe_arg == null) { self.doError("Expected parameter for {}, got nothing", .{cmd_field.name}); return; } const arg = maybe_arg.?; if (cmd_field.field_type != f32) @compileError("LV2 parameter struct can only have f32 fields"); @field(cmd.parameters, cmd_field.name) = try std.fmt.parseFloat(f32, arg); } } else { inline for (@typeInfo(command_struct).Struct.fields) |cmd_field| { comptime { if (std.mem.eql(u8, cmd_field.name, "base")) { continue; } } const arg = tok_it.next().?; const argument_value = switch (cmd_field.field_type) { usize => try std.fmt.parseInt(usize, arg, 10), i32 => try std.fmt.parseInt(i32, arg, 10), f32 => try std.fmt.parseFloat(f32, arg), []const u8 => try self.allocator.dupe(u8, arg), else => @panic("Invalid parameter type (" ++ @typeName(cmd_field.field_type) ++ ") left on command struct " ++ @typeName(command_struct) ++ "."), }; std.debug.warn("parsing {}, arg of type {} => {}\n", .{ @typeName(command_struct), @typeName(@TypeOf(argument_value)), argument_value, }); @field(cmd, cmd_field.name) = argument_value; } } cmd.base.tag = command_struct.base_tag; const command = cmd.base.cast(command_struct).?; std.debug.warn("cmd: {}\n", .{command}); try commands.append(&cmd.base); } pub fn parse(self: *Lang, data: []const u8) !CommandList { var splitted_it = std.mem.split(data, ";"); var cmds = CommandList.init(self.allocator); while (splitted_it.next()) |stmt_orig| { self.line += 1; var stmt = std.mem.trimRight(u8, stmt_orig, "\n"); stmt = std.mem.trimLeft(u8, stmt, "\n"); if (stmt.len == 0) continue; if (std.mem.startsWith(u8, stmt, "#")) continue; // TODO better tokenizer instead of just tokenize(" ")...maybe???? var tok_it = std.mem.tokenize(stmt, " "); var cmd_opt = tok_it.next(); if (cmd_opt == null) { self.doError("No command given", .{}); continue; } const command_string = cmd_opt.?; var found: bool = false; inline for (@typeInfo(Command).Struct.decls) |cmd_struct_decl| { switch (cmd_struct_decl.data) { .Type => |typ| switch (@typeInfo(typ)) { .Struct => {}, else => continue, }, else => continue, } const struct_name = cmd_struct_decl.name; comptime var lowered_command_name = [_]u8{0} ** struct_name.len; comptime { for (struct_name) |c, i| { lowered_command_name[i] = std.ascii.toLower(c); } } // if we have a match, we know the proper struct type // to use. this actually works compared to storing command_struct // in a variable because then that variable must be comptime. // the drawback of this approach is that our emitted code is basically linear // because we don't use the hashmap anymore. maybe #5359 can help. if (std.mem.eql(u8, &lowered_command_name, command_string)) { found = true; const cmd_struct_type = cmd_struct_decl.data.Type; try self.parseCommandArguments(cmd_struct_type, &tok_it, &cmds); } } if (!found) { self.doError("Unknown command '{}' ({})", .{ command_string, command_string.len }); continue; } // try cmds.append(cmd); } if (self.has_error) return ParseError.ParseFail; return cmds; } }; test "noop" { var lang = Lang.init(std.heap.direct_allocator); defer lang.deinit(); var cmds = try lang.parse("noop;"); defer cmds.deinit(); std.testing.expectEqual(cmds.len, 1); std.testing.expectEqual(cmds.items[0].command, .Noop); } test "load, phaser, quicksave" { var lang = Lang.init(std.heap.direct_allocator); defer lang.deinit(); const prog = \\load :0; \\phaser 3 1 25 0.25 0 1; \\quicksave; ; var cmds = try lang.parse(prog); defer cmds.deinit(); std.testing.expectEqual(cmds.len, 3); std.testing.expectEqual(cmds.items[0].command, .Load); std.testing.expectEqual(cmds.items[1].command, .Phaser); std.testing.expectEqual(cmds.items[2].command, .Quicksave); }