scritcher/src/lang.zig

527 lines
14 KiB
Zig
Raw Normal View History

2019-07-08 02:03:55 +00:00
const std = @import("std");
2019-07-10 19:06:44 +00:00
const plugin = @import("plugin.zig");
2019-07-08 03:23:12 +00:00
pub const ParseError = error{
2019-09-09 02:28:09 +00:00
OutOfMemory,
2019-07-09 03:04:01 +00:00
ArgRequired,
2019-08-08 23:27:24 +00:00
ParseFail,
2019-07-08 03:23:12 +00:00
};
2019-07-08 02:03:55 +00:00
pub const CommandType = enum {
Noop,
Load,
2019-07-10 19:06:44 +00:00
Quicksave,
2019-07-11 00:43:23 +00:00
RunQS,
2019-07-10 19:06:44 +00:00
2019-07-08 02:03:55 +00:00
Amp,
2019-07-10 16:24:03 +00:00
RFlanger,
2019-07-10 19:06:44 +00:00
Eq,
2019-07-10 19:24:43 +00:00
Phaser,
2019-07-10 19:43:30 +00:00
Mbeq,
2019-07-10 19:59:15 +00:00
Chorus,
2019-07-10 20:31:18 +00:00
PitchScaler,
2019-07-10 23:19:40 +00:00
Reverb,
Highpass,
2019-07-11 13:20:09 +00:00
Delay,
2019-07-13 19:46:26 +00:00
Vinyl,
2019-07-13 20:20:14 +00:00
RevDelay,
2020-01-25 20:47:20 +00:00
Gate,
2020-01-25 21:52:45 +00:00
Detune,
Overdrive,
Degrade,
RePsycho,
TalkBox,
2020-01-26 01:45:37 +00:00
DynComp,
2020-01-26 02:32:24 +00:00
ThruZero,
Foverdrive,
2020-01-26 03:03:15 +00:00
Gverb,
2020-01-26 03:13:53 +00:00
Invert,
2020-01-26 03:28:59 +00:00
TapeDelay,
2020-01-26 05:05:43 +00:00
ModDelay,
2020-01-26 17:03:01 +00:00
MultiChorus,
2020-01-26 17:50:50 +00:00
Saturator,
VintageDelay,
Noise,
2019-07-13 22:55:57 +00:00
WildNoise,
Write,
2019-10-22 20:08:19 +00:00
Embed,
2019-07-22 20:04:43 +00:00
Rotate,
2019-07-08 02:03:55 +00:00
};
pub const Type = enum {
/// "LV2 Commands" are commands that receive split, index, and then receive
/// any f64 arguments.
lv2_command,
};
pub const NewCommand = 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,
};
2020-05-31 01:39:45 +00:00
pub fn tagToType(tag: Tag) type {
return switch (tag) {
.noop => Noop,
.load => Load,
.quicksave => Quicksave,
.runqs => RunQS,
.amp => Amp,
.rflanger => RFlanger,
else => @panic("TODO"),
};
}
2020-05-31 01:56:45 +00:00
pub fn cast(base: *const @This(), comptime T: type) ?*const T {
if (base.tag != T.base_tag)
return null;
return @fieldParentPtr(T, "base", base);
}
2020-05-31 01:39:45 +00:00
pub fn print(base: *const @This()) void {
std.debug.warn("{}\n", .{base.tag});
}
pub const Noop = struct {
pub const base_tag = Tag.noop;
base: NewCommand,
};
pub const Load = struct {
pub const base_tag = Tag.load;
base: NewCommand,
path: []const u8,
};
pub const Quicksave = struct {
pub const base_tag = Tag.quicksave;
base: NewCommand,
};
pub const RunQS = struct {
pub const base_tag = Tag.runqs;
program: []const u8,
base: NewCommand,
};
pub const Amp = struct {
pub const base_tag = Tag.amp;
base: NewCommand,
2020-05-31 01:42:41 +00:00
split: usize,
index: usize,
2020-05-31 01:29:13 +00:00
gain: f32
};
pub const RFlanger = struct {
pub const base_tag = Tag.rflanger;
base: NewCommand,
2020-05-31 01:42:41 +00:00
split: usize,
index: usize,
2020-05-31 01:29:13 +00:00
delay_depth_avg: f32,
law_freq: f32,
};
};
2019-07-08 02:03:55 +00:00
pub const Command = struct {
command: CommandType,
2019-07-08 03:09:34 +00:00
args: ArgList,
cur_idx: usize = 0,
2019-07-08 02:03:55 +00:00
pub fn print(self: Command) void {
2020-01-15 01:31:20 +00:00
std.debug.warn("cmd:{}\n", .{self.command});
2019-07-08 02:03:55 +00:00
}
2019-07-09 01:40:52 +00:00
pub fn argAt(self: Command, idx: usize) ![]const u8 {
std.debug.warn("{} {}", .{ idx, self.args.items.len });
2019-07-09 03:04:01 +00:00
if (idx > (self.args.items.len - 1)) {
2020-01-15 01:31:20 +00:00
std.debug.warn("Expected argument at index {}\n", .{idx});
2019-07-09 03:04:01 +00:00
return ParseError.ArgRequired;
}
return self.args.items[idx];
2019-07-09 03:04:01 +00:00
}
pub fn usizeArgAt(self: Command, idx: usize) !usize {
2019-07-09 03:04:01 +00:00
var arg = try self.argAt(idx);
return try std.fmt.parseInt(usize, arg, 10);
}
pub fn consumePosition(self: *Command) !plugin.Position {
self.cur_idx = 2;
2019-07-10 19:06:44 +00:00
return plugin.Position{
.split = try self.usizeArgAt(0),
.index = try self.usizeArgAt(1),
};
}
pub fn intArgAt(self: Command, idx: usize) !i32 {
2019-07-09 03:04:01 +00:00
var arg = try self.argAt(idx);
2019-07-09 01:40:52 +00:00
return try std.fmt.parseInt(i32, arg, 10);
}
pub fn floatArgAt(self: Command, idx: usize) !f32 {
2019-07-09 03:04:01 +00:00
var arg = try self.argAt(idx);
2019-07-09 01:40:52 +00:00
return try std.fmt.parseFloat(f32, arg);
}
2019-07-10 19:43:30 +00:00
pub fn floatArgMany(
self: Command,
2019-07-10 19:43:30 +00:00
allocator: *std.mem.Allocator,
start_index: usize,
elements: usize,
default: f32,
) ![]const f32 {
var i: usize = start_index;
var arr = std.ArrayList(f32).init(allocator);
while (i < elements) : (i += 1) {
var value: f32 = self.floatArgAt(i) catch |err| blk: {
2020-01-15 01:31:20 +00:00
std.debug.warn("\tdoing default on arg {}\n", .{i});
2019-07-10 19:43:30 +00:00
break :blk default;
};
try arr.append(value);
}
return arr.items;
2019-07-10 19:43:30 +00:00
}
2019-07-10 19:59:15 +00:00
pub fn appendParam(
self: *Command,
2019-07-10 19:59:15 +00:00
params: *plugin.ParamList,
symbol: []const u8,
) !void {
var val = try self.floatArgAt(self.cur_idx);
self.cur_idx += 1;
2019-07-10 19:59:15 +00:00
try params.append(plugin.Param{
.sym = symbol,
.value = val,
});
}
pub fn appendParamMap(
self: *Command,
map: *plugin.ParamMap,
symbol: []const u8,
) !void {
var val = try self.floatArgAt(self.cur_idx);
self.cur_idx += 1;
_ = try map.put(symbol, val);
}
2019-07-08 03:09:34 +00:00
pub fn copy(self: Command, allocator: *std.mem.Allocator) !*Command {
var cmd = try allocator.create(Command);
cmd.* = Command{
.command = self.command,
.args = self.args,
.cur_idx = self.cur_idx,
};
2019-08-09 21:40:11 +00:00
return cmd;
2019-08-09 21:40:11 +00:00
}
};
2019-08-09 21:40:11 +00:00
pub const CommandList = std.ArrayList(NewCommand);
pub const ArgList = std.ArrayList([]const u8);
2019-08-09 21:40:11 +00:00
pub const KeywordMap = std.StringHashMap(CommandType);
2019-07-08 02:03:55 +00:00
/// A parser.
2019-07-08 02:03:55 +00:00
pub const Lang = struct {
allocator: *std.mem.Allocator,
keywords: KeywordMap,
2019-07-08 02:03:55 +00:00
has_error: bool = false,
line: usize = 0,
2019-07-08 02:03:55 +00:00
pub fn init(allocator: *std.mem.Allocator) Lang {
return Lang{
.allocator = allocator,
.keywords = KeywordMap.init(allocator),
};
}
2019-08-08 00:04:51 +00:00
pub fn deinit(self: *Lang) void {
self.keywords.deinit();
}
pub fn reset(self: *Lang) void {
self.has_error = false;
self.line = 0;
}
fn fillKeywords(self: *Lang) !void {
inline for (@typeInfo(NewCommand).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);
}
}
_ = try self.keywords.put(&lowered_command_name, @field(CommandType, struct_name));
}
2019-07-08 02:03:55 +00:00
}
pub fn getCommand(self: *Lang, stmt: []const u8) ?CommandType {
2019-08-09 21:40:11 +00:00
var kv_opt = self.keywords.get(stmt);
if (kv_opt) |kv| {
return kv.value;
} else {
return null;
}
}
fn expectAny(self: *Lang, count: usize, args: ArgList) !void {
if (args.items.len != count) {
self.doError("expected {} arguments, found {}", .{ count, args.items.len });
2019-08-08 23:13:49 +00:00
return error.ArgRequired;
}
}
fn expectSingle(self: *Lang, args: ArgList) !void {
return try self.expectAny(1, args);
}
2019-08-08 23:13:49 +00:00
fn expectFloat(self: *Lang, count: usize, args: ArgList) !void {
var i: usize = 0;
if (args.items.len != count) {
self.doError("expected {} arguments, found {}", .{ count, args.items.len });
2019-08-08 23:13:49 +00:00
return error.ArgRequired;
}
while (i < count) : (i += 1) {
var arg = args.items[i];
2019-08-08 23:13:49 +00:00
_ = std.fmt.parseFloat(f32, arg) catch |err| {
2020-01-15 01:31:20 +00:00
std.debug.warn("failed to parse f32: {}\n", .{err});
2019-08-08 23:13:49 +00:00
return error.FloatParseFail;
};
}
}
fn validateCommand(self: *Lang, cmd: Command) !void {
2019-08-08 23:13:49 +00:00
switch (cmd.command) {
.Quicksave, .Noop => {},
.Load, .RunQS => try self.expectSingle(cmd.args),
.Amp => try self.expectFloat(3, cmd.args),
.RFlanger => try self.expectFloat(4, cmd.args),
.Eq => try self.expectFloat(5, cmd.args),
.Phaser => try self.expectFloat(6, cmd.args),
2019-08-12 16:07:06 +00:00
.Mbeq => try self.expectFloat(17, cmd.args),
.Chorus => try self.expectFloat(8, cmd.args),
.PitchScaler => try self.expectFloat(3, cmd.args),
.Reverb => try self.expectFloat(12, cmd.args),
.Highpass => try self.expectFloat(5, cmd.args),
.Delay => try self.expectFloat(12, cmd.args),
.Vinyl => try self.expectFloat(7, cmd.args),
2019-08-27 17:17:15 +00:00
.RevDelay => try self.expectFloat(7, cmd.args),
.Noise => try self.expectFloat(4, cmd.args),
.WildNoise => try self.expectFloat(4, cmd.args),
.Write => try self.expectFloat(3, cmd.args),
.Rotate => try self.expectAny(2, cmd.args),
.Embed => try self.expectAny(3, cmd.args),
2020-01-15 01:31:20 +00:00
else => std.debug.warn("WARN unchecked command {}\n", .{cmd.command}),
2019-08-08 23:13:49 +00:00
}
}
2020-01-15 01:31:20 +00:00
fn doError(self: *Lang, comptime fmt: []const u8, args: var) void {
std.debug.warn("error at line {}: ", .{self.line});
std.debug.warn(fmt, args);
2020-01-15 01:31:20 +00:00
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);
inline for (@typeInfo(command_struct).Struct.fields) |cmd_field| {
comptime {
if (std.mem.eql(u8, cmd_field.name, "base")) {
continue;
}
}
// TODO: crash when no arguments are left but we still need
// arguments...
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 => arg,
else => @panic("Invalid parameter type (" ++ @typeName(cmd_field.field_type) ++ ") left on command struct " ++ @typeName(command_struct) ++ "."),
};
@field(cmd, cmd_field.name) = argument_value;
}
cmd.base.tag = command_struct.base_tag;
try commands.append(cmd.base);
}
2020-05-31 01:29:13 +00:00
pub fn parse(self: *Lang, data: []const u8) !CommandList {
var splitted_it = std.mem.split(data, ";");
// try self.fillKeywords();
2019-07-08 02:03:55 +00:00
var cmds = CommandList.init(self.allocator);
while (splitted_it.next()) |stmt_orig| {
self.line += 1;
2019-07-08 02:03:55 +00:00
var stmt = std.mem.trimRight(u8, stmt_orig, "\n");
2019-07-08 16:55:54 +00:00
stmt = std.mem.trimLeft(u8, stmt, "\n");
2019-07-08 02:03:55 +00:00
if (stmt.len == 0) continue;
2019-08-13 13:19:39 +00:00
if (std.mem.startsWith(u8, stmt, "#")) continue;
2019-07-08 02:03:55 +00:00
// TODO better tokenizer instead of just tokenize(" ")...maybe????
2019-07-08 03:09:34 +00:00
var tok_it = std.mem.tokenize(stmt, " ");
2019-07-08 03:23:12 +00:00
var cmd_opt = tok_it.next();
if (cmd_opt == null) {
2020-01-15 01:31:20 +00:00
self.doError("No command given", .{});
continue;
}
2020-05-30 20:48:14 +00:00
const command_string = cmd_opt.?;
2020-05-30 20:48:14 +00:00
var found: bool = false;
inline for (@typeInfo(NewCommand).Struct.decls) |cmd_struct_decl| {
switch (cmd_struct_decl.data) {
.Type => |typ| switch (@typeInfo(typ)) {
.Struct => {},
else => continue,
},
else => continue,
}
2020-05-30 20:48:14 +00:00
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.
2020-05-30 20:48:14 +00:00
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);
2020-05-30 20:48:14 +00:00
}
2019-07-08 03:09:34 +00:00
}
2020-05-30 20:48:14 +00:00
if (!found) {
self.doError("Unknown command '{}' ({})", .{ command_string, command_string.len });
continue;
2020-05-30 20:48:14 +00:00
}
2019-08-08 23:13:49 +00:00
2020-05-30 20:48:14 +00:00
// try cmds.append(cmd);
2019-07-08 02:03:55 +00:00
}
if (self.has_error) return ParseError.ParseFail;
2019-07-08 02:03:55 +00:00
return cmds;
}
};
2019-07-08 03:09:34 +00:00
2019-08-08 00:04:51 +00:00
test "noop" {
var lang = Lang.init(std.heap.direct_allocator);
2019-08-08 00:09:04 +00:00
defer lang.deinit();
2019-08-08 00:04:51 +00:00
var cmds = try lang.parse("noop;");
2019-08-08 00:09:04 +00:00
defer cmds.deinit();
2019-08-08 00:04:51 +00:00
std.testing.expectEqual(cmds.len, 1);
2020-05-12 20:48:15 +00:00
std.testing.expectEqual(cmds.items[0].command, .Noop);
2019-08-08 00:04:51 +00:00
}
test "load, phaser, quicksave" {
var lang = Lang.init(std.heap.direct_allocator);
2019-08-08 00:09:04 +00:00
defer lang.deinit();
2019-08-08 00:04:51 +00:00
const prog =
\\load :0;
\\phaser 3 1 25 0.25 0 1;
\\quicksave;
;
2019-08-08 00:09:04 +00:00
2019-08-08 00:04:51 +00:00
var cmds = try lang.parse(prog);
2019-08-08 00:09:04 +00:00
defer cmds.deinit();
2019-08-08 00:04:51 +00:00
std.testing.expectEqual(cmds.len, 3);
2020-05-12 20:48:15 +00:00
std.testing.expectEqual(cmds.items[0].command, .Load);
std.testing.expectEqual(cmds.items[1].command, .Phaser);
std.testing.expectEqual(cmds.items[2].command, .Quicksave);
2019-08-08 00:04:51 +00:00
}