From d7d43852422f1abec1fba6b9ba38ca50ebadcacc Mon Sep 17 00:00:00 2001 From: Luna Date: Wed, 27 Apr 2022 20:01:00 -0300 Subject: [PATCH 1/5] fix memory leak on string arguments --- src/lang.zig | 19 +++++++++++++++++-- src/main.zig | 6 +++--- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/src/lang.zig b/src/lang.zig index 3ad0c41..f465895 100644 --- a/src/lang.zig +++ b/src/lang.zig @@ -479,6 +479,21 @@ pub const CommandList = struct { pub fn deinit(self: *Self) void { for (self.list.items) |cmd_ptr| { self.list.allocator.destroy(cmd_ptr); + inline for (@typeInfo(Command.Tag).Enum.fields) |field| { + if (cmd_ptr.tag == @field(Command.Tag, field.name)) { + const actual_tag = + @field(Command.Tag, field.name); + // if we find a match on the tag, we can get the type + const typ = Command.tagToType(actual_tag); + + inline for (@typeInfo(typ).Struct.fields) |cmd_field| { + switch (cmd_field.field_type) { + []u8, []const u8 => self.list.allocator.destroy(@field(typ, cmd_field.name)), + else => {}, + } + } + } + } } self.list.deinit(); } @@ -561,7 +576,7 @@ pub const Lang = struct { f32 => try std.fmt.parseFloat(f32, arg), u64 => try std.fmt.parseInt(u64, arg, 10), usize => try std.fmt.parseInt(usize, arg, 10), - []const u8 => arg, + []const u8 => @as([]const u8, try self.allocator.dupe(u8, arg)), else => @compileError("parameter struct has unsupported type " ++ @typeName(cmd_field.field_type)), }; @@ -586,7 +601,7 @@ pub const Lang = struct { 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, + []const u8 => @as([]const u8, try self.allocator.dupe(u8, arg)), else => @compileError("Invalid parameter type (" ++ @typeName(cmd_field.field_type) ++ ") left on command struct " ++ @typeName(command_struct) ++ "."), }; diff --git a/src/main.zig b/src/main.zig index f1cb3c8..a096f4f 100644 --- a/src/main.zig +++ b/src/main.zig @@ -40,6 +40,8 @@ pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { var stdout_file = std.io.getStdOut(); const stdout = &stdout_file.writer(); const scri_path = try (args_it.next(allocator) orelse @panic("expected scri path")); + errdefer allocator.free(scri_path); + defer allocator.free(scri_path); var file_read_opt: ?std.fs.File = std.fs.cwd().openFile(scri_path, .{}) catch |err| blk: { if (err == error.FileNotFound) break :blk null; @@ -54,11 +56,9 @@ pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { defer lang.deinit(); if (total_bytes > 0) { - // this MUST BE long lived (a reference to it is kept inside - // existing_cmds, and then passed along to cmds), - // we can't defer them here var scri_existing = try allocator.alloc(u8, total_bytes); _ = try file_read_opt.?.read(scri_existing); + defer allocator.free(scri_existing); // we can't defer this directly because we copy the // Command pointers to the cmds list. running deinit() directly From 268be1074cf44eb4e0d60a519cd3a3258574710b Mon Sep 17 00:00:00 2001 From: Luna Date: Wed, 27 Apr 2022 20:01:06 -0300 Subject: [PATCH 2/5] port to latest zig fs api --- src/main.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main.zig b/src/main.zig index a096f4f..005100b 100644 --- a/src/main.zig +++ b/src/main.zig @@ -89,9 +89,9 @@ pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { file_read.close(); } - var file = try std.fs.cwd().openFile(scri_path, .{ - .write = true, + var file = try std.fs.cwd().createFile(scri_path, .{ .read = false, + .truncate = true, }); defer file.close(); From c817170a0423fa65ef28aa15e512db9284edeaa9 Mon Sep 17 00:00:00 2001 From: Luna Date: Wed, 27 Apr 2022 20:01:09 -0300 Subject: [PATCH 3/5] port to latest zig: use std.log --- build.zig | 6 +++--- src/bmp_valid.zig | 5 ++--- src/custom.zig | 3 ++- src/image.zig | 41 +++++++++++++++++++++-------------------- src/lang.zig | 13 +++++++------ src/lv2_helpers.zig | 8 +++++--- src/magick.zig | 7 ++++--- src/main.zig | 18 ++++++++++-------- src/plugin.zig | 5 +++-- src/printer.zig | 2 ++ src/runner.zig | 16 +++++++++------- 11 files changed, 68 insertions(+), 56 deletions(-) diff --git a/build.zig b/build.zig index 467240c..f7b08f9 100644 --- a/build.zig +++ b/build.zig @@ -24,19 +24,19 @@ fn setupLinks(step: *builds.LibExeObjStep) void { for (possible_lilv_include_dirs) |possible_lilv_dir| { var possible_dir = std.fs.cwd().openDir(possible_lilv_dir, .{}) catch |err| { - std.debug.warn("possible lilv {s} fail: {s}\n", .{ possible_lilv_dir, err }); + std.debug.print("possible lilv {s} fail: {s}\n", .{ possible_lilv_dir, err }); continue; }; possible_dir.close(); found_any_lilv = true; - std.debug.warn("found lilv at '{s}'\n", .{possible_lilv_dir}); + std.debug.print("found lilv at '{s}'\n", .{possible_lilv_dir}); step.addIncludeDir(possible_lilv_dir); } if (!found_any_lilv) { - std.debug.warn("No LILV library was found :(\n", .{}); + std.debug.print("No LILV library was found :(\n", .{}); @panic("no lilv found"); } } diff --git a/src/bmp_valid.zig b/src/bmp_valid.zig index 6468658..55970b8 100644 --- a/src/bmp_valid.zig +++ b/src/bmp_valid.zig @@ -1,11 +1,10 @@ const std = @import("std"); - +const log = std.log.scoped(.scritcher_bmp); pub const BMPValidError = error{InvalidMagic}; const VALID_MAGICS = [_][]const u8{ "BM", "BA", - "CI", "CP", "IC", @@ -20,7 +19,7 @@ pub fn magicValid(magic: []const u8) !void { } if (!valid) { - std.debug.warn("\tINVALID HEADER: '{s}'\n", .{magic}); + log.debug("\tINVALID HEADER: '{s}'\n", .{magic}); return BMPValidError.InvalidMagic; } } diff --git a/src/custom.zig b/src/custom.zig index 03120f0..401b39f 100644 --- a/src/custom.zig +++ b/src/custom.zig @@ -4,6 +4,7 @@ const lv2 = @import("lv2_helpers.zig"); const plugins = @import("plugin.zig"); const image = @import("image.zig"); +const log = std.log.scoped(.scritcher_custom); const c = lv2.c; const RunBuffers = plugins.RunBuffers; @@ -174,7 +175,7 @@ pub const Embed = struct { if (read_bytes < 0) { const st: i32 = c.sf_error(self.sndfile); - std.debug.warn("Failed to read {s} ({s})\n", .{ + log.debug("Failed to read {s} ({s})\n", .{ self.filepath, c.sf_error_number(st), }); diff --git a/src/image.zig b/src/image.zig index b6e13ae..4a01845 100644 --- a/src/image.zig +++ b/src/image.zig @@ -3,6 +3,7 @@ const lv2 = @import("lv2_helpers.zig"); const c = lv2.c; const bmp = @import("bmp_valid.zig"); +const log = std.log.scoped(.scritcher_image); const plugins = @import("plugin.zig"); /// Buffer size for main image copying. @@ -32,7 +33,7 @@ pub fn sopen( const st: i32 = c.sf_error(file); if (st != 0) { - std.debug.warn("Failed to open {s} ({s})\n", .{ + log.debug("Failed to open {s} ({s})\n", .{ path, c.sf_error_number(st), }); @@ -47,7 +48,7 @@ pub fn sopen( const frames_on_end_by_end = c.sf_seek(file, frames_on_end, c.SEEK_SET); std.testing.expectEqual(frames_on_end, frames_on_end_by_end); - std.debug.warn("frames on end: {}, frame on end (2): {}\n", .{ frames_on_end, frames_on_end_by_end }); + log.debug("frames on end: {}, frame on end (2): {}\n", .{ frames_on_end, frames_on_end_by_end }); return file.?; } @@ -56,7 +57,7 @@ pub fn swrite(file: *c.SNDFILE, buf: [*]f32, frames: i64) !void { const count = c.sf_writef_float(file, buf, frames); if (count != frames) { - std.debug.warn("Wanted to write {}, got {}\n", .{ frames, count }); + log.debug("Wanted to write {}, got {}\n", .{ frames, count }); return ImageError.WriteFail; } } @@ -68,7 +69,7 @@ pub fn sseek(file: *c.SNDFILE, offset: usize) void { std.testing.expectEqual(frames, frames_current); if (frames != offset_i64) { - std.debug.warn("failed to seek to {} (seeked {} frames, offset_i64={})\n", .{ offset, frames, offset_i64 }); + log.debug("failed to seek to {} (seeked {} frames, offset_i64={})\n", .{ offset, frames, offset_i64 }); } } @@ -181,7 +182,7 @@ pub const Image = struct { pub fn close(self: *Image) void { var st: i32 = c.sf_close(self.sndfile); if (st != 0) { - std.debug.warn("Failed to close {s} ({s})\n", .{ + log.debug("Failed to close {s} ({s})\n", .{ self.path, c.sf_error_number(st), }); @@ -228,7 +229,7 @@ pub const Image = struct { sseek(out_file, start); while (i <= end) : (i += buf.len) { - std.debug.warn("\t\ti={d}, buf.len={d}, end={d}\n", .{ i, buf.len, end }); + log.debug("\t\ti={d}, buf.len={d}, end={d}\n", .{ i, buf.len, end }); sseek(self.sndfile, i); sseek(out_file, i); @@ -254,7 +255,7 @@ pub const Image = struct { fn getSeekPos(self: *Image, position: plugins.Position) plugins.SeekPos { const file_end = self.frames; var seek_pos = position.seekPos(file_end); - std.debug.warn("\tstart {d} end {d}\n", .{ seek_pos.start, seek_pos.end }); + log.debug("\tstart {d} end {d}\n", .{ seek_pos.start, seek_pos.end }); return seek_pos; } @@ -267,7 +268,7 @@ pub const Image = struct { self.curpath = path; self.frames = @intCast(usize, in_fmt.frames); - std.debug.warn("\timage: reopened on '{s}' (frames={d}, fmt.frames={d})\n", .{ + log.debug("\timage: reopened on '{s}' (frames={d}, fmt.frames={d})\n", .{ self.curpath, self.frames, in_fmt.frames, @@ -310,12 +311,12 @@ pub const Image = struct { defer ctx.allocator.free(ports); if (ctx.n_audio_in > 2) { - std.debug.warn("plugin <{s}> has more than two inputs.\n", .{plugin_uri}); + log.debug("plugin <{s}> has more than two inputs.\n", .{plugin_uri}); return ImageError.InvalidPlugin; } if (ctx.n_audio_out > 2) { - std.debug.warn("plugin <{s}> has more than two outputs.\n", .{plugin_uri}); + log.debug("plugin <{s}> has more than two outputs.\n", .{plugin_uri}); return ImageError.InvalidPlugin; } @@ -327,14 +328,14 @@ pub const Image = struct { var sym = c.lilv_new_string(ctx.world, sym_cstr.ptr); const port = c.lilv_plugin_get_port_by_symbol(ctx.plugin, sym) orelse { - std.debug.warn("assert fail: symbol {s} not found on port\n", .{param.sym}); + log.debug("assert fail: symbol {s} not found on port\n", .{param.sym}); return ImageError.InvalidSymbol; }; c.lilv_node_free(sym); var idx = c.lilv_port_get_index(ctx.plugin, port); - std.debug.warn("\tset sym={s}, idx={d} to val={}\n", .{ + log.debug("\tset sym={s}, idx={d} to val={}\n", .{ param.sym, idx, param.value, @@ -345,7 +346,7 @@ pub const Image = struct { // now we need to generate a temporary file and put the output of // running the plugin on that file var tmpnam = try temporaryName(self.allocator); - std.debug.warn("\trunning plugin from '{s}' to '{s}'\n", .{ self.curpath, tmpnam }); + log.debug("\trunning plugin from '{s}' to '{s}'\n", .{ self.curpath, tmpnam }); var out_fmt = mkSfInfo(); var out_file = try sopen(self.allocator, tmpnam, c.SFM_WRITE, &out_fmt); @@ -378,7 +379,7 @@ pub const Image = struct { sseek(self.sndfile, seek_pos.start); var i: usize = seek_pos.start; - std.debug.warn("\tseek pos start: {d} end: {d}\n", .{ seek_pos.start, seek_pos.end }); + log.debug("\tseek pos start: {d} end: {d}\n", .{ seek_pos.start, seek_pos.end }); var inbuf = &rctx.buffers.in; var outbuf = &rctx.buffers.out; @@ -389,7 +390,7 @@ pub const Image = struct { const read_bytes = c.sf_readf_float(self.sndfile, inbuf, 1); if (read_bytes == 0) { - std.debug.warn("WARN! reached EOF at idx={d}\n", .{i}); + log.debug("WARN! reached EOF at idx={d}\n", .{i}); break; } @@ -418,11 +419,11 @@ pub const Image = struct { try self.checkValid(); var time_taken = timer.read(); - std.debug.warn("\ttook {d:.2}ms running plugin\n", .{time_taken / std.time.us_per_ms}); + log.debug("\ttook {d:.2}ms running plugin\n", .{time_taken / std.time.us_per_ms}); } pub fn saveTo(self: *Image, out_path: []const u8) !void { - std.debug.warn("\timg: copy from '{s}' to '{s}'\n", .{ self.curpath, out_path }); + log.debug("\timg: copy from '{s}' to '{s}'\n", .{ self.curpath, out_path }); try std.fs.copyFileAbsolute(self.curpath, out_path, .{}); } @@ -450,7 +451,7 @@ pub const Image = struct { // the code here is a copypaste of runPlugin() without the specific // lilv things. var tmpnam = try temporaryName(self.allocator); - std.debug.warn("\trunning CUSTOM plugin from '{s}' to '{s}'\n", .{ self.curpath, tmpnam }); + log.debug("\trunning CUSTOM plugin from '{s}' to '{s}'\n", .{ self.curpath, tmpnam }); var out_fmt = mkSfInfo(); var out_file = try sopen(self.allocator, tmpnam, c.SFM_WRITE, &out_fmt); @@ -477,7 +478,7 @@ pub const Image = struct { sseek(self.sndfile, seek_pos.start); var i: usize = seek_pos.start; - std.debug.warn("\tseek pos start: {d} end: {d}\n", .{ seek_pos.start, seek_pos.end }); + log.debug("\tseek pos start: {d} end: {d}\n", .{ seek_pos.start, seek_pos.end }); var inbuf = &bufs.in; var outbuf = &bufs.out; @@ -485,7 +486,7 @@ pub const Image = struct { while (i <= seek_pos.end) : (i += 1) { const read_bytes = c.sf_readf_float(self.sndfile, inbuf, 1); if (read_bytes == 0) { - std.debug.warn("WARN! reached EOF at idx={d}\n", .{i}); + log.debug("WARN! reached EOF at idx={d}\n", .{i}); break; } diff --git a/src/lang.zig b/src/lang.zig index f465895..4c4f8f5 100644 --- a/src/lang.zig +++ b/src/lang.zig @@ -3,6 +3,7 @@ const std = @import("std"); const plugin = @import("plugin.zig"); const custom = @import("custom.zig"); +const log = std.log.scoped(.scritcher_lang); pub const ParseError = error{ParseFail}; pub const CommandType = enum { @@ -146,7 +147,7 @@ pub const Command = struct { } pub fn print(base: *const @This()) void { - std.debug.warn("tag: {s}\n", .{base.tag}); + log.debug("tag: {s}\n", .{base.tag}); } pub const Noop = struct { @@ -524,9 +525,9 @@ pub const Lang = struct { } fn doError(self: *Lang, comptime fmt: []const u8, args: anytype) void { - std.debug.warn("ERROR! at line {}: ", .{self.line}); - std.debug.warn(fmt, args); - std.debug.warn("\n", .{}); + log.debug("ERROR! at line {}: ", .{self.line}); + log.debug(fmt, args); + log.debug("\n", .{}); self.has_error = true; } @@ -605,7 +606,7 @@ pub const Lang = struct { else => @compileError("Invalid parameter type (" ++ @typeName(cmd_field.field_type) ++ ") left on command struct " ++ @typeName(command_struct) ++ "."), }; - std.debug.warn("parsing {s}, arg of type {s} => {any}\n", .{ + log.debug("parsing {s}, arg of type {s} => {any}\n", .{ @typeName(command_struct), @typeName(@TypeOf(argument_value)), argument_value, @@ -617,7 +618,7 @@ pub const Lang = struct { cmd.base.tag = command_struct.base_tag; const command = cmd.base.cast(command_struct).?; - std.debug.warn("cmd: {s}\n", .{command}); + log.debug("cmd: {s}\n", .{command}); } pub fn parse(self: *Lang, data: []const u8) !CommandList { diff --git a/src/lv2_helpers.zig b/src/lv2_helpers.zig index 599370c..62570df 100644 --- a/src/lv2_helpers.zig +++ b/src/lv2_helpers.zig @@ -1,6 +1,8 @@ const std = @import("std"); const plugin = @import("plugin.zig"); +const log = std.log.scoped(.scritcher_lv2); + pub const c = @cImport({ @cInclude("sndfile.h"); @cInclude("lilv/lilv.h"); @@ -21,7 +23,7 @@ const LV2_CORE__connectionOptional = Lv2Core("#connectionOptional"); pub fn lilv_instance_connect_port( instance: [*c]c.LilvInstance, port_index: u32, - data_location: ?*c_void, + data_location: ?*anyopaque, ) void { instance.?.*.lv2_descriptor.?.*.connect_port.?(instance.?.*.lv2_handle, port_index, data_location); } @@ -118,7 +120,7 @@ pub fn setupPorts(ctx: *plugin.Context) ![]Port { if (c.lilv_port_is_a(ctx.plugin, lport, lv2_InputPort)) { port.is_input = true; } else if (!c.lilv_port_is_a(ctx.plugin, lport, lv2_OutputPort) and !port.optional) { - std.debug.warn("Port {d} is neither input or output\n", .{i}); + log.debug("Port {d} is neither input or output\n", .{i}); return error.UnassignedIOPort; } @@ -134,7 +136,7 @@ pub fn setupPorts(ctx: *plugin.Context) ![]Port { ctx.n_audio_out += 1; } } else if (!port.optional) { - std.debug.warn("Port {d} has unsupported type\n", .{i}); + log.debug("Port {d} has unsupported type\n", .{i}); return error.UnsupportedPortType; } } diff --git a/src/magick.zig b/src/magick.zig index dd5f295..21f6d2d 100644 --- a/src/magick.zig +++ b/src/magick.zig @@ -2,6 +2,7 @@ const std = @import("std"); const images = @import("image.zig"); +const log = std.log.scoped(.scritcher_magick); const Image = images.Image; const mc = @cImport({ @@ -39,7 +40,7 @@ fn magickLoad(image: *Image) !MagickContext { var curpath = try std.cstr.addNullByte(image.allocator, image.curpath); defer image.allocator.free(curpath); - std.debug.warn("loading '{s}'\n", .{curpath}); + log.debug("loading '{s}'\n", .{curpath}); if (mc.MagickReadImage(mctx.wand, curpath.ptr) != 1) return error.MagickReadFail; @@ -54,12 +55,12 @@ fn magickSave(image: *Image, wand: *mc.MagickWand) !void { var c_tmpnam = try std.cstr.addNullByte(allocator, tmpnam); defer allocator.free(c_tmpnam); - std.debug.warn("\tmagick: saving to '{s}'..", .{c_tmpnam}); + log.debug("\tmagick: saving to '{s}'..", .{c_tmpnam}); if (mc.MagickWriteImage(wand, c_tmpnam.ptr) != 1) return error.MagickWriteFail; - std.debug.warn("OK\n", .{}); + log.debug("OK\n", .{}); try image.reopen(tmpnam); } diff --git a/src/main.zig b/src/main.zig index 005100b..c41d2e4 100644 --- a/src/main.zig +++ b/src/main.zig @@ -3,6 +3,8 @@ const langs = @import("lang.zig"); const runners = @import("runner.zig"); const printer = @import("printer.zig"); +const log = std.log.scoped(.scritcher); + test "scritcher" { _ = @import("lang.zig"); _ = @import("runner.zig"); @@ -132,7 +134,7 @@ pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { var rd_line = readline.readline("> "); if (rd_line == null) { - std.debug.warn("leaving from eof\n", .{}); + log.debug("leaving from eof\n", .{}); break; } readline.add_history(rd_line); @@ -200,14 +202,14 @@ pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { try printer.printList(cmds, stream); continue; } else if (std.mem.eql(u8, line, "quit") or std.mem.eql(u8, line, "q")) { - std.debug.warn("leaving\n", .{}); + log.debug("leaving\n", .{}); break; } else if (std.mem.startsWith(u8, line, "#")) { continue; } var cmds_parsed = lang.parse(line) catch |err| { - std.debug.warn("repl: error while parsing: {}\n", .{err}); + log.debug("repl: error while parsing: {}\n", .{err}); continue; }; @@ -231,10 +233,10 @@ pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { } fn doHelp() void { - std.debug.warn("scritcher!\n", .{}); - std.debug.warn("usage: scritcher [run|help|repl]\n", .{}); - std.debug.warn("\tscritcher run path_to_script.scri path_to_input_file.bmp\n", .{}); - std.debug.warn("\tscritcher repl path_to_script.scri path_to_input_file.bmp\n", .{}); + log.debug("scritcher!\n", .{}); + log.debug("usage: scritcher [run|help|repl]\n", .{}); + log.debug("\tscritcher run path_to_script.scri path_to_input_file.bmp\n", .{}); + log.debug("\tscritcher repl path_to_script.scri path_to_input_file.bmp\n", .{}); } fn doRun(allocator: *std.mem.Allocator, args_it: anytype) !void { @@ -288,7 +290,7 @@ pub fn main() !void { } else if (std.mem.eql(u8, cli_command, "run")) { return try doRun(allocator, &args_it); } else { - std.debug.warn("unknown command: '{s}'\n", .{cli_command}); + log.debug("unknown command: '{s}'\n", .{cli_command}); return error.UnknownCommand; } } diff --git a/src/plugin.zig b/src/plugin.zig index cb8c64a..d046edb 100644 --- a/src/plugin.zig +++ b/src/plugin.zig @@ -3,6 +3,7 @@ const std = @import("std"); const lv2 = @import("lv2_helpers.zig"); const c = lv2.c; +const log = std.log.scoped(.scritcher_plugin); const ImageError = @import("image.zig").ImageError; /// Control port @@ -137,7 +138,7 @@ pub fn makeContext(allocator: *std.mem.Allocator, plugin_uri: []const u8) !Conte c.lilv_world_load_all(world); var uri: *c.LilvNode = c.lilv_new_uri(world, cstr_plugin_uri.ptr) orelse { - std.debug.warn("Invalid plugin URI <{s}>\n", .{plugin_uri}); + log.debug("Invalid plugin URI <{s}>\n", .{plugin_uri}); return ImageError.InvalidPlugin; }; defer c.lilv_node_free(uri); @@ -145,7 +146,7 @@ pub fn makeContext(allocator: *std.mem.Allocator, plugin_uri: []const u8) !Conte const plugins: *const c.LilvPlugins = c.lilv_world_get_all_plugins(world).?; var plugin: *const c.LilvPlugin = c.lilv_plugins_get_by_uri(plugins, uri) orelse { - std.debug.warn("Plugin <{s}> not found\n", .{plugin_uri}); + log.debug("Plugin <{s}> not found\n", .{plugin_uri}); return ImageError.UnknownPlugin; }; diff --git a/src/printer.zig b/src/printer.zig index c1fab31..a851602 100644 --- a/src/printer.zig +++ b/src/printer.zig @@ -1,6 +1,8 @@ const std = @import("std"); const langs = @import("lang.zig"); +const log = std.log.scoped(.scritcher_printer); + fn printCommandWithParams(stream: anytype, command: anytype) !void { const Parameters = @TypeOf(command.parameters); try stream.print(" {d} {d}", .{ command.split, command.index }); diff --git a/src/runner.zig b/src/runner.zig index 16bbc12..40684a3 100644 --- a/src/runner.zig +++ b/src/runner.zig @@ -5,6 +5,8 @@ const plugin = @import("plugin.zig"); const custom = @import("custom.zig"); const magick = @import("magick.zig"); +const log = std.log.scoped(.scritcher_runner); + const Position = plugin.Position; const ParamList = plugin.ParamList; const ParamMap = plugin.ParamMap; @@ -65,12 +67,12 @@ pub const Runner = struct { // 'scritcher repl ./script ./image' // ':0' should ALWAYS point to the image. - if (self.repl) index += 4 else index += 3; + if (self.repl) index += 3 else index += 3; for (self.args) |arg, idx| { - std.debug.warn("arg{d} = {s}\n", .{ idx, arg }); + log.debug("arg{d} = {s}\n", .{ idx, arg }); } - std.debug.warn("fetch arg idx={d}, val={s}\n", .{ index, self.args[index] }); + log.debug("fetch arg idx={d}, val={s}\n", .{ index, self.args[index] }); return self.args[index]; } else { return load_path; @@ -90,7 +92,7 @@ pub const Runner = struct { fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void { const load_path = try self.resolveArgPath(path_or_argidx); - std.debug.warn("\tload path: {s}\n", .{load_path}); + log.debug("\tload path: {s}\n", .{load_path}); // we could use ImageMagick to convert from X to BMP // but i can't find an easy way to do things in memory. @@ -100,7 +102,7 @@ pub const Runner = struct { // krita/gimp and make it export a bmp and while in the program you can // apply filters, etc. if (!std.mem.endsWith(u8, load_path, ".bmp") and !std.mem.endsWith(u8, load_path, ".ppm")) { - std.debug.warn("Only BMP files are allowed to be loaded. Got path '{s}'\n", .{load_path}); + log.debug("Only BMP files are allowed to be loaded. Got path '{s}'\n", .{load_path}); return RunError.NoBMP; } @@ -115,7 +117,7 @@ pub const Runner = struct { if (self.image) |image| { return image; } else { - std.debug.warn("image is required!\n", .{}); + log.debug("image is required!\n", .{}); return RunError.ImageRequired; } } @@ -201,7 +203,7 @@ pub const Runner = struct { ); defer proc.deinit(); - std.debug.warn("running '{s} {s}'\n", .{ runqs.program, out_path }); + log.debug("running '{s} {s}'\n", .{ runqs.program, out_path }); _ = try proc.spawnAndWait(); } From 5d1bcf33ee17a39a27bf91b141d54e9bf1cfa360 Mon Sep 17 00:00:00 2001 From: Luna Date: Wed, 27 Apr 2022 20:01:12 -0300 Subject: [PATCH 4/5] fixes for latest zig: a lot of stuff --- src/custom.zig | 31 ++++++++++++++----------- src/image.zig | 24 +++++++++----------- src/lang.zig | 61 +++++++++++++++++++++++++------------------------- src/magick.zig | 1 + src/main.zig | 8 +++---- src/plugin.zig | 8 ++++--- src/runner.zig | 22 +++++++++--------- 7 files changed, 80 insertions(+), 75 deletions(-) diff --git a/src/custom.zig b/src/custom.zig index 401b39f..4e48d6a 100644 --- a/src/custom.zig +++ b/src/custom.zig @@ -12,11 +12,11 @@ const RunBuffers = plugins.RunBuffers; pub const RandomNoise = struct { r: std.rand.DefaultPrng, rand_buf: ?[]f32 = null, - allocator: ?*std.mem.Allocator = null, + allocator: ?std.mem.Allocator = null, cnt: usize = 0, pub fn init( - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, params: anytype, ) ?RandomNoise { var r = std.rand.DefaultPrng.init(params.seed); @@ -25,7 +25,7 @@ pub const RandomNoise = struct { var rand_buf = allocator.alloc(f32, params.fill_bytes) catch return null; for (rand_buf) |_, idx| { - rand_buf[idx] = r.random.float(f32); + rand_buf[idx] = r.random().float(f32); } return RandomNoise{ @@ -52,7 +52,7 @@ pub const RandomNoise = struct { bufs.out[0] = rand_buf[self.cnt]; self.cnt += 1; } else { - bufs.out[0] = self.r.random.float(f32); + bufs.out[0] = self.r.random().float(f32); } } }; @@ -60,11 +60,11 @@ pub const RandomNoise = struct { pub const WildNoise = struct { r: std.rand.DefaultPrng, rand_buf: ?[]f32 = null, - allocator: ?*std.mem.Allocator = null, + allocator: ?std.mem.Allocator = null, cnt: usize = 0, pub fn init( - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, params: anytype, ) ?WildNoise { var r = std.rand.DefaultPrng.init(params.seed); @@ -73,7 +73,7 @@ pub const WildNoise = struct { var rand_buf = allocator.alloc(f32, params.fill_bytes) catch return null; for (rand_buf) |_, idx| { - rand_buf[idx] = @intToFloat(f32, r.random.int(u1)); + rand_buf[idx] = @intToFloat(f32, r.random().int(u1)); } return WildNoise{ @@ -99,7 +99,7 @@ pub const WildNoise = struct { bufs.out[0] = rand_buf[self.cnt]; self.cnt += 1; } else { - bufs.out[0] = @intToFloat(f32, self.r.random.int(u1)); + bufs.out[0] = @intToFloat(f32, self.r.random().int(u1)); } } }; @@ -112,15 +112,18 @@ pub const Write = struct { data: f32, pub fn init( - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, params: anytype, ) Write { + _ = allocator; return Write{ .data = params.data, }; } - pub fn deinit(self: *Write) void {} + pub fn deinit(self: *Write) void { + _ = self; + } pub fn run(self: *Write, bufs: *RunBuffers) void { bufs.out[0] = self.data; @@ -128,13 +131,13 @@ pub const Write = struct { }; pub const Embed = struct { - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, filepath: []const u8, sndfile: *c.SNDFILE = undefined, buf: []f32 = undefined, - pub fn init(allocator: *std.mem.Allocator, params: anytype) @This() { + pub fn init(allocator: std.mem.Allocator, params: anytype) @This() { return Embed{ .allocator = allocator, .filepath = params.path, @@ -163,7 +166,9 @@ pub const Embed = struct { self.buf = try self.allocator.alloc(f32, @intCast(usize, in_fmt.channels)); } - pub fn deinit(self: *@This()) void {} + pub fn deinit(self: *@This()) void { + _ = self; + } pub fn run(self: *@This(), bufs: *RunBuffers) void { const read_bytes = c.sf_readf_float(self.sndfile, self.buf.ptr, 1); diff --git a/src/image.zig b/src/image.zig index 4a01845..073ffc4 100644 --- a/src/image.zig +++ b/src/image.zig @@ -21,7 +21,7 @@ pub const ImageError = error{ /// Low level integration function with libsndfile. pub fn sopen( - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, path: []const u8, mode: i32, fmt: *c.SF_INFO, @@ -43,10 +43,10 @@ pub fn sopen( const frames_on_end = c.sf_seek(file, 0, c.SEEK_END); _ = c.sf_seek(file, 0, c.SEEK_SET); - std.testing.expectEqual(fmt.frames, frames_on_end); + try std.testing.expectEqual(fmt.frames, frames_on_end); const frames_on_end_by_end = c.sf_seek(file, frames_on_end, c.SEEK_SET); - std.testing.expectEqual(frames_on_end, frames_on_end_by_end); + try std.testing.expectEqual(frames_on_end, frames_on_end_by_end); log.debug("frames on end: {}, frame on end (2): {}\n", .{ frames_on_end, frames_on_end_by_end }); @@ -66,7 +66,7 @@ pub fn sseek(file: *c.SNDFILE, offset: usize) void { const offset_i64 = @intCast(i64, offset); const frames = c.sf_seek(file, offset_i64, c.SEEK_SET); const frames_current = c.sf_seek(file, 0, c.SEEK_CUR); - std.testing.expectEqual(frames, frames_current); + std.debug.assert(frames == frames_current); if (frames != offset_i64) { log.debug("failed to seek to {} (seeked {} frames, offset_i64={})\n", .{ offset, frames, offset_i64 }); @@ -74,7 +74,7 @@ pub fn sseek(file: *c.SNDFILE, offset: usize) void { } /// Caller owns the returned memory. -pub fn temporaryName(allocator: *std.mem.Allocator) ![]u8 { +pub fn temporaryName(allocator: std.mem.Allocator) ![]u8 { const template_start = "/temp/temp_"; const template = "/tmp/temp_XXXXXXXXXXXXXXXXXXXXX"; var nam = try allocator.alloc(u8, template.len); @@ -89,7 +89,7 @@ pub fn temporaryName(allocator: *std.mem.Allocator) ![]u8 { while (i < 100) : (i += 1) { // generate a random uppercase letter, that is, 65 + random number. for (fill) |_, f_idx| { - var idx = @intCast(u8, r.random.uintLessThan(u5, 24)); + var idx = @intCast(u8, r.random().uintLessThan(u5, 24)); var letter = @as(u8, 65) + idx; fill[f_idx] = letter; } @@ -97,7 +97,7 @@ pub fn temporaryName(allocator: *std.mem.Allocator) ![]u8 { // if we fail to access it, we assume it doesn't exist and return it. var tmp_file: std.fs.File = std.fs.cwd().openFile( nam, - .{ .read = true, .write = false }, + .{ .mode = .read_only }, ) catch |err| { if (err == error.FileNotFound) return nam else continue; }; @@ -122,7 +122,7 @@ pub fn mkSfInfo() c.SF_INFO { } pub const Image = struct { - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, /// Pointer to the underlying libsndfile's SNDFILE struct. sndfile: *c.SNDFILE, @@ -137,7 +137,7 @@ pub const Image = struct { curpath: []const u8, /// Open a BMP image for later. - pub fn open(allocator: *std.mem.Allocator, path: []const u8) !*Image { + pub fn open(allocator: std.mem.Allocator, path: []const u8) !*Image { var in_fmt = mkSfInfo(); var sndfile = try sopen(allocator, path, c.SFM_READ, &in_fmt); @@ -197,9 +197,7 @@ pub const Image = struct { } pub fn read(self: *Image, file_chans: c_int, buf: []f32) bool { - var file = file_opt.?; - - const n_read: c.sf_count_t = c.sf_readf_float(file, buf.ptr, 1); + const n_read: c.sf_count_t = c.sf_readf_float(self.sndfile, buf.ptr, 1); const buf_chans = @intCast(c_int, buf.len); var i = file_chans - 1; @@ -276,7 +274,7 @@ pub const Image = struct { } pub fn checkValid(self: *Image) !void { - var file = try std.fs.cwd().openFile(self.path, .{ .read = true }); + var file = try std.fs.cwd().openFile(self.path, .{ .mode = .read_only }); defer file.close(); // main bmp header: diff --git a/src/lang.zig b/src/lang.zig index 4c4f8f5..4c5973e 100644 --- a/src/lang.zig +++ b/src/lang.zig @@ -471,7 +471,7 @@ pub const CommandList = struct { list: CmdArrayList, const Self = @This(); - pub fn init(allocator: *std.mem.Allocator) Self { + pub fn init(allocator: std.mem.Allocator) Self { return .{ .list = CmdArrayList.init(allocator), }; @@ -486,13 +486,16 @@ pub const CommandList = struct { @field(Command.Tag, field.name); // if we find a match on the tag, we can get the type const typ = Command.tagToType(actual_tag); + _ = typ; - inline for (@typeInfo(typ).Struct.fields) |cmd_field| { - switch (cmd_field.field_type) { - []u8, []const u8 => self.list.allocator.destroy(@field(typ, cmd_field.name)), - else => {}, - } - } + // TODO fix + + //inline for (@typeInfo(typ).Struct.fields) |cmd_field| { + // switch (cmd_field.field_type) { + // []u8, []const u8 => self.list.allocator.destroy(@field(typ, cmd_field.name)), + // else => {}, + // } + //} } } } @@ -506,18 +509,20 @@ pub const CommandList = struct { /// A parser. pub const Lang = struct { - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, has_error: bool = false, line: usize = 0, - pub fn init(allocator: *std.mem.Allocator) Lang { + pub fn init(allocator: std.mem.Allocator) Lang { return Lang{ .allocator = allocator, }; } - pub fn deinit(self: *Lang) void {} + pub fn deinit(self: *Lang) void { + _ = self; + } pub fn reset(self: *Lang) void { self.has_error = false; @@ -534,7 +539,7 @@ pub const Lang = struct { fn parseCommandArguments( self: *@This(), comptime command_struct: type, - tok_it: *std.mem.TokenIterator, + tok_it: *std.mem.SplitIterator(u8), commands: *CommandList, ) !void { // Based on the command struct fields, we can parse the arguments. @@ -622,7 +627,7 @@ pub const Lang = struct { } pub fn parse(self: *Lang, data: []const u8) !CommandList { - var splitted_it = std.mem.split(data, ";"); + var splitted_it = std.mem.split(u8, data, ";"); var cmds = CommandList.init(self.allocator); errdefer cmds.deinit(); @@ -635,7 +640,7 @@ pub const Lang = struct { if (std.mem.startsWith(u8, stmt, "#")) continue; // TODO better tokenizer instead of just tokenize(" ")...maybe???? - var tok_it = std.mem.tokenize(stmt, " "); + var tok_it = std.mem.split(u8, stmt, " "); var cmd_opt = tok_it.next(); if (cmd_opt == null) { @@ -647,15 +652,14 @@ pub const Lang = struct { 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, - }, + const struct_name = cmd_struct_decl.name; + const cmd_struct_type = @field(Command, struct_name); + + switch (@typeInfo(@TypeOf(cmd_struct_type))) { + .Struct => {}, 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| { @@ -675,7 +679,6 @@ pub const Lang = struct { 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); } } @@ -699,8 +702,8 @@ test "noop" { var cmds = try lang.parse("noop;"); defer cmds.deinit(); - std.testing.expectEqual(cmds.list.items.len, 1); - std.testing.expectEqual(cmds.list.items[0].tag, .noop); + try std.testing.expectEqual(cmds.list.items.len, 1); + try std.testing.expectEqual(cmds.list.items[0].tag, .noop); } test "load, phaser, quicksave" { @@ -716,10 +719,10 @@ test "load, phaser, quicksave" { var cmds = try lang.parse(prog); defer cmds.deinit(); - std.testing.expectEqual(cmds.list.items.len, 3); - std.testing.expectEqual(cmds.list.items[0].tag, .load); - std.testing.expectEqual(cmds.list.items[1].tag, .phaser); - std.testing.expectEqual(cmds.list.items[2].tag, .quicksave); + try std.testing.expectEqual(cmds.list.items.len, 3); + try std.testing.expectEqual(cmds.list.items[0].tag, .load); + try std.testing.expectEqual(cmds.list.items[1].tag, .phaser); + try std.testing.expectEqual(cmds.list.items[2].tag, .quicksave); } test "load, phaser with errors, quicksave" { @@ -732,9 +735,5 @@ test "load, phaser with errors, quicksave" { \\quicksave; ; - var cmds = lang.parse(prog) catch |err| { - return; - }; - - unreachable; + try std.testing.expectError(error.ParseFail, lang.parse(prog)); } diff --git a/src/magick.zig b/src/magick.zig index 21f6d2d..c88ceba 100644 --- a/src/magick.zig +++ b/src/magick.zig @@ -29,6 +29,7 @@ pub const MagickContext = struct { } pub fn doErr(self: *MagickContext) !void { + _ = self; return error.WandError; } }; diff --git a/src/main.zig b/src/main.zig index c41d2e4..9045304 100644 --- a/src/main.zig +++ b/src/main.zig @@ -18,13 +18,13 @@ const readline = @cImport({ @cInclude("readline/history.h"); }); -fn wrapInCmdList(allocator: *std.mem.Allocator, cmd: *langs.Command) !langs.CommandList { +fn wrapInCmdList(allocator: std.mem.Allocator, cmd: *langs.Command) !langs.CommandList { var cmds = langs.CommandList.init(allocator); try cmds.append(cmd); return cmds; } -fn copyCommandToHeap(allocator: *std.mem.Allocator, command: langs.Command, comptime tag: langs.Command.Tag) !*langs.Command { +fn copyCommandToHeap(allocator: std.mem.Allocator, command: langs.Command, comptime tag: langs.Command.Tag) !*langs.Command { const CommandStruct = langs.Command.tagToType(tag); const casted = command.cast(CommandStruct).?; var heap_cmd = try allocator.create(CommandStruct); @@ -38,7 +38,7 @@ fn copyCommandToHeap(allocator: *std.mem.Allocator, command: langs.Command, comp return &heap_cmd.base; } -pub fn doRepl(allocator: *std.mem.Allocator, args_it: anytype) !void { +pub fn doRepl(allocator: std.mem.Allocator, args_it: anytype) !void { var stdout_file = std.io.getStdOut(); const stdout = &stdout_file.writer(); const scri_path = try (args_it.next(allocator) orelse @panic("expected scri path")); @@ -239,7 +239,7 @@ fn doHelp() void { log.debug("\tscritcher repl path_to_script.scri path_to_input_file.bmp\n", .{}); } -fn doRun(allocator: *std.mem.Allocator, args_it: anytype) !void { +fn doRun(allocator: std.mem.Allocator, args_it: anytype) !void { var lang = langs.Lang.init(allocator); defer lang.deinit(); diff --git a/src/plugin.zig b/src/plugin.zig index d046edb..8e88283 100644 --- a/src/plugin.zig +++ b/src/plugin.zig @@ -47,7 +47,7 @@ pub const Position = struct { /// Represents the starting context for a single plugin run. pub const Context = struct { - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, world: *c.LilvWorld, plugin: *const c.LilvPlugin, @@ -75,9 +75,11 @@ pub const RunContext = struct { instance: *c.LilvInstance, pub fn init( - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, plugin: *const c.LilvPlugin, ) !RunContext { + _ = allocator; // TODO batch RunBuffers? + var instance = c.lilv_plugin_instantiate(plugin, @as(f64, 44100), null); errdefer c.lilv_instance_free(instance); @@ -128,7 +130,7 @@ pub const RunContext = struct { } }; -pub fn makeContext(allocator: *std.mem.Allocator, plugin_uri: []const u8) !Context { +pub fn makeContext(allocator: std.mem.Allocator, plugin_uri: []const u8) !Context { const cstr_plugin_uri = try std.cstr.addNullByte(allocator, plugin_uri); defer allocator.free(cstr_plugin_uri); diff --git a/src/runner.zig b/src/runner.zig index 40684a3..eb41231 100644 --- a/src/runner.zig +++ b/src/runner.zig @@ -20,7 +20,7 @@ pub const RunError = error{ }; pub const Runner = struct { - allocator: *std.mem.Allocator, + allocator: std.mem.Allocator, /// The currently opened image in the runner image: ?*Image = null, @@ -30,7 +30,7 @@ pub const Runner = struct { args: []const [:0]u8, - pub fn init(allocator: *std.mem.Allocator, repl: bool) Runner { + pub fn init(allocator: std.mem.Allocator, repl: bool) Runner { return Runner{ .allocator = allocator, .repl = repl, @@ -164,6 +164,8 @@ pub const Runner = struct { // if N isn't a number, we just ignore that file const idx_str = entry.name[entry_gidx + 2 .. entry_pidx]; const idx = std.fmt.parseInt(usize, idx_str, 10) catch |err| { + log.debug("ignoring file {s}", .{@errorName(err)}); + break :blk {}; }; @@ -254,7 +256,7 @@ pub const Runner = struct { cmd: lang.Command, comptime tag: lang.Command.Tag, ) !void { - comptime const typ = lang.Command.tagToType(tag); + const typ = lang.Command.tagToType(tag); const command = cmd.cast(typ).?; const ctype = typ.command_type; switch (ctype) { @@ -315,6 +317,7 @@ pub const Runner = struct { cmds: lang.CommandList, debug_flag: bool, ) !void { + _ = debug_flag; for (cmds.list.items) |cmd| { cmd.print(); try self.runCommand(cmd.*); @@ -323,18 +326,15 @@ pub const Runner = struct { }; test "running noop" { - const allocator = std.heap.direct_allocator; + const allocator = std.testing.allocator; var cmds = lang.CommandList.init(allocator); defer cmds.deinit(); - var cmd_ptr = try allocator.create(lang.Command); - cmd_ptr.* = lang.Command{ - .command = .Noop, - .args = lang.ArgList.init(allocator), - }; - try cmds.append(cmd_ptr); + var command = lang.Command{ .tag = .noop }; + var noop = lang.Command.Noop{ .base = command }; + try cmds.append(&noop.base); - var runner = Runner.init(allocator); + var runner = Runner.init(allocator, false); defer runner.deinit(); try runner.runCommands(cmds, false); From 1987c4d497d479fe81367fa7bef9c7768518a40d Mon Sep 17 00:00:00 2001 From: Luna Date: Wed, 27 Apr 2022 20:01:14 -0300 Subject: [PATCH 5/5] fix command parsing --- src/lang.zig | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/src/lang.zig b/src/lang.zig index 4c5973e..98b1e77 100644 --- a/src/lang.zig +++ b/src/lang.zig @@ -479,7 +479,7 @@ pub const CommandList = struct { pub fn deinit(self: *Self) void { for (self.list.items) |cmd_ptr| { - self.list.allocator.destroy(cmd_ptr); + //self.list.allocator.destroy(cmd_ptr); inline for (@typeInfo(Command.Tag).Enum.fields) |field| { if (cmd_ptr.tag == @field(Command.Tag, field.name)) { const actual_tag = @@ -530,9 +530,9 @@ pub const Lang = struct { } fn doError(self: *Lang, comptime fmt: []const u8, args: anytype) void { - log.debug("ERROR! at line {}: ", .{self.line}); - log.debug(fmt, args); - log.debug("\n", .{}); + log.err("ERROR! at line {}: ", .{self.line}); + log.err(fmt, args); + log.err("\n", .{}); self.has_error = true; } @@ -655,7 +655,16 @@ pub const Lang = struct { const struct_name = cmd_struct_decl.name; const cmd_struct_type = @field(Command, struct_name); - switch (@typeInfo(@TypeOf(cmd_struct_type))) { + const info_of_info = @typeInfo(@TypeOf(cmd_struct_type)); + + switch (info_of_info) { + .Type => {}, + else => continue, + } + + const info = @typeInfo(cmd_struct_type); + + switch (info) { .Struct => {}, else => continue, } @@ -677,7 +686,7 @@ pub const Lang = struct { // Attempting to use ComptimeHashMap hits compiler bugs and I'm // not sure if we can map strings to *types* in it. - if (std.mem.eql(u8, &lowered_command_name, command_string)) { + if ((!found) and std.mem.eql(u8, &lowered_command_name, command_string)) { found = true; try self.parseCommandArguments(cmd_struct_type, &tok_it, &cmds); }