Current section
Files
Jump to
Current section
Files
src/acrostic.erl
-module(acrostic).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([gen/3]).
-export_type([message/0, flags/0]).
-type message() :: {message,
integer(),
binary(),
list(acrostic@parser:pb_message_field())}.
-type flags() :: {flags, boolean(), boolean()}.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 482).
-spec field_is_packed(acrostic@parser:pb_message_field()) -> boolean().
field_is_packed(Field) ->
case erlang:element(3, Field) of
<<"int32"/utf8>> when erlang:element(2, Field) ->
true;
<<"int64"/utf8>> when erlang:element(2, Field) ->
true;
<<"uint32"/utf8>> when erlang:element(2, Field) ->
true;
<<"uint64"/utf8>> when erlang:element(2, Field) ->
true;
<<"bool"/utf8>> when erlang:element(2, Field) ->
true;
<<"fixed64"/utf8>> when erlang:element(2, Field) ->
true;
<<"sfixed64"/utf8>> when erlang:element(2, Field) ->
true;
<<"double"/utf8>> when erlang:element(2, Field) ->
true;
<<"fixed32"/utf8>> when erlang:element(2, Field) ->
true;
<<"sfixed32"/utf8>> when erlang:element(2, Field) ->
true;
<<"float"/utf8>> when erlang:element(2, Field) ->
true;
_ ->
false
end.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 749).
-spec get_enums(
binary(),
nibble@lexer:lexer(MAX, nil),
nibble:parser(MBD, MAX, any())
) -> list(MBD).
get_enums(Text, Lexer, Parser) ->
_assert_subject = gleam@regex:from_string(
<<"enum\\s+\\w+\\s*{[^{}]*}"/utf8>>
),
{ok, Re} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"get_enums"/utf8>>,
line => 750})
end,
_pipe = gleam@regex:scan(Re, Text),
gleam@list:map(
_pipe,
fun(A) ->
_assert_subject@1 = nibble@lexer:run(erlang:element(2, A), Lexer),
{ok, Tokens} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@1,
module => <<"acrostic"/utf8>>,
function => <<"get_enums"/utf8>>,
line => 753})
end,
_assert_subject@2 = nibble:run(Tokens, Parser),
{ok, Enum} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@2,
module => <<"acrostic"/utf8>>,
function => <<"get_enums"/utf8>>,
line => 754})
end,
Enum
end
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 759).
-spec get_structs(
binary(),
nibble@lexer:lexer(MBK, nil),
nibble:parser(MBQ, MBK, any())
) -> list({integer(), MBQ}).
get_structs(Text, Lexer, Parser) ->
_assert_subject = gleam@regex:from_string(
<<"//\\s*@gleam\\s+record\\s*\nmessage\\s+\\w+\\s*{([^{}]*)}"/utf8>>
),
{ok, Re} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"get_structs"/utf8>>,
line => 760})
end,
_pipe = gleam@regex:scan(Re, Text),
gleam@list:map(
_pipe,
fun(A) ->
_assert_subject@1 = nibble@lexer:run(erlang:element(2, A), Lexer),
{ok, Tokens} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@1,
module => <<"acrostic"/utf8>>,
function => <<"get_structs"/utf8>>,
line => 766})
end,
_assert_subject@2 = nibble:run(Tokens, Parser),
{ok, Message} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@2,
module => <<"acrostic"/utf8>>,
function => <<"get_structs"/utf8>>,
line => 767})
end,
{0, Message}
end
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 772).
-spec get_messages(
binary(),
nibble@lexer:lexer(MBX, nil),
nibble:parser(MCD, MBX, any())
) -> list({integer(), MCD}).
get_messages(Text, Lexer, Parser) ->
_assert_subject = gleam@regex:from_string(
<<"//\\s*@gleam\\s+msgid\\s*=\\s*(\\d+)\\s*\nmessage\\s+\\w+\\s*{([^{}]*)}"/utf8>>
),
{ok, Re} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"get_messages"/utf8>>,
line => 773})
end,
_pipe = gleam@regex:scan(Re, Text),
gleam@list:map(
_pipe,
fun(A) ->
_assert_subject@1 = nibble@lexer:run(erlang:element(2, A), Lexer),
{ok, Tokens} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@1,
module => <<"acrostic"/utf8>>,
function => <<"get_messages"/utf8>>,
line => 779})
end,
_assert_subject@2 = nibble:run(Tokens, Parser),
{ok, Msg} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@2,
module => <<"acrostic"/utf8>>,
function => <<"get_messages"/utf8>>,
line => 780})
end,
Msgid = begin
_pipe@1 = erlang:element(3, A),
_pipe@2 = gleam@list:first(_pipe@1),
_pipe@3 = gleam@result:lazy_unwrap(
_pipe@2,
fun() -> erlang:error(#{gleam_error => panic,
message => <<"`panic` expression evaluated."/utf8>>,
module => <<"acrostic"/utf8>>,
function => <<"get_messages"/utf8>>,
line => 784}) end
),
_pipe@4 = gleam@option:lazy_unwrap(
_pipe@3,
fun() -> erlang:error(#{gleam_error => panic,
message => <<"`panic` expression evaluated."/utf8>>,
module => <<"acrostic"/utf8>>,
function => <<"get_messages"/utf8>>,
line => 785}) end
),
_pipe@5 = gleam@int:parse(_pipe@4),
gleam@result:lazy_unwrap(
_pipe@5,
fun() -> erlang:error(#{gleam_error => panic,
message => <<"`panic` expression evaluated."/utf8>>,
module => <<"acrostic"/utf8>>,
function => <<"get_messages"/utf8>>,
line => 787}) end
)
end,
{Msgid, Msg}
end
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 793).
-spec message_to_string(
message(),
fun((acrostic@parser:pb_message_field()) -> binary())
) -> binary().
message_to_string(Message, Convert) ->
case erlang:length(erlang:element(4, Message)) > 0 of
true ->
sprinkle:format(
<<" {name}({body})\n"/utf8>>,
[{<<"name"/utf8>>, erlang:element(3, Message)},
{<<"body"/utf8>>,
begin
_pipe = erlang:element(4, Message),
_pipe@1 = gleam@list:map(_pipe, Convert),
_pipe@2 = gleam@list:fold(
_pipe@1,
<<""/utf8>>,
fun(A, B) ->
<<<<A/binary, B/binary>>/binary, ", "/utf8>>
end
),
gleam@string:drop_right(_pipe@2, 2)
end}]
);
false ->
<<<<" "/utf8, (erlang:element(3, Message))/binary>>/binary,
"\n"/utf8>>
end.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 816).
-spec to_gleam_ty(binary(), boolean()) -> binary().
to_gleam_ty(Ty, Repeated) ->
Ty@1 = case Ty of
<<"string"/utf8>> ->
<<"String"/utf8>>;
<<"int32"/utf8>> ->
<<"Int"/utf8>>;
<<"int64"/utf8>> ->
<<"Int"/utf8>>;
<<"uint32"/utf8>> ->
<<"Int"/utf8>>;
<<"uint64"/utf8>> ->
<<"Int"/utf8>>;
<<"bool"/utf8>> ->
<<"Bool"/utf8>>;
<<"fixed64"/utf8>> ->
<<"Float"/utf8>>;
<<"sfixed64"/utf8>> ->
<<"Float"/utf8>>;
<<"double"/utf8>> ->
<<"Float"/utf8>>;
<<"fixed32"/utf8>> ->
<<"Float"/utf8>>;
<<"sfixed32"/utf8>> ->
<<"Float"/utf8>>;
<<"float"/utf8>> ->
<<"Float"/utf8>>;
X ->
X
end,
case Repeated of
true ->
<<<<"List("/utf8, Ty@1/binary>>/binary, ")"/utf8>>;
false ->
Ty@1
end.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 836).
-spec pascal_to_snake(binary()) -> binary().
pascal_to_snake(Ident) ->
_assert_subject = gleam@regex:from_string(<<"[A-Z][a-z]*"/utf8>>),
{ok, Re} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"pascal_to_snake"/utf8>>,
line => 837})
end,
_pipe = gleam@regex:scan(Re, Ident),
_pipe@1 = gleam@list:map(_pipe, fun(A) -> erlang:element(2, A) end),
_pipe@2 = gleam@list:map(
_pipe@1,
fun(A@1) -> gleam@string:lowercase(A@1) end
),
_pipe@3 = gleam@list:fold(
_pipe@2,
<<""/utf8>>,
fun(A@2, B) -> <<<<A@2/binary, "_"/utf8>>/binary, B/binary>> end
),
gleam@string:drop_left(_pipe@3, 1).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 189).
-spec write_decode(list(message()), binary()) -> {ok, nil} |
{error, simplifile:file_error()}.
write_decode(Messages, Out_path) ->
_assert_subject = begin
_pipe = Messages,
_pipe@1 = gleam@list:map(
_pipe,
fun(Msg) ->
sprinkle:format(
<<"{id} -> decode_message({default},binary)\n"/utf8>>,
[{<<"id"/utf8>>,
gleam@int:to_string(erlang:element(2, Msg))},
{<<"default"/utf8>>,
<<(pascal_to_snake(erlang:element(3, Msg)))/binary,
"_default"/utf8>>}]
)
end
),
_pipe@2 = gleam@list:fold(
_pipe@1,
<<"
pub fn decode(binary: BitArray) -> Message {
let assert <<id:big-size(16), binary:bits>> = binary
case id {
"/utf8>>,
fun gleam@string:append/2
),
_pipe@3 = gleam@string:append(
_pipe@2,
<<"_ -> panic
}
}
"/utf8>>
),
simplifile:append(Out_path, _pipe@3)
end,
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_decode"/utf8>>,
line => 190})
end.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 417).
-spec write_struct_field_encoder(message(), binary()) -> nil.
write_struct_field_encoder(Struct, Out_path) ->
_assert_subject = begin
_pipe = sprinkle:format(
<<"
pub const {name}_field_encoder = FieldEncoder(
{wire_type},
{encoder}
)
"/utf8>>,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(3, Struct))},
{<<"wire_type"/utf8>>, <<"encoding.WireLenTy"/utf8>>},
{<<"encoder"/utf8>>,
<<"encode_"/utf8,
(pascal_to_snake(erlang:element(3, Struct)))/binary>>}]
),
simplifile:append(Out_path, _pipe)
end,
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_struct_field_encoder"/utf8>>,
line => 418})
end,
nil.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 451).
-spec get_reader_string(acrostic@parser:pb_message_field()) -> binary().
get_reader_string(Field) ->
case erlang:element(2, Field) of
true ->
case erlang:element(3, Field) of
<<"string"/utf8>> ->
<<"decoding.read_string(binary)"/utf8>>;
<<"int32"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_varint)"/utf8>>;
<<"int64"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_varint)"/utf8>>;
<<"uint32"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_varint)"/utf8>>;
<<"uint64"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_varint)"/utf8>>;
<<"bool"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_bool)"/utf8>>;
<<"fixed64"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_i64)"/utf8>>;
<<"sfixed64"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_i64)"/utf8>>;
<<"double"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_i64)"/utf8>>;
<<"fixed32"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_i32)"/utf8>>;
<<"sfixed32"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_i32)"/utf8>>;
<<"float"/utf8>> ->
<<"decoding.read_len_packed_field(binary, decoding.read_i32)"/utf8>>;
Ty ->
<<<<"read_"/utf8, (pascal_to_snake(Ty))/binary>>/binary,
"(binary)"/utf8>>
end;
false ->
case erlang:element(3, Field) of
<<"string"/utf8>> ->
<<"decoding.read_string(binary)"/utf8>>;
<<"int32"/utf8>> ->
<<"decoding.read_varint(binary)"/utf8>>;
<<"int64"/utf8>> ->
<<"decoding.read_varint(binary)"/utf8>>;
<<"uint32"/utf8>> ->
<<"decoding.read_varint(binary)"/utf8>>;
<<"uint64"/utf8>> ->
<<"decoding.read_varint(binary)"/utf8>>;
<<"bool"/utf8>> ->
<<"decoding.read_bool(binary)"/utf8>>;
<<"fixed64"/utf8>> ->
<<"decoding.read_i64(binary)"/utf8>>;
<<"sfixed64"/utf8>> ->
<<"decoding.read_i64(binary)"/utf8>>;
<<"double"/utf8>> ->
<<"decoding.read_i64(binary)"/utf8>>;
<<"fixed32"/utf8>> ->
<<"decoding.read_i32(binary)"/utf8>>;
<<"sfixed32"/utf8>> ->
<<"decoding.read_i32(binary)"/utf8>>;
<<"float"/utf8>> ->
<<"decoding.read_i32(binary)"/utf8>>;
Ty@1 ->
<<<<"read_"/utf8, (pascal_to_snake(Ty@1))/binary>>/binary,
"(binary)"/utf8>>
end
end.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 225).
-spec get_message_case_code(message()) -> binary().
get_message_case_code(Msg) ->
_pipe = erlang:element(4, Msg),
_pipe@1 = gleam@list:map(
_pipe,
fun(F) ->
sprinkle:format(
<<"
{field_number} -> {
let #({field_name}, binary) = {reader}
decode_message({message}, binary)
}
"/utf8>>,
[{<<"reader"/utf8>>, get_reader_string(F)},
{<<"field_number"/utf8>>,
gleam@int:to_string(erlang:element(5, F))},
{<<"field_name"/utf8>>,
(case {erlang:element(2, F), field_is_packed(F)} of
{true, false} ->
<<"value"/utf8>>;
{_, _} ->
erlang:element(4, F)
end)},
{<<"message"/utf8>>,
message_to_string(
Msg,
fun(F2) ->
case {erlang:element(4, F) =:= erlang:element(
4,
F2
),
erlang:element(2, F2),
field_is_packed(F2)} of
{true, true, false} ->
sprinkle:format(
<<"list.append({field_name}, [value])"/utf8>>,
[{<<"field_name"/utf8>>,
erlang:element(4, F2)}]
);
{_, _, _} ->
erlang:element(4, F2)
end
end
)}]
)
end
),
_pipe@2 = gleam@list:fold(
_pipe@1,
<<(message_to_string(Msg, fun(F@1) -> erlang:element(4, F@1) end))/binary,
"
-> {
let #(key, binary) = decoding.read_key(binary)
case key.field_number {
"/utf8>>,
fun gleam@string:append/2
),
gleam@string:append(
_pipe@2,
<<"
_ -> panic
}
}
"/utf8>>
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 501).
-spec get_default_value(binary(), boolean()) -> binary().
get_default_value(Ty, Repeated) ->
case to_gleam_ty(Ty, false) of
_ when Repeated ->
<<"[]"/utf8>>;
<<"Int"/utf8>> ->
<<"0"/utf8>>;
<<"Bool"/utf8>> ->
<<"False"/utf8>>;
<<"Float"/utf8>> ->
<<"0.0"/utf8>>;
<<"String"/utf8>> ->
<<"\"\""/utf8>>;
X ->
<<(pascal_to_snake(X))/binary, "_default"/utf8>>
end.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 514).
-spec get_field_encoding(acrostic@parser:pb_message_field(), binary()) -> binary().
get_field_encoding(Field, Field_prefix) ->
sprinkle:format(
<<"|> bit_array.append(encoding.{encode_field}({tag}, {value}, {field_encoder}))"/utf8>>,
[{<<"encode_field"/utf8>>, case erlang:element(2, Field) of
true ->
<<"encode_repeated_field"/utf8>>;
false ->
<<"encode_field"/utf8>>
end}, {<<"tag"/utf8>>,
gleam@int:to_string(erlang:element(5, Field))}, {<<"value"/utf8>>,
<<Field_prefix/binary, (erlang:element(4, Field))/binary>>}, {<<"field_encoder"/utf8>>,
(case erlang:element(3, Field) of
<<"string"/utf8>> ->
<<"encoding.string_field_encoder"/utf8>>;
<<"int32"/utf8>> ->
<<"encoding.int_field_encoder"/utf8>>;
<<"int64"/utf8>> ->
<<"encoding.int_field_encoder"/utf8>>;
<<"uint32"/utf8>> ->
<<"encoding.int_field_encoder"/utf8>>;
<<"uint64"/utf8>> ->
<<"encoding.int_field_encoder"/utf8>>;
<<"bool"/utf8>> ->
<<"encoding.bool_field_encoder"/utf8>>;
<<"fixed64"/utf8>> ->
<<"encoding.i64_field_encoder"/utf8>>;
<<"sfixed64"/utf8>> ->
<<"encoding.i64_field_encoder"/utf8>>;
<<"double"/utf8>> ->
<<"encoding.i64_field_encoder"/utf8>>;
<<"fixed32"/utf8>> ->
<<"encoding.i32_field_encoder"/utf8>>;
<<"sfixed32"/utf8>> ->
<<"encoding.i32_field_encoder"/utf8>>;
<<"float"/utf8>> ->
<<"encoding.i32_field_encoder"/utf8>>;
X ->
<<(pascal_to_snake(X))/binary, "_field_encoder"/utf8>>
end)}]
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 96).
-spec write_messages(list(message()), binary()) -> {ok, nil} |
{error, simplifile:file_error()}.
write_messages(Messages, Out_path) ->
_assert_subject = simplifile:append(
Out_path,
<<"pub type Message {\n"/utf8>>
),
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_messages"/utf8>>,
line => 97})
end,
_assert_subject@1 = begin
_pipe = Messages,
_pipe@1 = gleam@list:map(
_pipe,
fun(_capture) ->
message_to_string(
_capture,
fun(Field) ->
<<<<(erlang:element(4, Field))/binary, ": "/utf8>>/binary,
(to_gleam_ty(
erlang:element(3, Field),
erlang:element(2, Field)
))/binary>>
end
)
end
),
_pipe@2 = gleam@list:fold(
_pipe@1,
<<""/utf8>>,
fun gleam@string:append/2
),
simplifile:append(Out_path, _pipe@2)
end,
{ok, _} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@1,
module => <<"acrostic"/utf8>>,
function => <<"write_messages"/utf8>>,
line => 99})
end,
_assert_subject@2 = simplifile:append(Out_path, <<"}\n\n"/utf8>>),
{ok, _} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@2,
module => <<"acrostic"/utf8>>,
function => <<"write_messages"/utf8>>,
line => 107})
end,
Body = begin
_pipe@3 = Messages,
_pipe@6 = gleam@list:map(
_pipe@3,
fun(Msg) ->
sprinkle:format(
<<"
{message} -> {
{fields}
}
"/utf8>>,
[{<<"message"/utf8>>,
message_to_string(
Msg,
fun(F) -> erlang:element(4, F) end
)},
{<<"fields"/utf8>>,
begin
_pipe@4 = erlang:element(4, Msg),
_pipe@5 = gleam@list:map(
_pipe@4,
fun(_capture@1) ->
get_field_encoding(
_capture@1,
<<""/utf8>>
)
end
),
gleam@list:fold(
_pipe@5,
<<<<"<<"/utf8,
(gleam@int:to_string(
erlang:element(2, Msg)
))/binary>>/binary,
":big-size(16)>>\n"/utf8>>,
fun gleam@string:append/2
)
end}]
)
end
),
gleam@list:fold(_pipe@6, <<""/utf8>>, fun gleam@string:append/2)
end,
_assert_subject@3 = begin
_pipe@7 = <<"
pub fn encode(msg: Message) -> BitArray {
case msg {
{body}
}
}
"/utf8>>,
_pipe@8 = sprinkle:format(_pipe@7, [{<<"body"/utf8>>, Body}]),
simplifile:append(Out_path, _pipe@8)
end,
{ok, _} = case _assert_subject@3 of
{ok, _} -> _assert_subject@3;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@3,
module => <<"acrostic"/utf8>>,
function => <<"write_messages"/utf8>>,
line => 135})
end,
_assert_subject@4 = begin
_pipe@9 = Messages,
_pipe@10 = gleam@list:map(
_pipe@9,
fun(Msg@1) -> get_message_case_code(Msg@1) end
),
_pipe@11 = gleam@list:fold(
_pipe@10,
<<"
pub fn decode_message(msg: Message, binary: BitArray) -> Message {
case binary {
<<>> -> msg
_ -> case msg {
"/utf8>>,
fun gleam@string:append/2
),
_pipe@12 = gleam@string:append(
_pipe@11,
<<"
}
}
}
"/utf8>>
),
simplifile:append(Out_path, _pipe@12)
end,
{ok, _} = case _assert_subject@4 of
{ok, _} -> _assert_subject@4;
_assert_fail@4 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@4,
module => <<"acrostic"/utf8>>,
function => <<"write_messages"/utf8>>,
line => 147})
end,
_pipe@13 = Messages,
gleam@list:each(
_pipe@13,
fun(Msg@2) ->
_assert_subject@5 = begin
_pipe@14 = <<"pub const {name}_default = {value}\n"/utf8>>,
_pipe@18 = sprinkle:format(
_pipe@14,
[{<<"name"/utf8>>,
pascal_to_snake(erlang:element(3, Msg@2))},
{<<"value"/utf8>>,
begin
_pipe@15 = erlang:element(4, Msg@2),
_pipe@16 = gleam@list:map(
_pipe@15,
fun(F@1) ->
get_default_value(
erlang:element(3, F@1),
erlang:element(2, F@1)
)
end
),
_pipe@17 = gleam@list:fold(
_pipe@16,
<<(erlang:element(3, Msg@2))/binary,
"("/utf8>>,
fun(A, B) ->
<<<<A/binary, B/binary>>/binary,
","/utf8>>
end
),
gleam@string:append(_pipe@17, <<")"/utf8>>)
end}]
),
simplifile:append(Out_path, _pipe@18)
end,
{ok, _} = case _assert_subject@5 of
{ok, _} -> _assert_subject@5;
_assert_fail@5 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@5,
module => <<"acrostic"/utf8>>,
function => <<"write_messages"/utf8>>,
line => 171})
end
end
),
write_decode(Messages, Out_path).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 276).
-spec write_structs(list(message()), binary()) -> nil.
write_structs(Structs, Out_path) ->
_pipe = Structs,
gleam@list:each(
_pipe,
fun(Struct) ->
_assert_subject = simplifile:append(
Out_path,
<<<<"pub type "/utf8, (erlang:element(3, Struct))/binary>>/binary,
" {\n"/utf8>>
),
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_structs"/utf8>>,
line => 280})
end,
_assert_subject@1 = simplifile:append(
Out_path,
<<(message_to_string(
Struct,
fun(Field) ->
<<<<(erlang:element(4, Field))/binary, ": "/utf8>>/binary,
(to_gleam_ty(
erlang:element(3, Field),
erlang:element(2, Field)
))/binary>>
end
))/binary,
"}\n\n"/utf8>>
),
{ok, _} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@1,
module => <<"acrostic"/utf8>>,
function => <<"write_structs"/utf8>>,
line => 285})
end,
_assert_subject@2 = begin
_pipe@1 = <<"pub const {name}_default = {value}\n"/utf8>>,
_pipe@5 = sprinkle:format(
_pipe@1,
[{<<"name"/utf8>>,
pascal_to_snake(erlang:element(3, Struct))},
{<<"value"/utf8>>,
begin
_pipe@2 = erlang:element(4, Struct),
_pipe@3 = gleam@list:map(
_pipe@2,
fun(F) ->
get_default_value(
erlang:element(3, F),
erlang:element(2, F)
)
end
),
_pipe@4 = gleam@list:fold(
_pipe@3,
<<(erlang:element(3, Struct))/binary,
"("/utf8>>,
fun(A, B) ->
<<<<A/binary, B/binary>>/binary,
","/utf8>>
end
),
gleam@string:append(_pipe@4, <<")"/utf8>>)
end}]
),
simplifile:append(Out_path, _pipe@5)
end,
{ok, _} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@2,
module => <<"acrostic"/utf8>>,
function => <<"write_structs"/utf8>>,
line => 296})
end,
_assert_subject@3 = begin
_pipe@8 = sprinkle:format(
<<"
pub fn encode_{name}({name}: {type}) -> BitArray {
{body}
}
"/utf8>>,
[{<<"name"/utf8>>,
pascal_to_snake(erlang:element(3, Struct))},
{<<"type"/utf8>>, erlang:element(3, Struct)},
{<<"body"/utf8>>,
begin
_pipe@6 = erlang:element(4, Struct),
_pipe@7 = gleam@list:map(
_pipe@6,
fun(_capture) ->
get_field_encoding(
_capture,
<<(pascal_to_snake(
erlang:element(3, Struct)
))/binary,
"."/utf8>>
)
end
),
gleam@list:fold(
_pipe@7,
<<"<<>>\n"/utf8>>,
fun gleam@string:append/2
)
end}]
),
simplifile:append(Out_path, _pipe@8)
end,
{ok, _} = case _assert_subject@3 of
{ok, _} -> _assert_subject@3;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@3,
module => <<"acrostic"/utf8>>,
function => <<"write_structs"/utf8>>,
line => 315})
end,
_assert_subject@4 = begin
_pipe@11 = sprinkle:format(
<<"
pub fn decode_to_{name}(binary: BitArray, {name}: {typename}) -> Result({typename}, String) {
case binary {
<<>> -> Ok({name})
_ -> {
let #(key, binary) = decoding.read_key(binary)
case key.field_number {
{body}
_ -> panic
}
}
}
}
"/utf8>>,
[{<<"name"/utf8>>,
pascal_to_snake(erlang:element(3, Struct))},
{<<"typename"/utf8>>, erlang:element(3, Struct)},
{<<"body"/utf8>>,
begin
_pipe@9 = erlang:element(4, Struct),
_pipe@10 = gleam@list:map(
_pipe@9,
fun(F@1) ->
sprinkle:format(
<<"
{field_number} -> {
let #({var_name}, binary) = {reader}
decode_to_{name}(binary, {typename}(..{name}, {field_name}: {field_value}))
}
"/utf8>>,
[{<<"name"/utf8>>,
pascal_to_snake(
erlang:element(
3,
Struct
)
)},
{<<"typename"/utf8>>,
erlang:element(3, Struct)},
{<<"reader"/utf8>>,
get_reader_string(F@1)},
{<<"field_number"/utf8>>,
gleam@int:to_string(
erlang:element(5, F@1)
)},
{<<"field_name"/utf8>>,
erlang:element(4, F@1)},
{<<"var_name"/utf8>>,
(case {erlang:element(
2,
F@1
),
field_is_packed(F@1)} of
{true, false} ->
<<"value"/utf8>>;
{_, _} ->
erlang:element(
4,
F@1
)
end)},
{<<"field_value"/utf8>>,
(case {erlang:element(
2,
F@1
),
field_is_packed(F@1)} of
{true, false} ->
sprinkle:format(
<<"list.append({name}.{field_name}, [value])"/utf8>>,
[{<<"name"/utf8>>,
pascal_to_snake(
erlang:element(
3,
Struct
)
)},
{<<"field_name"/utf8>>,
erlang:element(
4,
F@1
)}]
);
{_, _} ->
erlang:element(
4,
F@1
)
end)}]
)
end
),
gleam@list:fold(
_pipe@10,
<<""/utf8>>,
fun gleam@string:append/2
)
end}]
),
simplifile:append(Out_path, _pipe@11)
end,
{ok, _} = case _assert_subject@4 of
{ok, _} -> _assert_subject@4;
_assert_fail@4 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@4,
module => <<"acrostic"/utf8>>,
function => <<"write_structs"/utf8>>,
line => 338})
end,
_assert_subject@5 = begin
_pipe@12 = sprinkle:format(
<<"
pub fn read_{name}(binary: BitArray) -> #({typename}, BitArray) {
decoding.read_len_field(binary, decode_to_{name}(_, {name}_default))
}
"/utf8>>,
[{<<"name"/utf8>>,
pascal_to_snake(erlang:element(3, Struct))},
{<<"typename"/utf8>>, erlang:element(3, Struct)}]
),
simplifile:append(Out_path, _pipe@12)
end,
{ok, _} = case _assert_subject@5 of
{ok, _} -> _assert_subject@5;
_assert_fail@5 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@5,
module => <<"acrostic"/utf8>>,
function => <<"write_structs"/utf8>>,
line => 402})
end,
write_struct_field_encoder(Struct, Out_path)
end
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 671).
-spec write_enum_field_encoder(acrostic@parser:pb_enum(), binary()) -> nil.
write_enum_field_encoder(Enum, Out_path) ->
_assert_subject = begin
_pipe = sprinkle:format(
<<"
pub const {name}_field_encoder = FieldEncoder(
{wire_type},
{encoder}
)
"/utf8>>,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(2, Enum))},
{<<"wire_type"/utf8>>, <<"encoding.WireVarIntTy"/utf8>>},
{<<"encoder"/utf8>>,
<<"encode_"/utf8,
(pascal_to_snake(erlang:element(2, Enum)))/binary>>}]
),
simplifile:append(Out_path, _pipe)
end,
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_enum_field_encoder"/utf8>>,
line => 672})
end,
nil.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 690).
-spec write_int_to_enum(acrostic@parser:pb_enum(), binary()) -> nil.
write_int_to_enum(Enum, Out_path) ->
Head = sprinkle:format(
<<"
pub fn int_to_{name}(n: Int) -> {typename} {
case n {
"/utf8>>,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(2, Enum))},
{<<"typename"/utf8>>, erlang:element(2, Enum)}]
),
_assert_subject = begin
_pipe = erlang:element(3, Enum),
_pipe@1 = gleam@list:map(
_pipe,
fun(F) ->
sprinkle:format(
<<"{key} -> {value}\n"/utf8>>,
[{<<"key"/utf8>>, gleam@int:to_string(erlang:element(3, F))},
{<<"value"/utf8>>, erlang:element(2, F)}]
)
end
),
_pipe@2 = gleam@list:fold(_pipe@1, Head, fun gleam@string:append/2),
_pipe@3 = gleam@string:append(
_pipe@2,
<<"
_ -> panic
}}
"/utf8>>
),
simplifile:append(Out_path, _pipe@3)
end,
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_int_to_enum"/utf8>>,
line => 700})
end,
nil.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 720).
-spec write_enum_to_int(acrostic@parser:pb_enum(), binary()) -> nil.
write_enum_to_int(Enum, Out_path) ->
Head = sprinkle:format(
<<"
pub fn {name}_to_int({name}: {typename}) -> Int {
case {name} {
"/utf8>>,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(2, Enum))},
{<<"typename"/utf8>>, erlang:element(2, Enum)}]
),
_assert_subject = begin
_pipe = erlang:element(3, Enum),
_pipe@1 = gleam@list:map(
_pipe,
fun(F) ->
sprinkle:format(
<<"{key} -> {value}\n"/utf8>>,
[{<<"key"/utf8>>, erlang:element(2, F)},
{<<"value"/utf8>>,
gleam@int:to_string(erlang:element(3, F))}]
)
end
),
_pipe@2 = gleam@list:fold(_pipe@1, Head, fun gleam@string:append/2),
_pipe@3 = gleam@string:append(_pipe@2, <<"
}}
"/utf8>>),
simplifile:append(Out_path, _pipe@3)
end,
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_enum_to_int"/utf8>>,
line => 730})
end,
nil.
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 559).
-spec write_enums(list(acrostic@parser:pb_enum()), binary(), flags()) -> nil.
write_enums(Enums, Out_path, Flags) ->
_pipe = Enums,
gleam@list:each(
_pipe,
fun(Enum) ->
_assert_subject = simplifile:append(
Out_path,
<<<<"pub type "/utf8, (erlang:element(2, Enum))/binary>>/binary,
" {\n"/utf8>>
),
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 563})
end,
_pipe@1 = erlang:element(3, Enum),
gleam@list:each(
_pipe@1,
fun(Field) ->
_assert_subject@1 = simplifile:append(
Out_path,
<<<<" "/utf8, (erlang:element(2, Field))/binary>>/binary,
"\n"/utf8>>
),
{ok, _} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@1,
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 570})
end
end
),
_assert_subject@2 = simplifile:append(Out_path, <<"}\n\n"/utf8>>),
{ok, _} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@2,
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 573})
end,
_assert_subject@3 = begin
_pipe@2 = <<"pub const {name}_default = {value}\n"/utf8>>,
_pipe@4 = sprinkle:format(
_pipe@2,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(2, Enum))},
{<<"value"/utf8>>,
case begin
_pipe@3 = erlang:element(3, Enum),
gleam@list:first(_pipe@3)
end of
{ok, F} ->
erlang:element(2, F);
_ ->
erlang:error(#{gleam_error => panic,
message => (<<"Invalid empty enum: "/utf8,
(erlang:element(2, Enum))/binary>>),
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 583})
end}]
),
simplifile:append(Out_path, _pipe@4)
end,
{ok, _} = case _assert_subject@3 of
{ok, _} -> _assert_subject@3;
_assert_fail@3 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@3,
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 577})
end,
_assert_subject@4 = begin
_pipe@8 = sprinkle:format(
<<"
pub fn encode_{name}({name}: {type}) -> BitArray {
{body}
}
"/utf8>>,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(2, Enum))},
{<<"type"/utf8>>, erlang:element(2, Enum)},
{<<"body"/utf8>>,
begin
_pipe@5 = erlang:element(3, Enum),
_pipe@6 = gleam@list:map(
_pipe@5,
fun(F@1) ->
sprinkle:format(
<<" {key} -> encoding.encode_varint({value})\n"/utf8>>,
[{<<"key"/utf8>>,
erlang:element(2, F@1)},
{<<"value"/utf8>>,
gleam@int:to_string(
erlang:element(3, F@1)
)}]
)
end
),
_pipe@7 = gleam@list:fold(
_pipe@6,
<<<<"case "/utf8,
(pascal_to_snake(
erlang:element(2, Enum)
))/binary>>/binary,
" {\n"/utf8>>,
fun gleam@string:append/2
),
gleam@string:append(_pipe@7, <<" }"/utf8>>)
end}]
),
simplifile:append(Out_path, _pipe@8)
end,
{ok, _} = case _assert_subject@4 of
{ok, _} -> _assert_subject@4;
_assert_fail@4 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@4,
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 592})
end,
_assert_subject@5 = begin
_pipe@13 = sprinkle:format(
<<"
pub fn read_{name}(binary: BitArray) -> #({type}, BitArray) {
let #(num, binary) = decoding.read_varint(binary)
{body}
}
"/utf8>>,
[{<<"name"/utf8>>, pascal_to_snake(erlang:element(2, Enum))},
{<<"type"/utf8>>, erlang:element(2, Enum)},
{<<"body"/utf8>>,
begin
_pipe@9 = erlang:element(3, Enum),
_pipe@10 = gleam@list:map(
_pipe@9,
fun(F@2) ->
sprinkle:format(
<<" {key} -> {value}\n"/utf8>>,
[{<<"key"/utf8>>,
gleam@int:to_string(
erlang:element(3, F@2)
)},
{<<"value"/utf8>>,
<<<<"#("/utf8,
(erlang:element(
2,
F@2
))/binary>>/binary,
", binary)"/utf8>>}]
)
end
),
_pipe@11 = gleam@list:fold(
_pipe@10,
<<"case num {\n"/utf8>>,
fun gleam@string:append/2
),
_pipe@12 = gleam@string:append(
_pipe@11,
<<" _ -> panic\n"/utf8>>
),
gleam@string:append(_pipe@12, <<" }\n"/utf8>>)
end}]
),
simplifile:append(Out_path, _pipe@13)
end,
{ok, _} = case _assert_subject@5 of
{ok, _} -> _assert_subject@5;
_assert_fail@5 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail@5,
module => <<"acrostic"/utf8>>,
function => <<"write_enums"/utf8>>,
line => 622})
end,
_ = case erlang:element(2, Flags) of
true ->
write_enum_to_int(Enum, Out_path);
_ ->
nil
end,
_ = case erlang:element(3, Flags) of
true ->
write_int_to_enum(Enum, Out_path);
_ ->
nil
end,
write_enum_field_encoder(Enum, Out_path)
end
).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 37).
-spec generate_proto(binary(), binary(), flags()) -> binary().
generate_proto(Text, Out_path, Flags) ->
{Lexer, Message_parser, Enum_parser} = acrostic@parser:parser(),
Enums = get_enums(Text, Lexer, Enum_parser),
Structs = begin
_pipe = get_structs(Text, Lexer, Message_parser),
gleam@list:map(
_pipe,
fun(A) ->
{message,
erlang:element(1, A),
erlang:element(2, (erlang:element(2, A))),
erlang:element(3, (erlang:element(2, A)))}
end
)
end,
Messages = begin
_pipe@1 = get_messages(Text, Lexer, Message_parser),
gleam@list:map(
_pipe@1,
fun(A@1) ->
{message,
erlang:element(1, A@1),
erlang:element(2, (erlang:element(2, A@1))),
erlang:element(3, (erlang:element(2, A@1)))}
end
)
end,
_assert_subject = begin
_pipe@2 = <<"
import gleam/list
import gleam/bit_array
import acrostic/encoding.{type FieldEncoder, FieldEncoder}
import acrostic/decoding
"/utf8>>,
simplifile:write(Out_path, _pipe@2)
end,
{ok, _} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
value => _assert_fail,
module => <<"acrostic"/utf8>>,
function => <<"generate_proto"/utf8>>,
line => 51})
end,
write_enums(Enums, Out_path, Flags),
_ = case erlang:length(Structs) > 0 of
true ->
_ = simplifile:append(
Out_path,
<<"// struct start -----------------------------------\n"/utf8>>
),
write_structs(Structs, Out_path);
_ ->
nil
end,
_ = case erlang:length(Messages) > 0 of
true ->
_ = simplifile:append(
Out_path,
<<"// messages start -----------------------------------\n"/utf8>>
),
_ = write_messages(Messages, Out_path),
nil;
_ ->
nil
end,
acrostic@helper:cmd(<<"gleam format "/utf8, Out_path/binary>>).
-file("/Users/windy/study/gleam/acrostic/src/acrostic.gleam", 23).
-spec gen(list(binary()), binary(), flags()) -> nil.
gen(Protos, Out_path, Flags) ->
_pipe = Protos,
_pipe@1 = gleam@list:map(
_pipe,
fun(Filepath) -> case simplifile:read(Filepath) of
{ok, Content} ->
Content;
{error, E} ->
erlang:error(#{gleam_error => panic,
message => gleam@string:inspect(E),
module => <<"acrostic"/utf8>>,
function => <<"gen"/utf8>>,
line => 28})
end end
),
_pipe@2 = gleam@list:fold(_pipe@1, <<""/utf8>>, fun gleam@string:append/2),
generate_proto(_pipe@2, Out_path, Flags),
gleam@io:println(<<"done"/utf8>>).