src/ast.zig

@@ -3,7 +3,6 @@ const tokens = @import("tokens.zig");
 const Token = tokens.Token;
 
 pub const NodeList = std.ArrayList(*Node);
-pub const StmtList = std.ArrayList(*Stmt);
 pub const ExprList = std.ArrayList(*Expr);
 pub const ParamList = std.ArrayList(ParamDecl);
 pub const ConstList = std.ArrayList(SingleConst);
@@ -15,7 +14,6 @@ pub const NodeType = enum {
     ConstDecl,
     Block,
     Expr,
-    Stmt,
 };
 
 pub const ParamDecl = struct {
@@ -28,12 +26,14 @@ pub const ParamDecl = struct {
 pub const FnDecl = struct {
     func_name: Token,
     params: ParamList,
-    body: StmtList,
+    body: ExprList,
 };
 
 pub const SingleConst = struct {
     name: Token,
-    expr: *Expr,
+
+    // TODO expr
+    value: Token,
 };
 
 pub const BinaryExpr = struct {
@@ -61,26 +61,14 @@ pub const Expr = union(enum) {
     Grouping: *Expr,
 };
 
-pub const Stmt = union(enum) {
-    Expr: *Expr,
-    Println: *Expr,
-
-    pub fn mkPrintln(allocator: *std.mem.Allocator, expr: *Expr) !*Stmt {
-        var println = try allocator.create(Stmt);
-        println.* = Stmt{ .Println = expr };
-        return println;
-    }
-};
-
 pub const Node = union(NodeType) {
     Root: NodeList,
     FnDecl: FnDecl,
     ConstDecl: ConstList,
 
-    Block: StmtList,
+    // TODO StmtList
-
+    Block: ExprList,
     Expr: *Expr,
-    Stmt: *Stmt,
 };
 
 pub fn mkRoot(allocator: *std.mem.Allocator) !*Node {
@@ -115,9 +103,9 @@ pub fn printNode(node: *Node, ident: usize) void {
                 );
             }
 
-            for (decl.body.toSlice()) |stmt| {
+            for (decl.body.toSlice()) |expr| {
                 printIdent(ident + 1);
-                printStmt(stmt);
+                printExpr(expr);
                 std.debug.warn("\n");
             }
         },
@@ -127,12 +115,10 @@ pub fn printNode(node: *Node, ident: usize) void {
             for (consts.toSlice()) |const_decl| {
                 print(
                     ident + 1,
-                    "{} = ",
+                    "'{}' = '{}'\n",
                     const_decl.name.lexeme,
+                    const_decl.value.lexeme,
                 );
-
-                printExpr(const_decl.expr);
-                std.debug.warn("\n");
             }
         },
 
@@ -142,28 +128,7 @@ pub fn printNode(node: *Node, ident: usize) void {
             }
         },
 
-        .Expr => |expr| {
+        .Expr => |expr| printExpr(expr),
-            printIdent(ident);
-            printExpr(expr);
-            std.debug.warn("\n");
-        },
-
-        .Stmt => |stmt| blk: {
-            switch (stmt.*) {
-                .Println => |expr| blk2: {
-                    printIdent(ident);
-                    std.debug.warn("println(");
-                    printExpr(expr);
-                    std.debug.warn("\n");
-                },
-
-                .Expr => |expr| {
-                    printIdent(ident);
-                    printExpr(expr);
-                    std.debug.warn("\n");
-                },
-            }
-        },
 
         else => {
             print(ident, "unknown node: {}\n", node);
@@ -200,10 +165,3 @@ pub fn printExpr(expr: *Expr) void {
         else => std.debug.warn("unknown"),
     }
 }
-
-pub fn printStmt(stmt: *Stmt) void {
-    switch (stmt.*) {
-        .Println => |expr| parenthetize("println", &[_]*Expr{expr}),
-        .Expr => |expr| printExpr(expr),
-    }
-}

src/parser.zig

@@ -13,7 +13,6 @@ const Result = main.Result;
 
 const Node = ast.Node;
 const Expr = ast.Expr;
-const Stmt = ast.Stmt;
 
 pub const Parser = struct {
     allocator: *Allocator,
@@ -118,12 +117,14 @@ pub const Parser = struct {
         return false;
     }
 
-    fn mkFnDecl(self: *Parser, name: Token, params: ast.ParamList, block: ast.StmtList) !*ast.Node {
+    fn mkFnDecl(self: *Parser, name: Token, params: ast.ParamList, block: ast.ExprList) !*ast.Node {
         var node = try self.allocator.create(Node);
         node.* = Node{
             .FnDecl = ast.FnDecl{
                 .func_name = name,
                 .params = params,
+
+                // TODO stmt
                 .body = block,
             },
         };
@@ -136,9 +137,9 @@ pub const Parser = struct {
         return node;
     }
 
-    fn mkBlock(self: *Parser, stmts: ast.StmtList) !*ast.Node {
+    fn mkBlock(self: *Parser, exprs: ast.ExprList) !*ast.Node {
         var node = try self.allocator.create(Node);
-        node.* = Node{ .Block = stmts };
+        node.* = Node{ .Block = exprs };
         return node;
     }
 
@@ -148,18 +149,6 @@ pub const Parser = struct {
         return node;
     }
 
-    fn mkStmt(self: *Parser, stmt: *Stmt) !*ast.Node {
-        var node = try self.allocator.create(Node);
-        node.* = Node{ .Stmt = stmt };
-        return node;
-    }
-
-    fn mkStmtExpr(self: *Parser, expr: *Expr) !*Stmt {
-        var stmt = try self.allocator.create(Stmt);
-        stmt.* = Stmt{ .Expr = expr };
-        return stmt;
-    }
-
     fn mkGrouping(self: *Parser, expr: *Expr) !*ast.Expr {
         var grouping = try self.allocator.create(Expr);
         grouping.* = Expr{ .Grouping = expr };
@@ -345,14 +334,12 @@ pub const Parser = struct {
             const const_name = try self.consumeSingle(.Identifier);
             _ = try self.consumeSingle(.Equal);
 
-            var expr = try self.parseExpr();
+            // TODO expr
-            // _ = try self.nextToken();
+            const const_value = self.peek();
+            _ = try self.nextToken();
             //const const_value = try self.consumeSingle(.Identifier);
 
-            try consts.append(ast.SingleConst{
+            try consts.append(ast.SingleConst{ .name = const_name, .value = const_value });
-                .name = const_name,
-                .expr = expr.Expr,
-            });
         }
 
         _ = try self.consumeSingle(.RightParen);
@@ -373,42 +360,20 @@ pub const Parser = struct {
     }
 
     fn parseBlock(self: *@This()) !*Node {
-        var stmts = ast.StmtList.init(self.allocator);
+        var exprs = ast.ExprList.init(self.allocator);
-        errdefer stmts.deinit();
+        errdefer exprs.deinit();
 
         _ = try self.consumeSingle(.LeftBrace);
 
         while (self.peek().ttype != .RightBrace) {
-            var node = try self.parseStmt();
+            var node = try self.parseExpr();
             ast.printNode(node, 0);
-            try stmts.append(node.Stmt);
+            try exprs.append(node.Expr);
+            //_ = try self.nextToken();
         }
-
         _ = try self.consumeSingle(.RightBrace);
 
-        return try self.mkBlock(stmts);
+        return try self.mkBlock(exprs);
-    }
-
-    fn parseStmt(self: *@This()) anyerror!*Node {
-        var stmt = switch (self.peek().ttype) {
-            .Println => try self.parsePrintln(),
-
-            // TODO make newlines tokens and consume newline?
-            else => try self.parseStmtExpr(),
-        };
-
-        return try self.mkStmt(stmt);
-    }
-
-    fn parsePrintln(self: *@This()) !*Stmt {
-        _ = try self.consumeSingle(.Println);
-        var expr = try self.parseExpr();
-        return try Stmt.mkPrintln(self.allocator, expr.Expr);
-    }
-
-    fn parseStmtExpr(self: *@This()) !*Stmt {
-        var expr = (try self.parseExpr()).Expr;
-        return try self.mkStmtExpr(expr);
     }
 
     fn parseExpr(self: *@This()) anyerror!*Node {

src/scanner.zig

@@ -49,7 +49,6 @@ const keywords = [_][]const u8{
     "true",
     "false",
     "None",
-    "println",
 };
 
 const keyword_ttypes = [_]TokenType{
@@ -77,7 +76,6 @@ const keyword_ttypes = [_]TokenType{
     .True,
     .False,
     .None,
-    .Println,
 };
 
 fn getKeyword(keyword: []const u8) ?TokenType {

src/tokens.zig

@@ -71,8 +71,6 @@ pub const TokenType = enum {
     False,
     None,
 
-    Println,
-
     EOF,
 };