mvp treewalk interpreter

build.zig

@@ -19,7 +19,9 @@ pub fn build(b: *std.Build) void {
             .root_source_file = b.path("src/main.zig"),
             .target = target,
             .optimize = optimize,
-            .imports = &.{.{ .name = "libneon", .module = lib.root_module }},
+            .imports = &.{
+                .{ .name = "libneon", .module = lib.root_module },
+            },
         }),
     });
 
@@ -40,7 +42,9 @@ pub fn build(b: *std.Build) void {
             .root_source_file = b.path("tests/all.zig"),
             .target = target,
             .optimize = optimize,
-            .imports = &.{.{ .name = "libneon", .module = lib.root_module }},
+            .imports = &.{
+                .{ .name = "libneon", .module = lib.root_module },
+            },
         }),
     });
 

examples/first.ne

@@ -1,14 +1,3 @@
-(func print_fibs [limit] {
-    (let a 1)
-    (let b 1)
-
-    (while (< a limit) {
-        (printf "%d\n" a)
-        (set b (+ b a))
-        (set a (- b a))
-    })
-})
-
 (func main [] {
-    (print_fibs 100)
+    (print_int (+ 1 (* 2 34)))
 })

lib/interpreter.zig

@@ -0,0 +1,83 @@
+const std = @import("std");
+
+const parser = @import("parser.zig");
+
+pub const Interpreter = struct {
+    stdout: *std.Io.Writer,
+
+    pub fn interpret(self: @This(), program: parser.Program) !void {
+        const main = for (program.funcs) |func| {
+            if (std.mem.eql(u8, func.name, "main")) break func;
+        } else return error.NoMain;
+
+        try self.run_func(main);
+        try self.stdout.flush();
+    }
+
+    fn run_func(self: @This(), func: parser.Func) !void {
+        for (func.body) |stmt| {
+            try self.run_stmt(stmt);
+        }
+    }
+
+    fn run_stmt(self: @This(), stmt: parser.Stmt) !void {
+        switch (stmt) {
+            .expr => |expr| {
+                const val = try self.evaluate(expr);
+                if (val != .nil) {
+                    try self.stdout.print("{any}\n", .{val});
+                }
+            },
+            else => {
+                std.debug.print("unimplemented run for '{t}' stmt\n", .{stmt});
+                return error.Todo;
+            },
+        }
+    }
+
+    fn evaluate(self: @This(), expr: parser.Expr) !Value {
+        switch (expr) {
+            .nil => return .nil,
+            .variable => |val| {
+                std.debug.print("unimplemented variable '{s}' access\n", .{val});
+                return error.Todo;
+            },
+            .integer => |val| return .{ .integer = @intCast(val) },
+            .string => |val| return .{ .string = val },
+            .func_call => |call| {
+                if (std.mem.eql(u8, call.name, "+")) {
+                    var result: i64 = 0;
+                    for (call.args) |arg| {
+                        const val = try self.evaluate(arg);
+                        if (val != .integer) return error.InvalidArg;
+                        result += val.integer;
+                    }
+                    return .{ .integer = result };
+                } else if (std.mem.eql(u8, call.name, "*")) {
+                    var result: i64 = 1;
+                    for (call.args) |arg| {
+                        const val = try self.evaluate(arg);
+                        if (val != .integer) return error.InvalidArg;
+                        result *= val.integer;
+                    }
+                    return .{ .integer = result };
+                } else if (std.mem.eql(u8, call.name, "print_int")) {
+                    if (call.args.len != 1) return error.InvalidArg;
+                    const arg = try self.evaluate(call.args[0]);
+                    if (arg != .integer) return error.InvalidArg;
+                    try self.stdout.print("{d}\n", .{arg.integer});
+                    return .nil;
+                } else {
+                    std.debug.print("unimplemented call to '{s}'\n", .{call.name});
+                    return error.Todo;
+                }
+            },
+        }
+    }
+};
+
+const Value = union(enum) {
+    nil,
+    integer: i64,
+    string: []const u8,
+};

lib/lexer.zig

@@ -11,7 +11,7 @@ pub const Token = union(enum) {
     identifier: []const u8,
     string: []const u8,
 
-    pub fn format(self: @This(), w: *std.Io.Writer) !void {
+    pub fn format(self: @This(), w: *std.Io.Writer) error{WriteFailed}!void {
         try switch (self) {
             .lparen => w.print("lparen", .{}),
             .rparen => w.print("rparen", .{}),
@@ -26,7 +26,7 @@ pub const Token = union(enum) {
     }
 };
 
-pub fn lex(gpa: std.mem.Allocator, src: []const u8) ![]const Token {
+pub fn lex(gpa: std.mem.Allocator, src: []const u8) error{ OutOfMemory, Overflow, InvalidCharacter }![]const Token {
     var result = std.ArrayList(Token).empty;
     var idx: usize = 0;
     while (idx < src.len) {
@@ -51,11 +51,30 @@ pub fn lex(gpa: std.mem.Allocator, src: []const u8) ![]const Token {
                 idx -= 1;
                 break :sw .{ .integer = int };
             },
-            'A'...'Z', 'a'...'z', '!', '$'...'\'', '*'...'/', ':'...'@', '^', '_', '~' => {
+            'A'...'Z',
+            'a'...'z',
+            '!',
+            '$'...'\'',
+            '*'...'/',
+            ':'...'@',
+            '^',
+            '_',
+            '~',
+            => {
                 const start = idx;
                 while (idx < src.len) {
                     switch (src[idx]) {
-                        'A'...'Z', 'a'...'z', '0'...'9', '!', '$'...'\'', '*'...'/', ':'...'@', '^', '_', '~' => {
+                        'A'...'Z',
+                        'a'...'z',
+                        '0'...'9',
+                        '!',
+                        '$'...'\'',
+                        '*'...'/',
+                        ':'...'@',
+                        '^',
+                        '_',
+                        '~',
+                        => {
                             idx += 1;
                         },
                         else => break,

lib/parser.zig

@@ -1,49 +1,16 @@
 const std = @import("std");
 const lexer = @import("lexer.zig");
 
-pub const SExpr = union(enum) {
+const SExpr = union(enum) {
     integer: u64, // 42
     identifier: []const u8, // module.name
     string: []const u8, // "foo bar"
     call: []const SExpr, // (+ 1 2 3)
     block: []const SExpr, // { (print "hi") }
     list: []const SExpr, // [1 2 3]
-
-    fn format_(self: @This(), w: *std.Io.Writer, depth: usize) !void {
-        for (0..depth) |_| {
-            try w.print("  ", .{});
-        }
-        switch (self) {
-            .integer => |int| try w.print("int: {d}\n", .{int}),
-            .identifier => |id| try w.print("id: {s}\n", .{id}),
-            .string => |str| try w.print("str: {s}\n", .{str}),
-            .call => |call| {
-                try w.print("call: {s}\n", .{if (call.len == 0) "()" else ""});
-                for (call) |expr| {
-                    try expr.format_(w, depth + 1);
-                }
-            },
-            .block => |block| {
-                try w.print("block: {s}\n", .{if (block.len == 0) "{}" else ""});
-                for (block) |expr| {
-                    try expr.format_(w, depth + 1);
-                }
-            },
-            .list => |list| {
-                try w.print("list: {s}\n", .{if (list.len == 0) "[]" else ""});
-                for (list) |expr| {
-                    try expr.format_(w, depth + 1);
-                }
-            },
-        }
-    }
-
-    pub fn format(self: @This(), w: *std.Io.Writer) !void {
-        try self.format_(w, 0);
-    }
 };
 
-fn parse_expr(gpa: std.mem.Allocator, tokens: []const lexer.Token) !struct { SExpr, usize } {
+fn parse_sexpr(gpa: std.mem.Allocator, tokens: []const lexer.Token) !struct { SExpr, usize } {
     if (tokens.len == 0) {
         return error.UnexpectedEOF;
     }
@@ -56,8 +23,8 @@ fn parse_expr(gpa: std.mem.Allocator, tokens: []const lexer.Token) !struct { SEx
             var call = std.ArrayList(SExpr).empty;
             var tokens_rest = tokens[1..];
             while (tokens_rest.len > 0 and tokens_rest[0] != .rparen) {
-                const expr, const consumed = try parse_expr(gpa, tokens_rest);
+                const sexpr, const consumed = try parse_sexpr(gpa, tokens_rest);
-                try call.append(gpa, expr);
+                try call.append(gpa, sexpr);
                 tokens_rest = tokens_rest[consumed..];
             }
             if (tokens_rest.len == 0) {
@@ -70,8 +37,8 @@ fn parse_expr(gpa: std.mem.Allocator, tokens: []const lexer.Token) !struct { SEx
             var block = std.ArrayList(SExpr).empty;
             var tokens_rest = tokens[1..];
             while (tokens_rest.len > 0 and tokens_rest[0] != .rbrace) {
-                const expr, const consumed = try parse_expr(gpa, tokens_rest);
+                const sexpr, const consumed = try parse_sexpr(gpa, tokens_rest);
-                try block.append(gpa, expr);
+                try block.append(gpa, sexpr);
                 tokens_rest = tokens_rest[consumed..];
             }
             if (tokens_rest.len == 0) {
@@ -84,8 +51,8 @@ fn parse_expr(gpa: std.mem.Allocator, tokens: []const lexer.Token) !struct { SEx
             var list = std.ArrayList(SExpr).empty;
             var tokens_rest = tokens[1..];
             while (tokens_rest.len > 0 and tokens_rest[0] != .rbracket) {
-                const expr, const consumed = try parse_expr(gpa, tokens_rest);
+                const sexpr, const consumed = try parse_sexpr(gpa, tokens_rest);
-                try list.append(gpa, expr);
+                try list.append(gpa, sexpr);
                 tokens_rest = tokens_rest[consumed..];
             }
             if (tokens_rest.len == 0) {
@@ -100,15 +67,163 @@ fn parse_expr(gpa: std.mem.Allocator, tokens: []const lexer.Token) !struct { SEx
     }
 }
 
-pub fn parse_sexprs(gpa: std.mem.Allocator, tokens: []const lexer.Token) ![]const SExpr {
+fn parse_sexprs(gpa: std.mem.Allocator, tokens: []const lexer.Token) ![]const SExpr {
     var result = std.ArrayList(SExpr).empty;
     var idx: usize = 0;
 
     while (idx < tokens.len) {
-        const expr, const consumed = try parse_expr(gpa, tokens[idx..]);
+        const sexpr, const consumed = try parse_sexpr(gpa, tokens[idx..]);
-        try result.append(gpa, expr);
+        try result.append(gpa, sexpr);
         idx += consumed;
     }
 
     return result.toOwnedSlice(gpa);
 }
+
+pub const Program = struct {
+    funcs: []const Func,
+};
+
+pub const Func = struct {
+    name: []const u8,
+    args: []const []const u8,
+    body: []const Stmt,
+
+    fn from(gpa: std.mem.Allocator, sexpr: SExpr) !Func {
+        if (sexpr != .call or sexpr.call.len != 4) {
+            return error.InvalidFunc;
+        }
+        const call = sexpr.call;
+        if (call[0] != .identifier or !std.mem.eql(u8, call[0].identifier, "func") or call[1] != .identifier) {
+            return error.InvalidFunc;
+        }
+        if (call[2] != .list or call[3] != .block) {
+            return error.InvalidFunc;
+        }
+        var args = std.ArrayList([]const u8).empty;
+        for (call[2].list) |arg| {
+            if (arg != .identifier) return error.InvalidFuncArg;
+            try args.append(gpa, arg.identifier);
+        }
+        var body = std.ArrayList(Stmt).empty;
+        for (call[3].block) |inner| {
+            try body.append(gpa, try Stmt.from(gpa, inner));
+        }
+        return Func{
+            .name = call[1].identifier,
+            .args = try args.toOwnedSlice(gpa),
+            .body = try body.toOwnedSlice(gpa),
+        };
+    }
+};
+
+pub const Stmt = union(enum) {
+    var_let: struct {
+        name: []const u8,
+        value: Expr,
+    },
+    var_set: struct {
+        name: []const u8,
+        value: Expr,
+    },
+    while_loop: struct {
+        cond: Expr,
+        body: []const Stmt,
+    },
+    expr: Expr,
+
+    fn from(gpa: std.mem.Allocator, sexpr: SExpr) !Stmt {
+        switch (sexpr) {
+            .call => |ss| {
+                if (ss.len == 0 or ss[0] != .identifier) {
+                    return error.InvalidCall;
+                }
+                const name = ss[0].identifier;
+                if (std.mem.eql(u8, name, "let")) {
+                    if (ss.len != 3 or ss[1] != .identifier) {
+                        return error.InvalidLet;
+                    }
+                    const var_name = ss[1].identifier;
+                    return .{ .var_let = .{
+                        .name = var_name,
+                        .value = try Expr.from(gpa, ss[2]),
+                    } };
+                } else if (std.mem.eql(u8, name, "set")) {
+                    if (ss.len != 3 or ss[1] != .identifier) {
+                        return error.InvalidSet;
+                    }
+                    const var_name = ss[1].identifier;
+                    return .{ .var_set = .{
+                        .name = var_name,
+                        .value = try Expr.from(gpa, ss[2]),
+                    } };
+                } else if (std.mem.eql(u8, name, "while")) {
+                    if (ss.len != 3 or ss[2] != .block) {
+                        return error.InvalidWhile;
+                    }
+                    const cond = try Expr.from(gpa, ss[1]);
+                    var body = std.ArrayList(Stmt).empty;
+                    for (ss[2].block) |inner| {
+                        try body.append(gpa, try Stmt.from(gpa, inner));
+                    }
+                    return .{ .while_loop = .{
+                        .cond = cond,
+                        .body = try body.toOwnedSlice(gpa),
+                    } };
+                } else {
+                    return .{ .expr = try Expr.from(gpa, sexpr) };
+                }
+            },
+            else => return .{ .expr = try Expr.from(gpa, sexpr) },
+        }
+    }
+};
+
+pub const Expr = union(enum) {
+    nil,
+    variable: []const u8,
+    integer: u64,
+    string: []const u8,
+    func_call: struct {
+        name: []const u8,
+        args: []const Expr,
+    },
+
+    fn from(gpa: std.mem.Allocator, sexpr: SExpr) !Expr {
+        switch (sexpr) {
+            .integer => |int| return .{ .integer = int },
+            .identifier => |id| {
+                if (std.mem.eql(u8, id, "nil")) {
+                    return .nil;
+                }
+                return .{ .variable = id };
+            },
+            .string => |str| return .{ .string = str },
+            .call => |ss| {
+                if (ss.len < 1 or ss[0] != .identifier) return error.InvalidCall;
+                var args = std.ArrayList(Expr).empty;
+                for (ss[1..]) |inner| {
+                    try args.append(gpa, try Expr.from(gpa, inner));
+                }
+                return .{ .func_call = .{
+                    .name = ss[0].identifier,
+                    .args = try args.toOwnedSlice(gpa),
+                } };
+            },
+            .block => return error.BlockAsExpr,
+            .list => return error.ListsNotImplemented,
+        }
+    }
+};
+
+pub fn parse(gpa: std.mem.Allocator, tokens: []const lexer.Token) !Program {
+    const sexprs = try parse_sexprs(gpa, tokens);
+    var funcs = std.ArrayList(Func).empty;
+    for (sexprs) |sexpr| {
+        const func = try Func.from(gpa, sexpr);
+        try funcs.append(gpa, func);
+    }
+    return Program{
+        .funcs = try funcs.toOwnedSlice(gpa),
+    };
+}

lib/root.zig

@@ -1,2 +1,3 @@
 pub const lexer = @import("lexer.zig");
 pub const parser = @import("parser.zig");
+pub const interpreter = @import("interpreter.zig");

src/main.zig

@@ -3,7 +3,12 @@ const std = @import("std");
 const lib = @import("libneon");
 
 fn usage(w: *std.Io.Writer, program: []const u8) error{WriteFailed}!void {
-    try w.print("Usage: {s} <input>\n", .{program});
+    try w.print(
+        \\Usage: {s} [flags] <input>
+        \\Flags:
+        \\    -h, --help    Show this help message and quit
+        \\
+    , .{program});
 }
 
 fn entry(init: struct {
@@ -16,7 +21,7 @@ fn entry(init: struct {
     var input_path: ?[]const u8 = null;
 
     for (init.args[1..]) |arg| {
-        if (std.mem.eql(u8, arg, "--help")) {
+        if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
             try usage(init.stdout, program_name);
             try init.stdout.flush();
             return;
@@ -37,16 +42,19 @@ fn entry(init: struct {
         return;
     };
 
-    const src = try std.fs.cwd().readFileAlloc(init.arena.allocator(), input_path.?, input_stat.size);
+    const src = try std.fs.cwd().readFileAlloc(
+        init.arena.allocator(),
+        input_path.?,
+        input_stat.size,
+    );
 
     const tokens = try lib.lexer.lex(init.arena.allocator(), src);
 
-    const exprs = try lib.parser.parse_sexprs(init.arena.allocator(), tokens);
+    const program = try lib.parser.parse(init.arena.allocator(), tokens);
 
-    for (exprs) |expr| {
+    const interpreter = lib.interpreter.Interpreter{ .stdout = init.stdout };
-        try init.stdout.print("{f}", .{expr});
+
-        try init.stdout.flush();
+    try interpreter.interpret(program);
-    }
 }
 
 pub fn main() !void {