src/lang.zig

@@ -135,9 +135,6 @@ pub const Lang = struct {
     allocator: *std.mem.Allocator,
     keywords: KeywordMap,
 
-    has_error: bool = false,
-    line: usize = 0,
-
     pub fn init(allocator: *std.mem.Allocator) Lang {
         return Lang{
             .allocator = allocator,
@@ -290,20 +287,14 @@ pub const Lang = struct {
         }
     }
 
-    fn doError(self: *Lang, comptime fmt: []const u8, args: ...) void {
-        std.debug.warn("error at line {}: ", self.line);
-        std.debug.warn(fmt, args);
-        std.debug.warn("\n");
-        self.has_error = true;
-    }
-
     pub fn parse(self: *Lang, data: []const u8) !CommandList {
         var splitted_it = std.mem.separate(data, ";");
         try self.fillKeywords();
         var cmds = CommandList.init(self.allocator);
+        var idx: usize = 0;
+        var has_error = false;
 
         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");
 
@@ -314,10 +305,7 @@ pub const Lang = struct {
             var tok_it = std.mem.tokenize(stmt, " ");
 
             var cmd_opt = tok_it.next();
-            if (cmd_opt == null) {
+            if (cmd_opt == null) return ParseError.NoCommandGiven;
-                self.doError("No command given");
-                continue;
-            }
             var command = cmd_opt.?;
 
             var ctype_opt = self.getCommand(command);
@@ -325,8 +313,8 @@ pub const Lang = struct {
             if (ctype_opt) |ctype_val| {
                 ctype = ctype_val;
             } else {
-                self.doError("Unknown command '{}' ({})", command, command.len);
+                std.debug.warn("Unknown command: '{}' ({})\n", command, command.len);
-                continue;
+                return ParseError.UnknownCommand;
             }
 
             var args = ArgList.init(self.allocator);
@@ -340,14 +328,15 @@ pub const Lang = struct {
 
             cmd_ptr.* = Command{ .command = ctype, .args = args };
             self.validateCommand(cmd_ptr) catch |err| {
-                self.doError("Unknown command '{}' (length {})", command, command.len);
+                std.debug.warn("error at line {}: {}\n", idx, err);
-                continue;
+                has_error = true;
             };
 
             try cmds.append(cmd_ptr);
+            idx += 1;
         }
 
-        if (self.has_error) return ParseError.ParseFail;
+        if (has_error) return ParseError.ParseFail;
 
         return cmds;
     }

src/runner.zig

@@ -65,7 +65,7 @@ pub const Runner = struct {
 
     fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void {
         var load_path = try self.resolveArgPath(path_or_argidx);
-        std.debug.warn("\tload path: {}\n", load_path);
+        std.debug.warn("load path: {}\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.