geckolex

-module(gecko@builder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gecko/builder.gleam").
-export([init/0, keywords/2, tokens/2, comment/3, ident/3, float_universal/3, float/3, number_universal/3, number/3, string/3, regexes/2, compile_safe/2, compile/2]).
-export_type([builder/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-opaque builder(DUM) :: {builder,
        list({binary(), DUM}),
        list({binary(), DUM}),
        gleam@option:option({binary(), fun((binary()) -> DUM)}),
        gleam@option:option({binary(), fun((binary()) -> DUM)}),
        gleam@option:option({binary(), fun((binary()) -> DUM)}),
        gleam@option:option({binary(), fun((binary()) -> DUM)}),
        gleam@option:option({binary(), fun((binary()) -> DUM)}),
        list({binary(), fun((binary()) -> DUM)})}.

-file("src/gecko/builder.gleam", 30).
?DOC(" Initialize a new empty Builder.\n").
-spec init() -> builder(any()).
init() ->
    {builder, [], [], none, none, none, none, none, []}.

-file("src/gecko/builder.gleam", 46).
?DOC(
    " Set the list of keyword tokens for the builder.\n"
    "\n"
    " Keywords are matched as literal strings.\n"
).
-spec keywords(builder(DUR), list({binary(), DUR})) -> builder(DUR).
keywords(Builder, List) ->
    {builder,
        List,
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 56).
?DOC(
    " Set the list of non-keyword literal tokens for the builder.\n"
    "\n"
    " Tokens are matched as literal strings.\n"
).
-spec tokens(builder(DUW), list({binary(), DUW})) -> builder(DUW).
tokens(Builder, List) ->
    {builder,
        erlang:element(2, Builder),
        List,
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 66).
?DOC(
    " Set the comment regex for the builder.\n"
    "\n"
    " The regex is used to match comments in the input.\n"
).
-spec comment(builder(DVB), binary(), fun((binary()) -> DVB)) -> builder(DVB).
comment(Builder, Regex, Token) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        {some, {Regex, Token}},
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 77).
?DOC(
    " Set the identifier regex for the builder.\n"
    "\n"
    " The regex is used to match identifiers in the input.\n"
).
-spec ident(builder(DVE), binary(), fun((binary()) -> DVE)) -> builder(DVE).
ident(Builder, Regex, Token) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        {some, {Regex, Token}},
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 88).
?DOC(
    " Set a universal float-matching regex for the builder.\n"
    "\n"
    " The regex is used to match floats as strings, and the token function receives the matched string.\n"
).
-spec float_universal(builder(DVH), binary(), fun((binary()) -> DVH)) -> builder(DVH).
float_universal(Builder, Regex, Token) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        {some, {Regex, Token}},
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 99).
?DOC(
    " Set the float regex for the builder.\n"
    "\n"
    " The regex is used to match floats, and the token function receives a parsed Float.\n"
).
-spec float(builder(DVK), binary(), fun((float()) -> DVK)) -> builder(DVK).
float(Builder, Regex, Float) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        {some,
            {Regex,
                fun(S) ->
                    F@1 = case gleam_stdlib:parse_float(S) of
                        {ok, F} ->
                            F;

                        {error, _} ->
                            erlang:error(#{gleam_error => panic,
                                    message => (<<"float: could not parse: "/utf8,
                                        S/binary>>),
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"gecko/builder"/utf8>>,
                                    function => <<"float"/utf8>>,
                                    line => 110})
                    end,
                    Float(F@1)
                end}},
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 121).
?DOC(
    " Set a universal number-matching regex for the builder.\n"
    "\n"
    " The regex is used to match numbers as strings, and the token function receives the matched string.\n"
).
-spec number_universal(builder(DVN), binary(), fun((binary()) -> DVN)) -> builder(DVN).
number_universal(Builder, Regex, Token) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        {some, {Regex, Token}},
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 132).
?DOC(
    " Set the number regex for the builder.\n"
    "\n"
    " The regex is used to match numbers, and the token function receives a parsed Int.\n"
).
-spec number(builder(DVQ), binary(), fun((integer()) -> DVQ)) -> builder(DVQ).
number(Builder, Regex, Number) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        {some,
            {Regex,
                fun(S) ->
                    N = case gleam_stdlib:parse_int(S) of
                        {ok, F} ->
                            F;

                        {error, _} ->
                            erlang:error(#{gleam_error => panic,
                                    message => (<<"number: could not parse: "/utf8,
                                        S/binary>>),
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"gecko/builder"/utf8>>,
                                    function => <<"number"/utf8>>,
                                    line => 143})
                    end,
                    Number(N)
                end}},
        erlang:element(8, Builder),
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 154).
?DOC(
    " Set the string regex for the builder.\n"
    "\n"
    " The regex is used to match string literals in the input.\n"
).
-spec string(builder(DVT), binary(), fun((binary()) -> DVT)) -> builder(DVT).
string(Builder, Regex, Token) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        {some, {Regex, Token}},
        erlang:element(9, Builder)}.

-file("src/gecko/builder.gleam", 165).
?DOC(
    " Set additional regex token matchers for the builder.\n"
    "\n"
    " These regexes are tried after keywords and tokens.\n"
).
-spec regexes(builder(DVW), list({binary(), fun((binary()) -> DVW)})) -> builder(DVW).
regexes(Builder, Regexes) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        Regexes}.

-file("src/gecko/builder.gleam", 228).
-spec compare_literal_builders({binary(), DWJ}, {binary(), DWJ}) -> gleam@order:order().
compare_literal_builders(L1, L2) ->
    {S1, _} = L1,
    {S2, _} = L2,
    L1_len = string:length(S1),
    L2_len = string:length(S2),
    gleam@int:compare(L2_len, L1_len).

-file("src/gecko/builder.gleam", 239).
-spec lb_to_tokenfn({binary(), DWM}) -> fun((binary(), binary(), fun((binary()) -> DWM)) -> gleam@option:option({binary(),
    gecko@lexer:token(DWM)})).
lb_to_tokenfn(L) ->
    {S, L@1} = L,
    gecko@lexer:gen_naked(S, fun(_) -> L@1 end).

-file("src/gecko/builder.gleam", 244).
-spec rb_to_token_fn({binary(), fun((binary()) -> DWP)}) -> fun((binary(), binary(), fun((binary()) -> DWP)) -> gleam@option:option({binary(),
    gecko@lexer:token(DWP)})).
rb_to_token_fn(R) ->
    {S, F} = R,
    gecko@lexer:gen_rule(S, F).

-file("src/gecko/builder.gleam", 175).
?DOC(
    " Compile the builder into a Lexer, returning a Result.\n"
    "\n"
    " Returns `Ok(Lexer)` on success, or `Error(String)` if there is a problem.\n"
).
-spec compile_safe(builder(DWB), DWB) -> {ok, gecko@lexer:lexer(DWB)} |
    {error, binary()}.
compile_safe(Builder, Eof) ->
    Keywords = begin
        _pipe = erlang:element(2, Builder),
        _pipe@1 = gleam@list:sort(_pipe, fun compare_literal_builders/2),
        gleam@list:map(_pipe@1, fun lb_to_tokenfn/1)
    end,
    Tokens = begin
        _pipe@2 = erlang:element(3, Builder),
        _pipe@3 = gleam@list:sort(_pipe@2, fun compare_literal_builders/2),
        gleam@list:map(_pipe@3, fun lb_to_tokenfn/1)
    end,
    Regexes = begin
        _pipe@4 = erlang:element(9, Builder),
        gleam@list:map(_pipe@4, fun rb_to_token_fn/1)
    end,
    Ident = case erlang:element(5, Builder) of
        {some, I} ->
            [begin
                    _pipe@5 = I,
                    rb_to_token_fn(_pipe@5)
                end];

        none ->
            []
    end,
    Float = case erlang:element(6, Builder) of
        {some, I@1} ->
            [begin
                    _pipe@6 = I@1,
                    rb_to_token_fn(_pipe@6)
                end];

        none ->
            []
    end,
    Number = case erlang:element(7, Builder) of
        {some, I@2} ->
            [begin
                    _pipe@7 = I@2,
                    rb_to_token_fn(_pipe@7)
                end];

        none ->
            []
    end,
    String = case erlang:element(8, Builder) of
        {some, I@3} ->
            [begin
                    _pipe@8 = I@3,
                    rb_to_token_fn(_pipe@8)
                end];

        none ->
            []
    end,
    Toks = [],
    Toks@1 = lists:append(Toks, Keywords),
    Toks@2 = lists:append(Toks@1, Tokens),
    Toks@3 = lists:append(Toks@2, Regexes),
    Toks@4 = lists:append(Toks@3, Ident),
    Toks@5 = lists:append(Toks@4, Float),
    Toks@6 = lists:append(Toks@5, Number),
    Toks@7 = lists:append(Toks@6, String),
    {ok, {lexer, Toks@7, Eof}}.

-file("src/gecko/builder.gleam", 220).
?DOC(
    " Compile the builder into a Lexer, panicking on error.\n"
    "\n"
    " Returns a Lexer, or panics if there is a problem.\n"
).
-spec compile(builder(DWG), DWG) -> gecko@lexer:lexer(DWG).
compile(Builder, Eof) ->
    case compile_safe(Builder, Eof) of
        {ok, L} ->
            L;

        {error, E} ->
            erlang:error(#{gleam_error => panic,
                    message => E,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"gecko/builder"/utf8>>,
                    function => <<"compile"/utf8>>,
                    line => 223})
    end.