@nova-lang/cli 0.1.2 → 0.2.0

package/src/lexer.zig

@@ -1,400 +0,0 @@
-const std = @import("std");
-const types = @import("types.zig");
-const TokenType = types.TokenType;
-const Token = types.Token;
-
-const ESCAPE_MAP = std.ComptimeStringMap(u8, .{
-    .{ "n", '\n' }, .{ "t", '\t' }, .{ "r", '\r' },
-    .{ "\"", '"' }, .{ "'", '\'' }, .{ "\\", '\\' },
-    .{ "#", '#' }, .{ "$", '$' },
-});
-
-const INDENT_WIDTH: u32 = 2;
-
-pub const Lexer = struct {
-    allocator: std.mem.Allocator,
-    source: []const u8,
-    pos: u32,
-    line: u32,
-    col: u32,
-    tokens: std.ArrayList(Token),
-    indent_stack: std.ArrayList(u32),
-    line_start: bool,
-
-    pub fn init(allocator: std.mem.Allocator, source: []const u8) Lexer {
-        var stack = std.ArrayList(u32).init(allocator);
-        stack.append(0) catch {};
-        return .{
-            .allocator = allocator,
-            .source = source,
-            .pos = 0,
-            .line = 1,
-            .col = 1,
-            .tokens = std.ArrayList(Token).init(allocator),
-            .indent_stack = stack,
-            .line_start = true,
-        };
-    }
-
-    pub fn deinit(self: *Lexer) void {
-        self.tokens.deinit();
-        self.indent_stack.deinit();
-    }
-
-    pub fn getTokens(self: *Lexer) !std.ArrayList(Token) {
-        try self.tokenize();
-        return self.tokens;
-    }
-
-    fn peek(self: *Lexer, offset: u32) u8 {
-        const idx = self.pos + offset;
-        return if (idx < self.source.len) self.source[idx] else 0;
-    }
-
-    fn advance(self: *Lexer) u8 {
-        const ch = self.source[self.pos];
-        self.pos += 1;
-        if (ch == '\n') {
-            self.line += 1;
-            self.col = 1;
-        } else {
-            self.col += 1;
-        }
-        return ch;
-    }
-
-    fn syntaxError(self: *Lexer, msg: []const u8) !void {
-        std.debug.print("SyntaxError: {s} at line {}, col {}\n", .{ msg, self.line, self.col });
-        return error.SyntaxError;
-    }
-
-    fn emit(self: *Lexer, token_type: TokenType, value: []const u8) !void {
-        try self.tokens.append(.{
-            .type = token_type,
-            .value = value,
-            .line = self.line,
-            .col = self.col,
-        });
-    }
-
-    fn skipComment(self: *Lexer) !void {
-        if (self.peek(0) != '/') return;
-        self.pos += 1;
-        if (self.peek(0) == '/') {
-            self.pos += 1;
-            while (self.pos < self.source.len and self.source[self.pos] != '\n') {
-                self.pos += 1;
-            }
-        } else if (self.peek(0) == '*') {
-            self.pos += 1;
-            var depth: u32 = 1;
-            while (depth > 0 and self.pos < self.source.len) {
-                if (self.peek(0) == '/' and self.peek(1) == '*') {
-                    self.pos += 2;
-                    depth += 1;
-                } else if (self.peek(0) == '*' and self.peek(1) == '/') {
-                    self.pos += 2;
-                    depth -= 1;
-                } else {
-                    self.pos += 1;
-                }
-            }
-        } else {
-            self.pos -= 1;
-        }
-    }
-
-    fn readString(self: *Lexer, quote: u8) ![]const u8 {
-        var buf = std.ArrayList(u8).init(self.allocator);
-        defer buf.deinit();
-        while (self.pos < self.source.len) {
-            const ch = self.advance();
-            if (ch == '\\') {
-                if (self.pos < self.source.len) {
-                    const next = self.advance();
-                    const escaped = ESCAPE_MAP.get(&.{next});
-                    try buf.append('\\');
-                    if (escaped) |e| try buf.append(e) else try buf.append(next);
-                }
-            } else if (ch == '#' and self.peek(0) == '{') {
-                return buf.toOwnedSlice();
-            } else if (ch == quote) {
-                return buf.toOwnedSlice();
-            } else {
-                try buf.append(ch);
-            }
-        }
-        return error.UnterminatedString;
-    }
-
-    fn readStringInterp(self: *Lexer, quote: u8) !void {
-        while (true) {
-            var buf = std.ArrayList(u8).init(self.allocator);
-            defer buf.deinit();
-            var has_content = false;
-            while (self.pos < self.source.len) {
-                const ch = self.advance();
-                if (ch == '\\') {
-                    if (self.pos < self.source.len) {
-                        const next = self.advance();
-                        const escaped = ESCAPE_MAP.get(&.{next});
-                        try buf.append('\\');
-                        if (escaped) |e| try buf.append(e) else try buf.append(next);
-                        has_content = true;
-                    }
-                } else if (ch == '#' and self.peek(0) == '{') {
-                    self.pos += 1;
-                    if (has_content or buf.items.len > 0) {
-                        try self.emit(.string, try buf.toOwnedSlice());
-                    }
-                    var depth: u32 = 1;
-                    const start = self.pos;
-                    while (self.pos < self.source.len and depth > 0) {
-                        const c = self.source[self.pos];
-                        self.pos += 1;
-                        if (c == '{') {
-                            depth += 1;
-                        } else if (c == '}') {
-                            depth -= 1;
-                        }
-                    }
-                    try self.emit(.interp_start, self.source[start .. self.pos - 1]);
-                    break;
-                } else if (ch == quote) {
-                    if (has_content or buf.items.len > 0) {
-                        try self.emit(.string, buf.items);
-                    }
-                    return;
-                } else {
-                    try buf.append(ch);
-                    has_content = true;
-                }
-            } else {
-                return;
-            }
-        }
-    }
-
-    fn readNumber(self: *Lexer) ![]const u8 {
-        const start = self.pos;
-        if (self.peek(0) == '+' or self.peek(0) == '-') {
-            self.pos += 1;
-        }
-        if (self.peek(0) == '0' and (self.peek(1) == 'x' or self.peek(1) == 'X')) {
-            self.pos += 2;
-            while (self.pos < self.source.len and std.ascii.isHexDigit(self.source[self.pos])) {
-                self.pos += 1;
-            }
-            return self.source[start..self.pos];
-        }
-        while (self.pos < self.source.len and (std.ascii.isDigit(self.source[self.pos]) or self.source[self.pos] == '.')) {
-            self.pos += 1;
-        }
-        if (self.pos < self.source.len and (self.source[self.pos] == 'e' or self.source[self.pos] == 'E')) {
-            self.pos += 1;
-            if (self.pos < self.source.len and (self.source[self.pos] == '+' or self.source[self.pos] == '-')) {
-                self.pos += 1;
-            }
-            while (self.pos < self.source.len and std.ascii.isDigit(self.source[self.pos])) {
-                self.pos += 1;
-            }
-        }
-        return self.source[start..self.pos];
-    }
-
-    fn readIdent(self: *Lexer) []const u8 {
-        const start = self.pos;
-        while (self.pos < self.source.len) {
-            const ch = self.source[self.pos];
-            if (std.ascii.isAlphanumeric(ch) or ch == '_' or ch == '-') {
-                self.pos += 1;
-            } else {
-                break;
-            }
-        }
-        return self.source[start..self.pos];
-    }
-
-    fn readText(self: *Lexer) []const u8 {
-        const start = self.pos;
-        while (self.pos < self.source.len) {
-            const ch = self.source[self.pos];
-            const next = if (self.pos + 1 < self.source.len) self.source[self.pos + 1] else 0;
-            if (ch == '@' or ch == '{' or ch == '}' or ch == '$' or ch == '\n' or ch == '"' or ch == '\'') break;
-            if (ch == '/' and (next == '/' or next == '*')) break;
-            if (ch == '#' and next == '{') break;
-            self.pos += 1;
-        }
-        return self.source[start..self.pos];
-    }
-
-    fn handleIndent(self: *Lexer) !void {
-        var count: u32 = 0;
-        while (self.pos < self.source.len and self.source[self.pos] == ' ') {
-            self.pos += 1;
-            count += 1;
-        }
-        while (self.pos < self.source.len and self.source[self.pos] == '\t') {
-            self.pos += 1;
-            count += INDENT_WIDTH;
-        }
-        if (self.pos >= self.source.len) return;
-        if (self.source[self.pos] == '\n') return;
-        if (self.source[self.pos] == '#') return;
-
-        const top = self.indent_stack.getLast();
-        if (count > top) {
-            try self.indent_stack.append(count);
-            try self.emit(.indent, "");
-        } else if (count < top) {
-            while (self.indent_stack.items.len > 0 and count < self.indent_stack.getLast()) {
-                _ = self.indent_stack.pop();
-                try self.emit(.dedent, "");
-            }
-            if (self.indent_stack.items.len > 0 and count != self.indent_stack.getLast()) {
-                return self.syntaxError("Inconsistent indentation");
-            }
-        }
-    }
-
-    fn tokenize(self: *Lexer) !void {
-        while (self.pos < self.source.len) {
-            if (self.line_start) {
-                self.line_start = false;
-                try self.handleIndent();
-                if (self.pos >= self.source.len) break;
-            }
-
-            const ch = self.peek(0);
-
-            if (ch == '\n') {
-                self.pos += 1;
-                self.line += 1;
-                self.col = 1;
-                self.line_start = true;
-                try self.emit(.newline, "");
-                continue;
-            }
-
-            if (ch == '/' and (self.peek(1) == '/' or self.peek(1) == '*')) {
-                try self.skipComment();
-                continue;
-            }
-
-            if (ch == ' ' or ch == '\t') {
-                self.pos += 1;
-                self.col += 1;
-                continue;
-            }
-
-            if (ch == '$') {
-                if (self.peek(1) == '$') {
-                    self.pos += 2;
-                    const start = self.pos;
-                    while (self.pos < self.source.len) {
-                        if (self.peek(0) == '$' and self.peek(1) == '$') {
-                            try self.emit(.math_display, self.source[start..self.pos]);
-                            self.pos += 2;
-                            break;
-                        }
-                        self.pos += 1;
-                    } else {
-                        return self.syntaxError("Unterminated display math");
-                    }
-                } else {
-                    self.pos += 1;
-                    const start = self.pos;
-                    while (self.pos < self.source.len and self.source[self.pos] != '$') {
-                        self.pos += 1;
-                    }
-                    if (self.pos >= self.source.len) return self.syntaxError("Unterminated inline math");
-                    try self.emit(.math_inline, self.source[start..self.pos]);
-                    self.pos += 1;
-                }
-                continue;
-            }
-
-            if (ch == '@') {
-                self.pos += 1;
-                try self.emit(.at, "");
-                continue;
-            }
-
-            if (ch == '#') {
-                if (self.peek(1) == '{') {
-                    self.pos += 2;
-                    var depth: u32 = 1;
-                    const start = self.pos;
-                    while (self.pos < self.source.len and depth > 0) {
-                        const c = self.source[self.pos];
-                        self.pos += 1;
-                        if (c == '{') {
-                            depth += 1;
-                        } else if (c == '}') {
-                            depth -= 1;
-                        }
-                    }
-                    try self.emit(.interp_start, self.source[start .. self.pos - 1]);
-                    continue;
-                }
-            }
-
-            if (ch == '"' or ch == '\'') {
-                self.pos += 1;
-                try self.readStringInterp(ch);
-                continue;
-            }
-
-            if (ch == '(') { self.pos += 1; try self.emit(.lparen, ""); continue; }
-            if (ch == ')') { self.pos += 1; try self.emit(.rparen, ""); continue; }
-            if (ch == '{') { self.pos += 1; try self.emit(.lbrace, ""); continue; }
-            if (ch == '}') { self.pos += 1; try self.emit(.rbrace, ""); continue; }
-            if (ch == '[') { self.pos += 1; try self.emit(.lbracket, ""); continue; }
-            if (ch == ']') { self.pos += 1; try self.emit(.rbracket, ""); continue; }
-            if (ch == ':') { self.pos += 1; try self.emit(.colon, ":"); continue; }
-            if (ch == ',') { self.pos += 1; try self.emit(.comma, ""); continue; }
-            if (ch == '-') { self.pos += 1; try self.emit(.dash, ""); continue; }
-            if (ch == '*') { self.pos += 1; try self.emit(.star, ""); continue; }
-            if (ch == '+') { self.pos += 1; try self.emit(.plus, ""); continue; }
-            if (ch == '|') { self.pos += 1; try self.emit(.pipe, ""); continue; }
-            if (ch == '=') { self.pos += 1; try self.emit(.equals, ""); continue; }
-            if (ch == '.') { self.pos += 1; try self.emit(.dot, ""); continue; }
-            if (ch == '?') { self.pos += 1; try self.emit(.question, ""); continue; }
-            if (ch == '<') { self.pos += 1; try self.emit(.lt, ""); continue; }
-            if (ch == '>') { self.pos += 1; try self.emit(.gt, ""); continue; }
-
-            if (std.ascii.isDigit(ch) or ((ch == '+' or ch == '-') and self.peek(1) != 0 and std.ascii.isDigit(self.peek(1)))) {
-                const num = try self.readNumber();
-                try self.emit(.number, num);
-                continue;
-            }
-
-            if (std.ascii.isAlpha(ch) or ch == '_') {
-                const ident = self.readIdent();
-                if (std.mem.eql(u8, ident, "true") or std.mem.eql(u8, ident, "false")) {
-                    try self.emit(.bool, ident);
-                } else if (std.mem.eql(u8, ident, "null")) {
-                    try self.emit(.null, ident);
-                } else {
-                    try self.emit(.ident, ident);
-                }
-                continue;
-            }
-
-            const text = self.readText();
-            if (text.len > 0) {
-                try self.emit(.text, text);
-                continue;
-            }
-
-            if (ch == '\r') { self.pos += 1; continue; }
-            self.pos += 1;
-        }
-
-        while (self.indent_stack.items.len > 1) {
-            _ = self.indent_stack.pop();
-            try self.emit(.dedent, "");
-        }
-        try self.emit(.eof, "");
-    }
-};

package/src/main.zig

@@ -1,147 +0,0 @@
-const std = @import("std");
-const types = @import("types.zig");
-const lexer_mod = @import("lexer.zig");
-const parser_mod = @import("parser.zig");
-const interpreter_mod = @import("interpreter.zig");
-const renderer_mod = @import("renderer.zig");
-
-pub fn main() !void {
-    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    var args_list = std.ArrayList([]const u8).init(allocator);
-    {
-        var args_iter = try std.process.Args.Iterator.initAllocator(std.process.args, allocator);
-        defer args_iter.deinit();
-        while (try args_iter.next()) |arg| {
-            try args_list.append(try allocator.dupe(u8, arg));
-        }
-    }
-
-    if (args_list.items.len < 2) {
-        std.debug.print("Usage: nova <input.nv> [output.html]\n", .{});
-        std.debug.print("       nova lex <input.nv>\n", .{});
-        std.debug.print("       nova ast <input.nv>\n", .{});
-        return;
-    }
-
-    const command = args_list.items[1];
-    if (std.mem.eql(u8, command, "lex") or std.mem.eql(u8, command, "ast")) {
-        if (args_list.items.len < 3) {
-            std.debug.print("Usage: nova {s} <input.nv>\n", .{command});
-            return;
-        }
-        const input_file = args_list.items[2];
-        const source = try readFile(allocator, input_file);
-        var lexer = lexer_mod.Lexer.init(allocator, source);
-        defer lexer.deinit();
-        const tokens = try lexer.getTokens();
-        if (std.mem.eql(u8, command, "lex")) {
-            for (tokens.items) |tok| {
-                const padding = "            "[@tagName(tok.type).len..];
-                std.debug.print("{s}{s} '{s}' L:{} C:{}\n", .{
-                    @tagName(tok.type), padding, tok.value, tok.line, tok.col,
-                });
-            }
-        } else {
-            var pool = types.AstPool.init(allocator);
-            var parser = parser_mod.Parser.init(allocator, tokens, &pool);
-            const doc = parser.parse() catch |err| {
-                std.debug.print("Parse error: {}\n", .{err});
-                return;
-            };
-            printAST(doc, 0);
-        }
-        return;
-    }
-
-    const input_file = args_list.items[1];
-    const output_file = if (args_list.items.len > 2) args_list.items[2] else "";
-    const source = readFile(allocator, input_file) catch {
-        std.debug.print("Error: file not found: {s}\n", .{input_file});
-        return;
-    };
-
-    var lexer = lexer_mod.Lexer.init(allocator, source);
-    defer lexer.deinit();
-    const tokens = lexer.getTokens() catch |err| {
-        std.debug.print("Lex error: {}\n", .{err});
-        return;
-    };
-
-    var pool = types.AstPool.init(allocator);
-    var parser = parser_mod.Parser.init(allocator, tokens, &pool);
-    const doc = parser.parse() catch |err| {
-        std.debug.print("Parse error: {}\n", .{err});
-        return;
-    };
-
-    var interp = interpreter_mod.Interpreter.init(allocator);
-    defer interp.deinit();
-    const evaled_doc = interp.evalDocument(@constCast(&doc)) catch |err| {
-        std.debug.print("Interpretation error: {}\n", .{err});
-        return;
-    };
-
-    var renderer = renderer_mod.Renderer.init(allocator);
-    defer renderer.deinit();
-    const html = renderer.render(evaled_doc) catch |err| {
-        std.debug.print("Render error: {}\n", .{err});
-        return;
-    };
-
-    if (output_file.len > 0) {
-        const file = std.fs.cwd().createFile(output_file, .{}) catch |err| {
-            std.debug.print("Error creating output file: {}\n", .{err});
-            return;
-        };
-        defer file.close();
-        _ = file.write(html) catch {};
-        std.debug.print("Written to {s}\n", .{output_file});
-    } else {
-        std.debug.print("{s}", .{html});
-    }
-}
-
-fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]const u8 {
-    const file = std.fs.cwd().openFile(path, .{}) catch return error.FileNotFound;
-    defer file.close();
-    return file.readToEndAlloc(allocator, 1_000_000);
-}
-
-fn printAST(node: types.Node, indent: u32) void {
-    var i: u32 = 0;
-    while (i < indent) : (i += 1) std.debug.print("  ", .{});
-    switch (node.tag) {
-        .document => {
-            std.debug.print("Document\n", .{});
-            for (node.data.document.children.items) |child| printAST(child, indent + 1);
-        },
-        .text => std.debug.print("Text(value='{s}')\n", .{node.data.text.value}),
-        .block => {
-            const b = &node.data.block;
-            std.debug.print("Block(name='{s}', attrs={any}, inline_content=[], position=null)\n", .{ b.name, b.attrs });
-            for (b.children.items) |child| printAST(child, indent + 1);
-        },
-        .inline_block => {
-            const ib = &node.data.inline_block;
-            std.debug.print("InlineBlock(name='{s}', attrs={any}, content=[])\n", .{ ib.name, ib.attrs });
-        },
-        .math_inline => std.debug.print("MathInline(source='{s}')\n", .{node.data.math_inline.source}),
-        .math_display => std.debug.print("MathDisplay(source='{s}')\n", .{node.data.math_display.source}),
-        .interpolation => std.debug.print("Interpolation(expression='{s}')\n", .{node.data.interpolation.expression}),
-        .list_block => std.debug.print("ListBlock(ordered={})\n", .{node.data.list_block.ordered}),
-        .table_block => std.debug.print("TableBlock\n", .{}),
-        .schema_def => std.debug.print("SchemaDef(name='{s}')\n", .{node.data.schema_def.name}),
-        .service_def => std.debug.print("ServiceDef(name='{s}')\n", .{node.data.service_def.name}),
-        .macro_def => std.debug.print("MacroDef(name='{s}')\n", .{node.data.macro_def.name}),
-        .if_block => std.debug.print("IfBlock(condition='{s}')\n", .{node.data.if_block.condition}),
-        .for_block => std.debug.print("ForBlock(var='{s}', iterable='{s}')\n", .{ node.data.for_block.var_name, node.data.for_block.iterable }),
-        .use_block => std.debug.print("UseBlock(path='{s}')\n", .{node.data.use_block.path}),
-        .meta_block => std.debug.print("MetaBlock\n", .{}),
-        .biblio_entry => std.debug.print("BiblioEntry(key='{s}')\n", .{node.data.biblio_entry.key}),
-        .field_def => std.debug.print("FieldDef\n", .{}),
-        .method_def => std.debug.print("MethodDef\n", .{}),
-    }
-}