@nova-lang/cli 0.1.0

package/src/parser.zig

@@ -0,0 +1,1011 @@
+const std = @import("std");
+const types = @import("types.zig");
+const TokenType = types.TokenType;
+const Token = types.Token;
+const Node = types.Node;
+const AstPool = types.AstPool;
+
+pub const Parser = struct {
+    allocator: std.mem.Allocator,
+    tokens: std.ArrayList(Token),
+    pos: u32,
+    pool: *AstPool,
+
+    pub fn init(allocator: std.mem.Allocator, tokens: std.ArrayList(Token), pool: *AstPool) Parser {
+    return .{
+        .allocator = allocator,
+        .tokens = tokens,
+        .pos = 0,
+        .pool = pool,
+    };
+}
+
+fn peek(self: *Parser, offset: u32) Token {
+    const idx = self.pos + offset;
+    return if (idx < self.tokens.items.len) self.tokens.items[idx] else self.tokens.items[self.tokens.items.len - 1];
+}
+
+fn advance(self: *Parser) Token {
+    const tok = self.tokens.items[self.pos];
+    self.pos += 1;
+    return tok;
+}
+
+fn expect(self: *Parser, token_type: TokenType) !Token {
+    const tok = self.peek(0);
+    if (tok.type != token_type) {
+        std.debug.print("Expected {}, got {} ('{s}') at line {}, col {}\n", .{
+            @tagName(token_type), @tagName(tok.type), tok.value, tok.line, tok.col,
+        });
+        return error.ParseError;
+    }
+    return self.advance();
+}
+
+fn maybe(self: *Parser, token_type: TokenType) ?Token {
+    if (self.peek(0).type == token_type) {
+        return self.advance();
+    }
+    return null;
+}
+
+fn skipNewlines(self: *Parser) void {
+    while (self.peek(0).type == .newline) {
+        _ = self.advance();
+    }
+}
+
+fn skipIndentDedent(self: *Parser) void {
+    while (self.peek(0).type == .indent or self.peek(0).type == .dedent) {
+        _ = self.advance();
+    }
+}
+
+fn skipToRbrace(self: *Parser) void {
+    var depth: u32 = 1;
+    while (depth > 0 and self.peek(0).type != .eof) {
+        switch (self.peek(0).type) {
+            .lbrace => depth += 1,
+            .rbrace => depth -= 1,
+            else => {},
+        }
+        if (depth > 0) _ = self.advance();
+    }
+}
+
+pub fn parse(self: *Parser) !Node {
+    var children = std.ArrayList(Node).init(self.allocator);
+    var meta = std.StringHashMap([]const u8).init(self.allocator);
+    errdefer children.deinit();
+
+    while (self.peek(0).type != .eof) {
+        const node = try self.parseTopLevel();
+        if (node) |n| {
+            if (n.tag == .meta_block) {
+                var map = n.data.meta_block.pairs;
+                var it = map.iterator();
+                while (it.next()) |entry| {
+                    try meta.put(entry.key_ptr.*, entry.value_ptr.*);
+                }
+            } else {
+                try children.append(n);
+            }
+        }
+        self.skipNewlines();
+    }
+
+    return Node.init(.document, .{ .document = .{
+        .children = children,
+        .meta = meta,
+    } });
+}
+
+fn parseTopLevel(self: *Parser) !?Node {
+    self.skipNewlines();
+    self.skipIndentDedent();
+    const tok = self.peek(0);
+    switch (tok.type) {
+        .at => return self.parseBlock(),
+        .text => {
+            _ = self.advance();
+            return Node.init(.text, .{ .text = .{ .value = tok.value } });
+        },
+        .dash, .star => return self.parseList(false),
+        .plus => return self.parseList(true),
+        .lbracket => {
+            _ = self.advance();
+            return self.parseTableData();
+        },
+        else => {
+            _ = self.advance();
+            return null;
+        },
+    }
+}
+
+fn parseBlock(self: *Parser) !?Node {
+    _ = self.expect(.at);
+    const name = (try self.expect(.ident)).value;
+
+    if (std.mem.eql(u8, name, "def") or std.mem.eql(u8, name, "macro")) return self.parseMacroDef();
+    if (std.mem.eql(u8, name, "use")) return self.parseUse();
+    if (std.mem.eql(u8, name, "meta")) return self.parseMeta();
+    if (std.mem.eql(u8, name, "schema")) return self.parseSchema();
+    if (std.mem.eql(u8, name, "service")) return self.parseService();
+    if (std.mem.eql(u8, name, "if")) return self.parseIf();
+    if (std.mem.eql(u8, name, "for")) return self.parseFor();
+    if (std.mem.eql(u8, name, "table")) return self.parseTable();
+    if (std.mem.eql(u8, name, "ul")) return self.parseUL(false);
+    if (std.mem.eql(u8, name, "ol")) return self.parseUL(true);
+    if (std.mem.eql(u8, name, "entry")) return self.parseEntry();
+    if (std.mem.eql(u8, name, "config")) return self.parseMapping(name);
+
+    const attrs = try self.parseAttrs();
+    const inline_content = try self.parseInlineContent();
+    var children = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        children = try self.parseBlockWithChildren();
+    }
+    return Node.init(.block, .{ .block = .{
+        .name = name,
+        .attrs = attrs,
+        .inline_content = inline_content,
+        .children = children,
+    } });
+}
+
+pub fn parseBlockWithChildren(self: *Parser) !std.ArrayList(Node) {
+    _ = self.expect(.lbrace);
+    var children = std.ArrayList(Node).init(self.allocator);
+    self.skipNewlines();
+    self.skipIndentDedent();
+    while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+        self.skipNewlines();
+        self.skipIndentDedent();
+        if (self.peek(0).type == .rbrace) break;
+        const node = try self.parseTopLevel();
+        if (node) |n| try children.append(n);
+    }
+    _ = self.expect(.rbrace);
+    return children;
+}
+
+fn parseAttrs(self: *Parser) !std.StringHashMap([]const u8) {
+    var attrs = std.StringHashMap([]const u8).init(self.allocator);
+    if (self.peek(0).type != .lparen) return attrs;
+    _ = self.advance();
+    var idx: u32 = 0;
+    self.skipNewlines();
+    while (self.peek(0).type != .rparen and self.peek(0).type != .eof) {
+        self.skipNewlines();
+        if (self.peek(0).type == .rparen) break;
+        if (self.peek(0).type == .comma) {
+            _ = self.advance();
+            continue;
+        }
+
+        const key_tok = self.peek(0);
+        if (key_tok.type == .ident and self.peek(1).type == .colon) {
+            _ = self.advance();
+            _ = self.advance();
+            const val = try self.parseAttrValue();
+            try attrs.put(key_tok.value, val);
+        } else if (key_tok.type == .ident and self.peek(1).type == .equals) {
+            _ = self.advance();
+            _ = self.advance();
+            const val = try self.parseAttrValue();
+            try attrs.put(key_tok.value, val);
+        } else if (key_tok.type == .ident and (self.peek(1).type == .comma or self.peek(1).type == .rparen or self.peek(1).type == .newline)) {
+            _ = self.advance();
+            try attrs.put(key_tok.value, "true");
+        } else {
+            const val = try self.parseAttrValue();
+            var buf: [32]u8 = undefined;
+            const key = try std.fmt.bufPrint(&buf, "{}", .{idx});
+            const d = try self.pool.dupString(key);
+            try attrs.put(d, val);
+            idx += 1;
+        }
+        _ = self.maybe(.comma);
+        self.skipNewlines();
+    }
+    _ = self.expect(.rparen);
+    return attrs;
+}
+
+fn parseAttrValue(self: *Parser) ![]const u8 {
+    const tok = self.peek(0);
+    switch (tok.type) {
+        .string => return (self.advance()).value,
+        .number => return (self.advance()).value,
+        .ident => {
+            const val = (self.advance()).value;
+            if (std.mem.eql(u8, val, "true")) return val;
+            if (std.mem.eql(u8, val, "false")) return val;
+            if (std.mem.eql(u8, val, "null")) return val;
+            return val;
+        },
+        .text => return (self.advance()).value,
+        .lbracket => return self.parseArrayLiteral(),
+        .at => {
+            const inl = try self.parseInlineCommandValue();
+            return inl;
+        },
+        else => return "",
+    }
+}
+
+fn parseArrayLiteral(self: *Parser) ![]const u8 {
+    _ = self.expect(.lbracket);
+    var parts = std.ArrayList(u8).init(self.allocator);
+    defer parts.deinit();
+    try parts.append('[');
+    while (self.peek(0).type != .rbracket and self.peek(0).type != .eof) {
+        self.skipNewlines();
+        if (self.peek(0).type == .rbracket) break;
+        if (self.peek(0).type == .comma or self.peek(0).type == .indent or self.peek(0).type == .dedent) {
+            _ = self.advance();
+            try parts.append(',');
+            continue;
+        }
+        if (self.peek(0).type == .lbracket) {
+            const sub = try self.parseArrayLiteral();
+            try parts.appendSlice(sub);
+        } else {
+            const val = try self.parseAttrValue();
+            try parts.appendSlice(val);
+        }
+        _ = self.maybe(.comma);
+        self.skipNewlines();
+    }
+    while (self.peek(0).type == .indent or self.peek(0).type == .dedent) {
+        _ = self.advance();
+    }
+    _ = self.expect(.rbracket);
+    try parts.append(']');
+    return try self.pool.dupString(parts.items);
+}
+
+fn parseInlineContent(self: *Parser) !std.ArrayList(Node) {
+    var nodes = std.ArrayList(Node).init(self.allocator);
+    var text_buf = std.ArrayList(u8).init(self.allocator);
+    defer text_buf.deinit();
+    const TextTag = struct {
+        fn flush(buf: *std.ArrayList(u8), ns: *std.ArrayList(Node), pool: *AstPool) !void {
+            if (buf.items.len > 0) {
+                const val = try pool.dupString(buf.items);
+                try ns.append(Node.init(.text, .{ .text = .{ .value = val } }));
+                buf.clearRetainingCapacity();
+            }
+        }
+    };
+    while (true) {
+        const tok = self.peek(0);
+        switch (tok.type) {
+            .text, .string, .number => {
+                _ = self.advance();
+                try text_buf.appendSlice(tok.value);
+            },
+            .ident => {
+                if (self.peek(1).type == .colon) break;
+                _ = self.advance();
+                if (text_buf.items.len > 0 and text_buf.items[text_buf.items.len - 1] != 0 and std.ascii.isAlphanumeric(text_buf.items[text_buf.items.len - 1]) and tok.value.len > 0 and std.ascii.isAlphanumeric(tok.value[0])) {
+                    try text_buf.append(' ');
+                }
+                try text_buf.appendSlice(tok.value);
+            },
+            .at => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                const inl = try self.parseInlineCommand();
+                if (inl) |n| try nodes.append(n);
+            },
+            .math_inline => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                _ = self.advance();
+                try nodes.append(Node.init(.math_inline, .{ .math_inline = .{ .source = tok.value } }));
+            },
+            .math_display => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                _ = self.advance();
+                try nodes.append(Node.init(.math_display, .{ .math_display = .{ .source = tok.value } }));
+            },
+            .interp_start => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                _ = self.advance();
+                try nodes.append(Node.init(.interpolation, .{ .interpolation = .{ .expression = tok.value } }));
+            },
+            .lbrace => {
+                if (nodes.items.len > 0 and nodes.items[nodes.items.len - 1].tag == .text) {
+                    _ = self.advance();
+                    try text_buf.append('{');
+                } else break;
+            },
+            .lparen, .rparen, .lbracket, .rbracket, .equals, .dot => {
+                _ = self.advance();
+            },
+            else => break,
+        }
+    }
+    try TextTag.flush(&text_buf, &nodes, self.pool);
+    return nodes;
+}
+
+fn parseInlineCommand(self: *Parser) !?Node {
+    _ = self.expect(.at);
+    const name = (try self.expect(.ident)).value;
+    const ref_like = std.ComptimeStringMap(void, .{
+        .{ "ref", {} }, .{ "cite", {} }, .{ "label", {} },
+    });
+    if (ref_like.has(name)) return self.parseRefLikeInline(name);
+    const attrs = try self.parseAttrs();
+    var content = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        content = try self.parseInlineBracedContent();
+    }
+    return Node.init(.inline_block, .{ .inline_block = .{
+        .name = name,
+        .attrs = attrs,
+        .content = content,
+    } });
+}
+
+fn parseInlineCommandValue(self: *Parser) ![]const u8 {
+    _ = self.expect(.at);
+    const name = (try self.expect(.ident)).value;
+    _ = try self.parseAttrs();
+    if (self.peek(0).type == .lparen) _ = try self.parseAttrs();
+    var val: []const u8 = "";
+    if (self.peek(0).type == .lbrace) {
+        val = try self.parseInlineBracedString();
+    }
+    if (val.len > 0) {
+        return try std.fmt.allocPrint(self.allocator, "@{s}({s})", .{ name, val });
+    }
+    return try std.fmt.allocPrint(self.allocator, "@{s}", .{name});
+}
+
+fn parseInlineBracedString(self: *Parser) ![]const u8 {
+    _ = self.expect(.lbrace);
+    var buf = std.ArrayList(u8).init(self.allocator);
+    defer buf.deinit();
+    while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+        const tok = self.peek(0);
+        switch (tok.type) {
+            .text, .string, .number, .ident => {
+                _ = self.advance();
+                try buf.appendSlice(tok.value);
+            },
+            else => break,
+        }
+    }
+    _ = self.expect(.rbrace);
+    return try self.pool.dupString(buf.items);
+}
+
+fn parseRefLikeInline(self: *Parser, name: []const u8) !Node {
+    const key_attr = if (std.mem.eql(u8, name, "label")) "id" else "key";
+    var attrs = std.StringHashMap([]const u8).init(self.allocator);
+    if (self.peek(0).type == .lparen) {
+        _ = self.advance();
+        var parts = std.ArrayList(u8).init(self.allocator);
+        defer parts.deinit();
+        while (self.peek(0).type != .rparen and self.peek(0).type != .eof) {
+            const tok = self.peek(0);
+            switch (tok.type) {
+                .ident, .colon, .string, .number, .dot => {
+                    _ = self.advance();
+                    if (tok.value.len > 0) try parts.appendSlice(tok.value) else try parts.append(':');
+                },
+                .comma => {
+                    _ = self.advance();
+                    try parts.appendSlice(", ");
+                },
+                .newline, .indent, .dedent => {
+                    _ = self.advance();
+                },
+                else => break,
+            }
+        }
+        const combined = std.mem.trim(u8, parts.items, " ");
+        if (combined.len > 0) try attrs.put(key_attr, try self.pool.dupString(combined));
+        _ = self.expect(.rparen);
+    }
+    var content = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        content = try self.parseInlineBracedContent();
+    }
+    return Node.init(.inline_block, .{ .inline_block = .{
+        .name = name,
+        .attrs = attrs,
+        .content = content,
+    } });
+}
+
+fn parseInlineBracedContent(self: *Parser) !std.ArrayList(Node) {
+    _ = self.expect(.lbrace);
+    var nodes = std.ArrayList(Node).init(self.allocator);
+    var text_buf = std.ArrayList(u8).init(self.allocator);
+    defer text_buf.deinit();
+    const TextTag = struct {
+        fn flush(buf: *std.ArrayList(u8), ns: *std.ArrayList(Node), pool: *AstPool) !void {
+            if (buf.items.len > 0) {
+                const val = try pool.dupString(buf.items);
+                try ns.append(Node.init(.text, .{ .text = .{ .value = val } }));
+                buf.clearRetainingCapacity();
+            }
+        }
+    };
+    while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+        const tok = self.peek(0);
+        switch (tok.type) {
+            .text, .string, .number, .ident => {
+                _ = self.advance();
+                if (text_buf.items.len > 0 and text_buf.items[text_buf.items.len - 1] != 0 and std.ascii.isAlphanumeric(text_buf.items[text_buf.items.len - 1]) and tok.value.len > 0 and std.ascii.isAlphanumeric(tok.value[0])) {
+                    try text_buf.append(' ');
+                }
+                try text_buf.appendSlice(tok.value);
+            },
+            .at => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                const inl = try self.parseInlineCommand();
+                if (inl) |n| try nodes.append(n);
+            },
+            .math_inline => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                _ = self.advance();
+                try nodes.append(Node.init(.math_inline, .{ .math_inline = .{ .source = tok.value } }));
+            },
+            .interp_start => {
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                _ = self.advance();
+                try nodes.append(Node.init(.interpolation, .{ .interpolation = .{ .expression = tok.value } }));
+            },
+            .lparen, .rparen, .lbracket, .rbracket, .equals, .colon, .dot => {
+                _ = self.advance();
+                const c: u8 = if (tok.type == .lparen) '(' else if (tok.type == .rparen) ')' else if (tok.type == .lbracket) '[' else if (tok.type == .rbracket) ']' else if (tok.type == .equals) '=' else if (tok.type == .colon) ':' else if (tok.value.len > 0) tok.value[0] else ' ';
+                try text_buf.append(c);
+            },
+            .comma => {
+                _ = self.advance();
+                try TextTag.flush(&text_buf, &nodes, self.pool);
+                try nodes.append(Node.init(.text, .{ .text = .{ .value = ", " } }));
+            },
+            .newline, .indent, .dedent => {
+                _ = self.advance();
+            },
+            else => break,
+        }
+    }
+    try TextTag.flush(&text_buf, &nodes, self.pool);
+    if (self.peek(0).type == .rbrace) _ = self.advance() else self.skipToRbrace();
+    return nodes;
+}
+
+fn parseList(self: *Parser, ordered: bool) !?Node {
+    var items = std.ArrayList(Node).init(self.allocator);
+    while (self.peek(0).type == .dash or self.peek(0).type == .star or self.peek(0).type == .plus) {
+        _ = self.advance();
+        const item_nodes = try self.parseListItemContent();
+        const item = if (item_nodes.items.len == 1) item_nodes.items[0] else blk: {
+            break :blk Node.init(.block, .{ .block = .{
+                .name = "li",
+                .attrs = std.StringHashMap([]const u8).init(self.allocator),
+                .inline_content = std.ArrayList(Node).init(self.allocator),
+                .children = item_nodes,
+            } });
+        };
+        try items.append(item);
+        self.skipNewlines();
+    }
+    return Node.init(.list_block, .{ .list_block = .{
+        .ordered = ordered,
+        .items = items,
+    } });
+}
+
+fn parseUL(self: *Parser, ordered: bool) !?Node {
+    _ = try self.parseAttrs();
+    var items = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        self.skipIndentDedent();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            self.skipNewlines();
+            self.skipIndentDedent();
+            if (self.peek(0).type == .rbrace) break;
+            const tok = self.peek(0);
+            if (tok.type == .dash or tok.type == .star or (ordered and tok.type == .plus)) {
+                _ = self.advance();
+                const item_nodes = try self.parseListItemContent();
+                const item = if (item_nodes.items.len == 1) item_nodes.items[0] else blk: {
+                    break :blk Node.init(.block, .{
+                        .block = .{
+                            .name = "li",
+                            .attrs = std.StringHashMap([]const u8).init(self.allocator),
+                            .inline_content = std.ArrayList(Node).init(self.allocator),
+                            .children = item_nodes,
+                        },
+                    });
+                };
+                try items.append(item);
+            } else {
+                break;
+            }
+            self.skipNewlines();
+        }
+        self.skipToRbrace();
+        _ = self.expect(.rbrace);
+    }
+    return Node.init(.list_block, .{ .list_block = .{
+        .ordered = ordered,
+        .items = items,
+    } });
+}
+
+fn parseMapping(self: *Parser, name: []const u8) !?Node {
+    var pairs = std.StringHashMap([]const u8).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            self.skipNewlines();
+            self.skipIndentDedent();
+            if (self.peek(0).type == .rbrace) break;
+            const key_tok = self.peek(0);
+            if (key_tok.type == .ident and self.peek(1).type == .colon) {
+                _ = self.advance();
+                _ = self.advance();
+                const val = try self.parseAttrValue();
+                try pairs.put(key_tok.value, val);
+            } else if (key_tok.type == .ident and self.peek(1).type == .equals) {
+                _ = self.advance();
+                _ = self.advance();
+                const val = try self.parseAttrValue();
+                try pairs.put(key_tok.value, val);
+            } else break;
+            _ = self.maybe(.comma);
+            self.skipNewlines();
+        }
+        self.skipToRbrace();
+        _ = self.expect(.rbrace);
+    }
+    return Node.init(.block, .{ .block = .{
+        .name = name,
+        .attrs = pairs,
+        .inline_content = std.ArrayList(Node).init(self.allocator),
+        .children = std.ArrayList(Node).init(self.allocator),
+    } });
+}
+
+fn parseListItemContent(self: *Parser) !std.ArrayList(Node) {
+    var nodes = std.ArrayList(Node).init(self.allocator);
+    self.skipNewlines();
+    if (self.peek(0).type == .at) {
+        const block = try self.parseBlock();
+        if (block) |n| try nodes.append(n);
+        return nodes;
+    }
+    var text_parts = std.ArrayList(u8).init(self.allocator);
+    defer text_parts.deinit();
+    var last_was_text = false;
+    while (true) {
+        const tok = self.peek(0);
+        switch (tok.type) {
+            .text => {
+                _ = self.advance();
+                try text_parts.appendSlice(tok.value);
+                last_was_text = true;
+            },
+            .string => {
+                _ = self.advance();
+                try text_parts.appendSlice(tok.value);
+                last_was_text = false;
+            },
+            .number => {
+                _ = self.advance();
+                if (last_was_text) try text_parts.append(' ');
+                try text_parts.appendSlice(tok.value);
+                last_was_text = false;
+            },
+            .ident => {
+                _ = self.advance();
+                if (last_was_text) try text_parts.append(' ');
+                try text_parts.appendSlice(tok.value);
+                last_was_text = false;
+            },
+            .at => {
+                if (text_parts.items.len > 0) {
+                    try nodes.append(Node.init(.text, .{ .text = .{ .value = try self.pool.dupString(text_parts.items) } }));
+                    text_parts.clearRetainingCapacity();
+                }
+                const inl = try self.parseInlineCommand();
+                if (inl) |n| try nodes.append(n);
+                last_was_text = false;
+            },
+            .math_inline => {
+                if (text_parts.items.len > 0) {
+                    try nodes.append(Node.init(.text, .{ .text = .{ .value = try self.pool.dupString(text_parts.items) } }));
+                    text_parts.clearRetainingCapacity();
+                }
+                _ = self.advance();
+                try nodes.append(Node.init(.math_inline, .{ .math_inline = .{ .source = tok.value } }));
+                last_was_text = false;
+            },
+            .interp_start => {
+                if (text_parts.items.len > 0) {
+                    try nodes.append(Node.init(.text, .{ .text = .{ .value = try self.pool.dupString(text_parts.items) } }));
+                    text_parts.clearRetainingCapacity();
+                }
+                _ = self.advance();
+                try nodes.append(Node.init(.interpolation, .{ .interpolation = .{ .expression = tok.value } }));
+                last_was_text = false;
+            },
+            else => break,
+        }
+    }
+    if (text_parts.items.len > 0) {
+        try nodes.append(Node.init(.text, .{ .text = .{ .value = try self.pool.dupString(text_parts.items) } }));
+    }
+    return nodes;
+}
+
+fn parseMacroDef(self: *Parser) !?Node {
+    const name = (try self.expect(.ident)).value;
+    var params = std.ArrayList([]const u8).init(self.allocator);
+    var kwargs = std.StringHashMap([]const u8).init(self.allocator);
+    var has_block_param = false;
+    var block_param_name: []const u8 = "content";
+
+    if (self.peek(0).type == .lparen) {
+        _ = self.advance();
+        while (self.peek(0).type != .rparen and self.peek(0).type != .eof) {
+            if (self.peek(0).type == .comma) {
+                _ = self.advance();
+                continue;
+            }
+            if (self.peek(0).type == .at) {
+                _ = self.advance();
+                has_block_param = true;
+                block_param_name = (try self.expect(.ident)).value;
+            } else if (self.peek(0).type == .ident and self.peek(1).type == .colon) {
+                const key = (self.advance()).value;
+                _ = self.advance();
+                const typ = (try self.expect(.ident)).value;
+                _ = typ;
+                var default: []const u8 = "";
+                if (self.peek(0).type == .equals) {
+                    _ = self.advance();
+                    default = try self.parseAttrValue();
+                }
+                try kwargs.put(key, default);
+            } else {
+                try params.append((try self.expect(.ident)).value);
+            }
+            _ = self.maybe(.comma);
+        }
+        _ = self.expect(.rparen);
+    }
+
+    var body = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        body = try self.parseBlockWithChildren();
+    }
+    return Node.init(.macro_def, .{ .macro_def = .{
+        .name = name,
+        .params = params,
+        .kwargs = kwargs,
+        .has_block_param = has_block_param,
+        .block_param_name = block_param_name,
+        .body = body,
+    } });
+}
+
+fn parseUse(self: *Parser) !?Node {
+    const path = (try self.expect(.string)).value;
+    return Node.init(.use_block, .{ .use_block = .{ .path = path } });
+}
+
+fn parseMeta(self: *Parser) !?Node {
+    var pairs = std.StringHashMap([]const u8).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            self.skipNewlines();
+            if (self.peek(0).type == .rbrace) break;
+            const key = (try self.expect(.ident)).value;
+            _ = self.expect(.colon);
+            const val = try self.parseAttrValue();
+            try pairs.put(key, val);
+            _ = self.maybe(.comma);
+            self.skipNewlines();
+        }
+        _ = self.expect(.rbrace);
+    }
+    return Node.init(.meta_block, .{ .meta_block = .{ .pairs = pairs } });
+}
+
+fn parseEntry(self: *Parser) !?Node {
+    var attrs = std.StringHashMap([]const u8).init(self.allocator);
+    if (self.peek(0).type == .lparen) {
+        attrs = try self.parseAttrs();
+    }
+    const key = attrs.get("key") orelse "";
+    return Node.init(.biblio_entry, .{ .biblio_entry = .{
+        .key = key,
+        .attrs = attrs,
+    } });
+}
+
+fn parseSchema(self: *Parser) !?Node {
+    const name = (try self.expect(.ident)).value;
+    var fields = std.ArrayList(types.FieldDef).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            self.skipNewlines();
+            self.skipIndentDedent();
+            if (self.peek(0).type == .rbrace) break;
+            const field_name = (try self.expect(.ident)).value;
+            _ = self.expect(.colon);
+            const type_name = try self.parseTypeExpr();
+            var optional = false;
+            const opt_slice = if (self.peek(0).type == .question) blk: {
+                _ = self.advance();
+                optional = true;
+                break :blk type_name;
+            } else type_name;
+            _ = opt_slice;
+            var tag: u32 = 0;
+            if (self.peek(0).type == .at) {
+                _ = self.advance();
+                tag = try std.fmt.parseInt(u32, (try self.expect(.number)).value, 10);
+            }
+            var default: ?[]const u8 = null;
+            if (self.peek(0).type == .equals) {
+                _ = self.advance();
+                default = try self.parseAttrValue();
+            }
+            try fields.append(.{
+                .name = field_name,
+                .type_name = type_name,
+                .tag = tag,
+                .optional = optional,
+                .default = default,
+            });
+            _ = self.maybe(.comma);
+            self.skipNewlines();
+        }
+        _ = self.expect(.rbrace);
+    }
+    return Node.init(.schema_def, .{ .schema_def = .{ .name = name, .fields = fields } });
+}
+
+fn parseTypeExpr(self: *Parser) ![]const u8 {
+    var buf = std.ArrayList(u8).init(self.allocator);
+    defer buf.deinit();
+    try buf.appendSlice((try self.expect(.ident)).value);
+    if (self.peek(0).type == .lt) {
+        _ = self.advance();
+        try buf.append('<');
+        try buf.appendSlice((try self.expect(.ident)).value);
+        _ = self.expect(.gt);
+        try buf.append('>');
+    }
+    return try self.pool.dupString(buf.items);
+}
+
+fn parseService(self: *Parser) !?Node {
+    const name = (try self.expect(.ident)).value;
+    var methods = std.ArrayList(types.MethodDef).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            self.skipNewlines();
+            self.skipIndentDedent();
+            if (self.peek(0).type == .rbrace) break;
+            const method_name = (try self.expect(.ident)).value;
+            var params = std.ArrayList(struct { name: []const u8, type_name: []const u8 }).init(self.allocator);
+            if (self.peek(0).type == .lparen) {
+                _ = self.advance();
+                while (self.peek(0).type != .rparen and self.peek(0).type != .eof) {
+                    if (self.peek(0).type == .comma) { _ = self.advance(); continue; }
+                    const pname = (try self.expect(.ident)).value;
+                    _ = self.expect(.colon);
+                    const ptype = try self.parseTypeExpr();
+                    try params.append(.{ .name = pname, .type_name = ptype });
+                    _ = self.maybe(.comma);
+                }
+                _ = self.expect(.rparen);
+            }
+            var returns: ?[]const u8 = null;
+            if (self.peek(0).type == .dash and self.peek(1).type == .gt) {
+                _ = self.advance();
+                _ = self.advance();
+                returns = try self.parseTypeExpr();
+            }
+            try methods.append(.{ .name = method_name, .params = params, .returns = returns });
+            _ = self.maybe(.comma);
+            self.skipNewlines();
+        }
+        _ = self.expect(.rbrace);
+    }
+    return Node.init(.service_def, .{ .service_def = .{ .name = name, .methods = methods } });
+}
+
+fn parseIf(self: *Parser) !?Node {
+    var condition: []const u8 = "";
+    if (self.peek(0).type == .lparen) {
+        _ = self.advance();
+        var parts = std.ArrayList(u8).init(self.allocator);
+        defer parts.deinit();
+        var depth: u32 = 1;
+        while (depth > 0 and self.peek(0).type != .eof) {
+            const tok = self.peek(0);
+            if (tok.type == .lparen) depth += 1 else if (tok.type == .rparen) depth -= 1;
+            if (depth == 0) break;
+            _ = self.advance();
+            try parts.appendSlice(tok.value);
+        }
+        condition = try self.pool.dupString(std.mem.trim(u8, parts.items, " "));
+        _ = self.expect(.rparen);
+    }
+    var then_body = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) then_body = try self.parseBlockWithChildren();
+    var else_body = std.ArrayList(Node).init(self.allocator);
+    self.skipNewlines();
+    if (self.peek(0).type == .at and self.peek(1).type == .ident and std.mem.eql(u8, self.peek(1).value, "else")) {
+        _ = self.advance();
+        _ = self.advance();
+        if (self.peek(0).type == .lbrace) else_body = try self.parseBlockWithChildren();
+    }
+    return Node.init(.if_block, .{ .if_block = .{
+        .condition = condition,
+        .then_body = then_body,
+        .else_body = else_body,
+    } });
+}
+
+fn parseFor(self: *Parser) !?Node {
+    var var_name: []const u8 = "";
+    var iterable: []const u8 = "";
+    if (self.peek(0).type == .lparen) {
+        _ = self.advance();
+        var_name = (try self.expect(.ident)).value;
+        _ = self.expect(.comma);
+        iterable = (try self.expect(.ident)).value;
+        _ = self.expect(.rparen);
+    } else {
+        var_name = (try self.expect(.ident)).value;
+        if (self.peek(0).type == .ident and std.mem.eql(u8, self.peek(0).value, "in")) {
+            _ = self.advance();
+        }
+        iterable = (try self.expect(.ident)).value;
+    }
+    var body = std.ArrayList(Node).init(self.allocator);
+    if (self.peek(0).type == .lbrace) body = try self.parseBlockWithChildren();
+    return Node.init(.for_block, .{ .for_block = .{
+        .var_name = var_name,
+        .iterable = iterable,
+        .body = body,
+    } });
+}
+
+fn parseTable(self: *Parser) !?Node {
+    var attrs = try self.parseAttrs();
+    const src = attrs.get("src");
+    const caption = attrs.get("caption") orelse attrs.get("cap");
+    var headers_arr: ?std.ArrayList([]const u8) = null;
+    var rows = std.ArrayList(std.ArrayList([]const u8)).init(self.allocator);
+    var data: ?std.ArrayList(std.ArrayList([]const u8)) = null;
+
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        self.skipIndentDedent();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            self.skipNewlines();
+            self.skipIndentDedent();
+            if (self.peek(0).type == .rbrace) break;
+            if (self.peek(0).type == .at) {
+                _ = self.advance();
+                const sub_name = (try self.expect(.ident)).value;
+                const cells = try self.parseTableRowContent();
+                if (std.mem.eql(u8, sub_name, "header")) {
+                    headers_arr = cells;
+                } else if (std.mem.eql(u8, sub_name, "row")) {
+                    try rows.append(cells);
+                }
+            } else if (self.peek(0).type == .lbracket) {
+                data = try self.parseTableArrayData();
+            } else break;
+            self.skipNewlines();
+            self.skipIndentDedent();
+        }
+        self.skipToRbrace();
+        _ = self.expect(.rbrace);
+    }
+    return Node.init(.table_block, .{ .table_block = .{
+        .headers = headers_arr,
+        .rows = rows,
+        .src = src,
+        .caption = caption,
+        .data = data,
+    } });
+}
+
+fn parseTableRowContent(self: *Parser) !std.ArrayList([]const u8) {
+    var cells = std.ArrayList([]const u8).init(self.allocator);
+    if (self.peek(0).type == .lbrace) {
+        _ = self.advance();
+        self.skipNewlines();
+        while (self.peek(0).type != .rbrace and self.peek(0).type != .eof) {
+            if (self.peek(0).type == .comma) { _ = self.advance(); continue; }
+            if (self.peek(0).type == .newline) { _ = self.advance(); continue; }
+            if (self.peek(0).type == .indent or self.peek(0).type == .dedent) { _ = self.advance(); continue; }
+            const val = try self.parseAttrValue();
+            try cells.append(if (val.len > 0) val else "");
+            _ = self.maybe(.comma);
+        }
+        self.skipToRbrace();
+        _ = self.expect(.rbrace);
+    } else {
+        var cell_text = std.ArrayList(u8).init(self.allocator);
+        defer cell_text.deinit();
+        while (true) {
+            const tok = self.peek(0);
+            if (tok.type == .newline or tok.type == .rbrace or tok.type == .dedent or tok.type == .indent or tok.type == .eof) break;
+            if (tok.type == .comma) {
+                _ = self.advance();
+                try cells.append(try self.pool.dupString(std.mem.trim(u8, cell_text.items, " ")));
+                cell_text.clearRetainingCapacity();
+            } else if (tok.type == .text or tok.type == .string or tok.type == .number or tok.type == .ident) {
+                _ = self.advance();
+                try cell_text.appendSlice(tok.value);
+            } else break;
+        }
+        if (cell_text.items.len > 0) try cells.append(try self.pool.dupString(std.mem.trim(u8, cell_text.items, " ")));
+    }
+    return cells;
+}
+
+fn parseTableData(self: *Parser) !?Node {
+    _ = self.advance();
+    const data = try self.parseTableArrayData2();
+    return Node.init(.table_block, .{ .table_block = .{
+        .headers = null,
+        .rows = std.ArrayList(std.ArrayList([]const u8)).init(self.allocator),
+        .src = null,
+        .caption = null,
+        .data = data,
+    } });
+}
+
+fn parseTableArrayData(self: *Parser) !std.ArrayList(std.ArrayList([]const u8)) {
+    var data = std.ArrayList(std.ArrayList([]const u8)).init(self.allocator);
+    while (self.peek(0).type == .lbracket) {
+        try data.append(try self.parseTableRowContent());
+    }
+    return data;
+}
+
+fn parseTableArrayData2(self: *Parser) !std.ArrayList(std.ArrayList([]const u8)) {
+    var data = std.ArrayList(std.ArrayList([]const u8)).init(self.allocator);
+    _ = self.expect(.lbracket);
+    while (self.peek(0).type != .rbracket and self.peek(0).type != .eof) {
+        self.skipNewlines();
+        if (self.peek(0).type == .rbracket) break;
+        if (self.peek(0).type == .lbracket) {
+            const row = try self.parseTableRowContent();
+            try data.append(row);
+        } else break;
+        _ = self.maybe(.comma);
+        self.skipNewlines();
+    }
+    _ = self.expect(.rbracket);
+    return data;
+}
+};