eyg_parser

-module(eyg@parser@lexer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/eyg/parser/lexer.gleam").
-export([lex/1]).

-file("src/eyg/parser/lexer.gleam", 17).
-spec done(integer()) -> fun((FDM, integer(), FDO) -> {ok,
        {{FDM, integer()}, integer(), FDO}} |
    {error, any()}).
done(Start) ->
    fun(T, Size, Rest) -> {ok, {{T, Start}, Start + Size, Rest}} end.

-file("src/eyg/parser/lexer.gleam", 222).
-spec is_lower_grapheme(binary()) -> boolean().
is_lower_grapheme(Grapheme) ->
    case Grapheme of
        <<"a"/utf8>> ->
            true;

        <<"b"/utf8>> ->
            true;

        <<"c"/utf8>> ->
            true;

        <<"d"/utf8>> ->
            true;

        <<"e"/utf8>> ->
            true;

        <<"f"/utf8>> ->
            true;

        <<"g"/utf8>> ->
            true;

        <<"h"/utf8>> ->
            true;

        <<"i"/utf8>> ->
            true;

        <<"j"/utf8>> ->
            true;

        <<"k"/utf8>> ->
            true;

        <<"l"/utf8>> ->
            true;

        <<"m"/utf8>> ->
            true;

        <<"n"/utf8>> ->
            true;

        <<"o"/utf8>> ->
            true;

        <<"p"/utf8>> ->
            true;

        <<"q"/utf8>> ->
            true;

        <<"r"/utf8>> ->
            true;

        <<"s"/utf8>> ->
            true;

        <<"t"/utf8>> ->
            true;

        <<"u"/utf8>> ->
            true;

        <<"v"/utf8>> ->
            true;

        <<"w"/utf8>> ->
            true;

        <<"x"/utf8>> ->
            true;

        <<"y"/utf8>> ->
            true;

        <<"z"/utf8>> ->
            true;

        _ ->
            false
    end.

-file("src/eyg/parser/lexer.gleam", 254).
-spec is_upper_grapheme(binary()) -> boolean().
is_upper_grapheme(Grapheme) ->
    case Grapheme of
        <<"A"/utf8>> ->
            true;

        <<"B"/utf8>> ->
            true;

        <<"C"/utf8>> ->
            true;

        <<"D"/utf8>> ->
            true;

        <<"E"/utf8>> ->
            true;

        <<"F"/utf8>> ->
            true;

        <<"G"/utf8>> ->
            true;

        <<"H"/utf8>> ->
            true;

        <<"I"/utf8>> ->
            true;

        <<"J"/utf8>> ->
            true;

        <<"K"/utf8>> ->
            true;

        <<"L"/utf8>> ->
            true;

        <<"M"/utf8>> ->
            true;

        <<"N"/utf8>> ->
            true;

        <<"O"/utf8>> ->
            true;

        <<"P"/utf8>> ->
            true;

        <<"Q"/utf8>> ->
            true;

        <<"R"/utf8>> ->
            true;

        <<"S"/utf8>> ->
            true;

        <<"T"/utf8>> ->
            true;

        <<"U"/utf8>> ->
            true;

        <<"V"/utf8>> ->
            true;

        <<"W"/utf8>> ->
            true;

        <<"X"/utf8>> ->
            true;

        <<"Y"/utf8>> ->
            true;

        <<"Z"/utf8>> ->
            true;

        _ ->
            false
    end.

-file("src/eyg/parser/lexer.gleam", 286).
-spec is_digit_grapheme(binary()) -> boolean().
is_digit_grapheme(Grapheme) ->
    case Grapheme of
        <<"1"/utf8>> ->
            true;

        <<"2"/utf8>> ->
            true;

        <<"3"/utf8>> ->
            true;

        <<"4"/utf8>> ->
            true;

        <<"5"/utf8>> ->
            true;

        <<"6"/utf8>> ->
            true;

        <<"7"/utf8>> ->
            true;

        <<"8"/utf8>> ->
            true;

        <<"9"/utf8>> ->
            true;

        <<"0"/utf8>> ->
            true;

        _ ->
            false
    end.

-file("src/eyg/parser/lexer.gleam", 293).
-spec byte_slice_range(binary(), integer(), integer()) -> binary().
byte_slice_range(Raw, From, To) ->
    case gleam_stdlib:identity(Raw) of
        <<>> ->
            <<""/utf8>>;

        <<_:From/binary, Slice:(To - From)/binary, _/binary>> ->
            Slice@2 = case gleam@bit_array:to_string(Slice) of
                {ok, Slice@1} -> Slice@1;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"eyg/parser/lexer"/utf8>>,
                                function => <<"byte_slice_range"/utf8>>,
                                line => 297,
                                value => _assert_fail,
                                start => 7253,
                                'end' => 7302,
                                pattern_start => 7264,
                                pattern_end => 7273})
            end,
            Slice@2;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"eyg/parser/lexer"/utf8>>,
                    function => <<"byte_slice_range"/utf8>>,
                    line => 300})
    end.

-file("src/eyg/parser/lexer.gleam", 304).
-spec byte_slice_from(binary(), integer()) -> binary().
byte_slice_from(Raw, From) ->
    case gleam_stdlib:identity(Raw) of
        <<>> ->
            <<""/utf8>>;

        <<_:From/binary, Slice/binary>> ->
            Slice@2 = case gleam@bit_array:to_string(Slice) of
                {ok, Slice@1} -> Slice@1;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"eyg/parser/lexer"/utf8>>,
                                function => <<"byte_slice_from"/utf8>>,
                                line => 308,
                                value => _assert_fail,
                                start => 7477,
                                'end' => 7526,
                                pattern_start => 7488,
                                pattern_end => 7497})
            end,
            Slice@2;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"eyg/parser/lexer"/utf8>>,
                    function => <<"byte_slice_from"/utf8>>,
                    line => 311})
    end.

-file("src/eyg/parser/lexer.gleam", 156).
-spec string(
    binary(),
    integer(),
    binary(),
    fun((eyg@parser@token:token(), integer(), binary()) -> FEG)
) -> FEG.
string(Buffer, Length, Rest, Done) ->
    case Rest of
        <<"\""/utf8, Rest@1/binary>> ->
            Done({string, Buffer}, Length + 1, Rest@1);

        <<"\\"/utf8, Rest@2/binary>> ->
            case Rest@2 of
                <<"\""/utf8, Rest@3/binary>> ->
                    string(
                        <<Buffer/binary, "\""/utf8>>,
                        Length + 2,
                        Rest@3,
                        Done
                    );

                <<"\\"/utf8, Rest@4/binary>> ->
                    string(
                        <<Buffer/binary, "\\"/utf8>>,
                        Length + 2,
                        Rest@4,
                        Done
                    );

                <<"t"/utf8, Rest@5/binary>> ->
                    string(
                        <<Buffer/binary, "\t"/utf8>>,
                        Length + 2,
                        Rest@5,
                        Done
                    );

                <<"r"/utf8, Rest@6/binary>> ->
                    string(
                        <<Buffer/binary, "\r"/utf8>>,
                        Length + 2,
                        Rest@6,
                        Done
                    );

                <<"n"/utf8, Rest@7/binary>> ->
                    string(
                        <<Buffer/binary, "\n"/utf8>>,
                        Length + 2,
                        Rest@7,
                        Done
                    );

                <<""/utf8>> ->
                    Done(
                        {unterminated_string, <<Buffer/binary, "\\"/utf8>>},
                        Length,
                        <<""/utf8>>
                    );

                _ ->
                    Done(
                        {invalid_escape,
                            <<<<Buffer/binary, "\\"/utf8>>/binary,
                                Rest@2/binary>>},
                        Length,
                        <<""/utf8>>
                    )
            end;

        <<""/utf8>> ->
            Done({unterminated_string, Buffer}, Length, <<""/utf8>>);

        _ ->
            Next_byte = byte_slice_range(Rest, 0, 1),
            Rest@8 = byte_slice_from(Rest, 1),
            string(
                <<Buffer/binary, Next_byte/binary>>,
                Length + 1,
                Rest@8,
                Done
            )
    end.

-file("src/eyg/parser/lexer.gleam", 133).
-spec comment(
    binary(),
    binary(),
    fun((eyg@parser@token:token(), integer(), binary()) -> FCD)
) -> FCD.
comment(Buffer, Rest, Done) ->
    case Rest of
        <<"\r\n"/utf8, _/binary>> ->
            Done({comment, Buffer}, erlang:byte_size(Buffer) + 2, Rest);

        <<"\n"/utf8, _/binary>> ->
            Done({comment, Buffer}, erlang:byte_size(Buffer) + 2, Rest);

        _ ->
            Next_byte = byte_slice_range(Rest, 0, 1),
            Rest@1 = byte_slice_from(Rest, 1),
            comment(<<Buffer/binary, Next_byte/binary>>, Rest@1, Done)
    end.

-file("src/eyg/parser/lexer.gleam", 146).
-spec whitespace(
    binary(),
    binary(),
    fun((eyg@parser@token:token(), integer(), binary()) -> FES)
) -> FES.
whitespace(Buffer, Rest, Done) ->
    case Rest of
        <<"\r\n"/utf8, Rest@1/binary>> ->
            whitespace(<<Buffer/binary, "\r\n"/utf8>>, Rest@1, Done);

        <<"\n"/utf8, Rest@2/binary>> ->
            whitespace(<<Buffer/binary, "\n"/utf8>>, Rest@2, Done);

        <<" "/utf8, Rest@3/binary>> ->
            whitespace(<<Buffer/binary, " "/utf8>>, Rest@3, Done);

        <<"\t"/utf8, Rest@4/binary>> ->
            whitespace(<<Buffer/binary, "\t"/utf8>>, Rest@4, Done);

        _ ->
            Done({whitespace, Buffer}, erlang:byte_size(Buffer), Rest)
    end.

-file("src/eyg/parser/lexer.gleam", 178).
-spec name(
    binary(),
    binary(),
    fun((eyg@parser@token:token(), integer(), binary()) -> FEY)
) -> FEY.
name(Buffer, Raw, Done) ->
    Next_byte = byte_slice_range(Raw, 0, 1),
    Rest = byte_slice_from(Raw, 1),
    case (is_lower_grapheme(Next_byte) orelse is_digit_grapheme(Next_byte))
    orelse (Next_byte =:= <<"_"/utf8>>) of
        true ->
            name(<<Buffer/binary, Next_byte/binary>>, Rest, Done);

        false ->
            Done({name, Buffer}, erlang:byte_size(Buffer), Raw)
    end.

-file("src/eyg/parser/lexer.gleam", 191).
-spec uppername(
    binary(),
    binary(),
    fun((eyg@parser@token:token(), integer(), binary()) -> FFE)
) -> FFE.
uppername(Buffer, Raw, Done) ->
    Next_byte = byte_slice_range(Raw, 0, 1),
    Rest = byte_slice_from(Raw, 1),
    case ((is_upper_grapheme(Next_byte) orelse is_lower_grapheme(Next_byte))
    orelse is_digit_grapheme(Next_byte))
    orelse (Next_byte =:= <<"_"/utf8>>) of
        true ->
            uppername(<<Buffer/binary, Next_byte/binary>>, Rest, Done);

        false ->
            Done({uppername, Buffer}, erlang:byte_size(Buffer), Raw)
    end.

-file("src/eyg/parser/lexer.gleam", 206).
-spec integer(
    binary(),
    binary(),
    fun((eyg@parser@token:token(), integer(), binary()) -> FFK)
) -> FFK.
integer(Buffer, Rest, Done) ->
    case Rest of
        <<"1"/utf8, Rest@1/binary>> ->
            integer(<<Buffer/binary, "1"/utf8>>, Rest@1, Done);

        <<"2"/utf8, Rest@2/binary>> ->
            integer(<<Buffer/binary, "2"/utf8>>, Rest@2, Done);

        <<"3"/utf8, Rest@3/binary>> ->
            integer(<<Buffer/binary, "3"/utf8>>, Rest@3, Done);

        <<"4"/utf8, Rest@4/binary>> ->
            integer(<<Buffer/binary, "4"/utf8>>, Rest@4, Done);

        <<"5"/utf8, Rest@5/binary>> ->
            integer(<<Buffer/binary, "5"/utf8>>, Rest@5, Done);

        <<"6"/utf8, Rest@6/binary>> ->
            integer(<<Buffer/binary, "6"/utf8>>, Rest@6, Done);

        <<"7"/utf8, Rest@7/binary>> ->
            integer(<<Buffer/binary, "7"/utf8>>, Rest@7, Done);

        <<"8"/utf8, Rest@8/binary>> ->
            integer(<<Buffer/binary, "8"/utf8>>, Rest@8, Done);

        <<"9"/utf8, Rest@9/binary>> ->
            integer(<<Buffer/binary, "9"/utf8>>, Rest@9, Done);

        <<"0"/utf8, Rest@10/binary>> ->
            integer(<<Buffer/binary, "0"/utf8>>, Rest@10, Done);

        _ ->
            Done({integer, Buffer}, erlang:byte_size(Buffer), Rest)
    end.

-file("src/eyg/parser/lexer.gleam", 21).
-spec pop(binary(), integer()) -> {ok,
        {{eyg@parser@token:token(), integer()}, integer(), binary()}} |
    {error, nil}.
pop(Raw, Start) ->
    Done = done(Start),
    case Raw of
        <<"//"/utf8, Rest/binary>> ->
            comment(<<""/utf8>>, Rest, Done);

        <<"\r\n"/utf8, Rest@1/binary>> ->
            whitespace(<<"\r\n"/utf8>>, Rest@1, Done);

        <<"\n"/utf8, Rest@2/binary>> ->
            whitespace(<<"\n"/utf8>>, Rest@2, Done);

        <<" "/utf8, Rest@3/binary>> ->
            whitespace(<<" "/utf8>>, Rest@3, Done);

        <<"\t"/utf8, Rest@4/binary>> ->
            whitespace(<<"\t"/utf8>>, Rest@4, Done);

        <<"("/utf8, Rest@5/binary>> ->
            Done(left_paren, 1, Rest@5);

        <<")"/utf8, Rest@6/binary>> ->
            Done(right_paren, 1, Rest@6);

        <<"{"/utf8, Rest@7/binary>> ->
            Done(left_brace, 1, Rest@7);

        <<"}"/utf8, Rest@8/binary>> ->
            Done(right_brace, 1, Rest@8);

        <<"["/utf8, Rest@9/binary>> ->
            Done(left_square, 1, Rest@9);

        <<"]"/utf8, Rest@10/binary>> ->
            Done(right_square, 1, Rest@10);

        <<"="/utf8, Rest@11/binary>> ->
            Done(equal, 1, Rest@11);

        <<"->"/utf8, Rest@12/binary>> ->
            Done(right_arrow, 2, Rest@12);

        <<","/utf8, Rest@13/binary>> ->
            Done(comma, 1, Rest@13);

        <<".."/utf8, Rest@14/binary>> ->
            Done(dot_dot, 2, Rest@14);

        <<"."/utf8, Rest@15/binary>> ->
            Done(dot, 1, Rest@15);

        <<":"/utf8, Rest@16/binary>> ->
            Done(colon, 1, Rest@16);

        <<"-"/utf8, Rest@17/binary>> ->
            Done(minus, 1, Rest@17);

        <<"!"/utf8, Rest@18/binary>> ->
            Done(bang, 1, Rest@18);

        <<"|"/utf8, Rest@19/binary>> ->
            Done(bar, 1, Rest@19);

        <<"#"/utf8, Rest@20/binary>> ->
            Done(hash, 1, Rest@20);

        <<"@"/utf8, Rest@21/binary>> ->
            Done(at, 1, Rest@21);

        <<"let"/utf8, Rest@22/binary>> ->
            Done('let', 3, Rest@22);

        <<"match"/utf8, Rest@23/binary>> ->
            Done(match, 5, Rest@23);

        <<"perform"/utf8, Rest@24/binary>> ->
            Done(perform, 7, Rest@24);

        <<"deep"/utf8, Rest@25/binary>> ->
            Done(deep, 4, Rest@25);

        <<"handle"/utf8, Rest@26/binary>> ->
            Done(handle, 6, Rest@26);

        <<"\""/utf8, Rest@27/binary>> ->
            string(<<""/utf8>>, 1, Rest@27, Done);

        <<"1"/utf8, Rest@28/binary>> ->
            integer(<<"1"/utf8>>, Rest@28, Done);

        <<"2"/utf8, Rest@29/binary>> ->
            integer(<<"2"/utf8>>, Rest@29, Done);

        <<"3"/utf8, Rest@30/binary>> ->
            integer(<<"3"/utf8>>, Rest@30, Done);

        <<"4"/utf8, Rest@31/binary>> ->
            integer(<<"4"/utf8>>, Rest@31, Done);

        <<"5"/utf8, Rest@32/binary>> ->
            integer(<<"5"/utf8>>, Rest@32, Done);

        <<"6"/utf8, Rest@33/binary>> ->
            integer(<<"6"/utf8>>, Rest@33, Done);

        <<"7"/utf8, Rest@34/binary>> ->
            integer(<<"7"/utf8>>, Rest@34, Done);

        <<"8"/utf8, Rest@35/binary>> ->
            integer(<<"8"/utf8>>, Rest@35, Done);

        <<"9"/utf8, Rest@36/binary>> ->
            integer(<<"9"/utf8>>, Rest@36, Done);

        <<"0"/utf8, Rest@37/binary>> ->
            integer(<<"0"/utf8>>, Rest@37, Done);

        _ ->
            Next_byte = byte_slice_range(Raw, 0, 1),
            Rest@38 = byte_slice_from(Raw, 1),
            case Next_byte of
                <<"_"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"a"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"b"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"c"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"d"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"e"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"f"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"g"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"h"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"i"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"j"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"k"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"l"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"m"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"n"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"o"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"p"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"q"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"r"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"s"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"t"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"u"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"v"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"w"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"x"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"y"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"z"/utf8>> ->
                    name(Next_byte, Rest@38, Done);

                <<"A"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"B"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"C"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"D"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"E"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"F"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"G"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"H"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"I"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"J"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"K"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"L"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"M"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"N"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"O"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"P"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"Q"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"R"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"S"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"T"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"U"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"V"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"W"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"X"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"Y"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<"Z"/utf8>> ->
                    uppername(Next_byte, Rest@38, Done);

                <<""/utf8>> ->
                    {error, nil};

                _ ->
                    Done(
                        {unexpected_grapheme, Raw},
                        erlang:byte_size(Raw),
                        <<""/utf8>>
                    )
            end
    end.

-file("src/eyg/parser/lexer.gleam", 10).
-spec loop(binary(), integer(), list({eyg@parser@token:token(), integer()})) -> list({eyg@parser@token:token(),
    integer()}).
loop(Raw, Offset, Acc) ->
    case pop(Raw, Offset) of
        {ok, {Token, Offset@1, Rest}} ->
            loop(Rest, Offset@1, [Token | Acc]);

        {error, nil} ->
            lists:reverse(Acc)
    end.

-file("src/eyg/parser/lexer.gleam", 6).
-spec lex(binary()) -> list({eyg@parser@token:token(), integer()}).
lex(Raw) ->
    loop(Raw, 0, []).