//! This is a Javascript parser and tokenizer.
//! It is and probably will never be complete,
//! since js is a very strange language and I want
//! to move forward and code on more interesting things
//! I started something called mujs (micro-js). It's a
//! subset of the javascript language. It does not support
//! the regex literal and currently also not template strings.
//! It is chosen like that to make parsing easier and also less
//! context-dependent.

const std = @import("std");

const parser = @import("../../root.zig");
pub const Lexer = parser.Lexer(Grammar);
pub const Token = parser.Token(Grammar);

pub const Whitespace = @import("whitespace.zig").Whitespace;
pub const Keyword = @import("keyword.zig").Keyword;
pub const Literal = @import("literal.zig").Literal;
pub const Punctuator = @import("punctuator.zig").Punctuator;
pub const Identifier = @import("identifier.zig").Identifier;

pub const Grammar = union(enum) {
    whitespace: Whitespace,
    keyword: Keyword,
    literal: Literal,
    punctuator: Punctuator,
    identifier: Identifier,
    end_of_file: void,

    pub inline fn tokenize(comptime lexer: *Lexer) Lexer.Error!void {
        comptime {
            while (lexer.peekChar()) |_| {
                Whitespace.tokenize(lexer) catch {
                    Keyword.tokenize(lexer) catch {
                        Literal.tokenize(lexer) catch {
                            Punctuator.tokenize(lexer) catch {
                                try Identifier.tokenize(lexer);
                            };
                        };
                    };
                };
            }

            lexer.commit(lexer.start(.end_of_file));
        }
    }
};

test {
    _ = std.testing.refAllDecls(@This());
}