acrostic

-module(acrostic@internal@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([parser/0]).
-export_type([pb_message_field/0, pb_message/0, pb_enum_field/0, pb_enum/0, token/0]).

-type pb_message_field() :: {field, boolean(), binary(), binary(), integer()}.

-type pb_message() :: {message, binary(), list(pb_message_field())}.

-type pb_enum_field() :: {pb_enum_field, binary(), integer()}.

-type pb_enum() :: {pb_enum, binary(), list(pb_enum_field())}.

-type token() :: message_keyword |
    enum_keyword |
    left_curly |
    right_curly |
    repeated |
    equals |
    semicolon |
    {num, integer()} |
    {comment, binary()} |
    {pascal_identifier, binary()} |
    {snake_identifier, binary()} |
    {identifier, binary()}.

-file("/Users/windy/mygleam/acrostic/src/acrostic/internal/parser.gleam", 37).
-spec parser() -> {nibble@lexer:lexer(token(), nil),
    nibble:parser(pb_message(), token(), KII),
    nibble:parser(pb_enum(), token(), KII)}.
parser() ->
    Lexer = nibble@lexer:simple(
        [nibble@lexer:keyword(
                <<"message"/utf8>>,
                <<"\\W"/utf8>>,
                message_keyword
            ),
            nibble@lexer:keyword(<<"enum"/utf8>>, <<"\\W"/utf8>>, enum_keyword),
            nibble@lexer:token(<<"{"/utf8>>, left_curly),
            nibble@lexer:token(<<"}"/utf8>>, right_curly),
            nibble@lexer:keyword(<<"repeated"/utf8>>, <<"\\W"/utf8>>, repeated),
            nibble@lexer:token(<<"="/utf8>>, equals),
            nibble@lexer:token(<<";"/utf8>>, semicolon),
            nibble@lexer:int(fun(Field@0) -> {num, Field@0} end),
            nibble@lexer:identifier(
                <<"[A-Z]"/utf8>>,
                <<"[a-zA-Z0-9_]"/utf8>>,
                gleam@set:new(),
                fun(Field@0) -> {pascal_identifier, Field@0} end
            ),
            nibble@lexer:variable(
                gleam@set:new(),
                fun(Field@0) -> {snake_identifier, Field@0} end
            ),
            begin
                _pipe = nibble@lexer:comment(
                    <<"//"/utf8>>,
                    fun(Field@0) -> {comment, Field@0} end
                ),
                nibble@lexer:ignore(_pipe)
            end,
            begin
                _pipe@1 = nibble@lexer:whitespace(nil),
                nibble@lexer:ignore(_pipe@1)
            end]
    ),
    Parse_pascal_identifier = (nibble:take_map(
        <<"Expected PascalCase identifier"/utf8>>,
        fun(Tok) -> case Tok of
                {pascal_identifier, Str} ->
                    {some, Str};

                _ ->
                    none
            end end
    )),
    Parse_snake_identifier = (nibble:take_map(
        <<"Expected snake_case identifier"/utf8>>,
        fun(Tok@1) -> case Tok@1 of
                {snake_identifier, Str@1} ->
                    {some, Str@1};

                _ ->
                    none
            end end
    )),
    Parse_identifier = (nibble:take_map(
        <<"Expected identifier"/utf8>>,
        fun(Tok@2) -> case Tok@2 of
                {snake_identifier, Str@2} ->
                    {some, Str@2};

                {pascal_identifier, Str@3} ->
                    {some, Str@3};

                _ ->
                    none
            end end
    )),
    Parse_num = (nibble:take_map(
        <<"Expected number"/utf8>>,
        fun(Tok@3) -> case Tok@3 of
                {num, Num} ->
                    {some, Num};

                _ ->
                    none
            end end
    )),
    Parse_field = (nibble:do(
        nibble:optional(nibble:token(repeated)),
        fun(Repeated) ->
            nibble:do(
                Parse_identifier,
                fun(Ty) ->
                    nibble:do(
                        Parse_snake_identifier,
                        fun(Name) ->
                            nibble:do(
                                nibble:token(equals),
                                fun(_) ->
                                    nibble:do(
                                        Parse_num,
                                        fun(Tag) ->
                                            nibble:do(
                                                nibble:token(semicolon),
                                                fun(_) ->
                                                    nibble:return(
                                                        {field,
                                                            gleam@option:is_some(
                                                                Repeated
                                                            ),
                                                            Ty,
                                                            Name,
                                                            Tag}
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    )),
    Parse_enum_field = (nibble:do(
        Parse_pascal_identifier,
        fun(Name@1) ->
            nibble:do(
                nibble:token(equals),
                fun(_) ->
                    nibble:do(
                        Parse_num,
                        fun(Tag@1) ->
                            nibble:do(
                                nibble:token(semicolon),
                                fun(_) ->
                                    nibble:return(
                                        {pb_enum_field, Name@1, Tag@1}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    )),
    Message_parser = (nibble:do(
        nibble:token(message_keyword),
        fun(_) ->
            nibble:do(
                Parse_pascal_identifier,
                fun(Message_name) ->
                    nibble:do(
                        nibble:token(left_curly),
                        fun(_) ->
                            nibble:do(
                                nibble:many(Parse_field),
                                fun(Fields) ->
                                    nibble:do(
                                        nibble:token(right_curly),
                                        fun(_) ->
                                            nibble:return(
                                                {message, Message_name, Fields}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    )),
    Enum_parser = (nibble:do(
        nibble:token(enum_keyword),
        fun(_) ->
            nibble:do(
                Parse_pascal_identifier,
                fun(Enum_name) ->
                    nibble:do(
                        nibble:token(left_curly),
                        fun(_) ->
                            nibble:do(
                                nibble:many(Parse_enum_field),
                                fun(Fields@1) ->
                                    nibble:do(
                                        nibble:token(right_curly),
                                        fun(_) ->
                                            nibble:return(
                                                {pb_enum, Enum_name, Fields@1}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    )),
    {Lexer, Message_parser, Enum_parser}.