vig/src/runner.zig

const std = @import("std");
const scanners = @import("scanner.zig");
const parsers = @import("parser.zig");
const main = @import("main.zig");
const ast = @import("ast.zig");

const tokens = @import("tokens.zig");
const printer = @import("ast_printer.zig");

const Allocator = std.mem.Allocator;
const Result = main.Result;
const Parser = parsers.Parser;

pub const Runner = struct {
    allocator: *Allocator,
    stdout: main.StdOut,

    pub fn init(allocator: *Allocator, stdout: main.StdOut) Runner {
        return Runner{ .allocator = allocator, .stdout = stdout };
    }

    fn testScanner(self: *Runner, scanner: *scanners.Scanner) !void {
        while (true) {
            var tok_opt = scanner.nextToken() catch |err| {
                try self.stdout.print(
                    "error at '{}': {}\n",
                    scanner.currentLexeme(),
                    err,
                );

                return Result.ScannerError;
            };

            if (tok_opt) |tok| {
                if (tok.ttype == .EOF) break;
                try self.stdout.print("{x}\n", tok);
            }
        }
    }

    pub fn execute(self: *Runner, code: []u8) !void {
        var scanner = scanners.Scanner.init(self.allocator, code);
        try self.testScanner(&scanner);

        scanner = scanners.Scanner.init(self.allocator, code);
        var parser = Parser.init(self.allocator, &scanner);
        var expr_opt = try parser.parse();

        //var expr = ast.mkBinary(
        //    &ast.mkUnary(
        //        tokens.Token{ .ttype = .Minus, .lexeme = "-", .line = 1 },
        //        &ast.mkNum(i32, 123),
        //    ),
        //    tokens.Token{ .ttype = .Star, .lexeme = "*", .line = 1 },
        //    &ast.mkGrouping(&ast.mkNum(f32, 45.67)),
        //);

        if (expr_opt) |expr_ptr| {
            printer.printAst(expr_ptr);
            std.debug.warn("\n");
        } else {
            return Result.CompileError;
        }

        return Result.Ok;
    }
};