@nova-lang/cli 0.1.0

package/src/main.zig

@@ -0,0 +1,147 @@
+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", .{}),
+    }
+}