#include "rapidproto/parser.hpp"
#include <cctype>
#include <charconv>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <locale>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <system_error>
#include <utility>
#include <variant>
#include <vector>
#include "rapidproto/ast.hpp"
#include "rapidproto/combinators.hpp"
#include "rapidproto/lexer.hpp"
#include "rapidproto/range.hpp"
#include "rapidproto/result.hpp"
#include "rapidproto/scalar.hpp"
namespace rapidproto {
namespace {
constexpr int kMaxParseDepth = 50;
int& parse_depth() {
thread_local int depth = 0;
return depth;
}
class DepthGuard {
public:
DepthGuard() : m_within(++parse_depth() <= kMaxParseDepth) {}
~DepthGuard() { --parse_depth(); }
DepthGuard(const DepthGuard&) = delete;
DepthGuard& operator=(const DepthGuard&) = delete;
DepthGuard(DepthGuard&&) = delete;
DepthGuard& operator=(DepthGuard&&) = delete;
[[nodiscard]] bool within_limit() const { return m_within; }
private:
bool m_within;
};
Error too_deep() {
Error error{0, "maximum nesting depth exceeded"};
error.fatal = true;
return error;
}
bool is_keyword(TokenKind k) {
return k >= TokenKind::KwSyntax && k <= TokenKind::KwNan;
}
bool is_name_token(const Token& t) {
return t.kind == TokenKind::Identifier || is_keyword(t.kind);
}
auto kind(TokenKind k) {
return one([k](const Token& t) { return t.kind == k; });
}
auto name_token() {
return one([](const Token& t) { return is_name_token(t); });
}
auto sign_token() {
return one(
[](const Token& t) { return t.kind == TokenKind::Minus || t.kind == TokenKind::Plus; });
}
auto number_token() {
return one([](const Token& t) {
return t.kind == TokenKind::IntLiteral || t.kind == TokenKind::FloatLiteral ||
t.kind == TokenKind::KwInf || t.kind == TokenKind::KwNan;
});
}
constexpr int kDecimalBase = 10;
constexpr int kHexBase = 16;
constexpr int kOctalBase = 8;
constexpr unsigned kInt64SignBitShift = 63;
OptionValue make_float(std::string_view text, bool negative);
std::pair<int, std::string_view> split_int_literal(std::string_view text) {
if (text.size() >= 2 && text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) {
return {kHexBase, text.substr(2)};
}
if (text.size() > 1 && text[0] == '0') {
return {kOctalBase, text.substr(1)};
}
return {kDecimalBase, text};
}
OptionValue make_int(std::string_view text, bool negative) {
const auto [base, digits] = split_int_literal(text);
std::uint64_t mag = 0;
const char* first = digits.data();
const char* last = first + digits.size();
const auto ec = std::from_chars(first, last, mag, base).ec;
if (ec == std::errc::result_out_of_range) {
return make_float(text, negative); }
if (negative) {
const std::uint64_t int64_min_magnitude = std::uint64_t{1} << kInt64SignBitShift;
if (mag > int64_min_magnitude) {
return make_float(text, negative); }
return OptionValue{mag == int64_min_magnitude ? INT64_MIN
: -static_cast<std::int64_t>(mag)};
}
return OptionValue{mag};
}
OptionValue make_float(std::string_view text, bool negative) {
std::istringstream stream{std::string(text)};
stream.imbue(std::locale::classic());
double v = 0;
stream >> v;
if (stream.fail() && v >= std::numeric_limits<double>::max()) {
v = HUGE_VAL; }
if (negative) {
v = -v;
}
return OptionValue{v};
}
OptionValue interpret_number(const std::optional<Token>& sign, const Token& num) {
const bool negative = sign.has_value() && sign->kind == TokenKind::Minus;
if (num.kind == TokenKind::IntLiteral) {
return make_int(num.text, negative);
}
if (num.kind == TokenKind::FloatLiteral) {
return make_float(num.text, negative);
}
if (num.kind == TokenKind::KwInf) {
return OptionValue{negative ? -HUGE_VAL : HUGE_VAL};
}
const double nan_value = std::nan(""); return OptionValue{negative ? -nan_value : nan_value};
}
Result<Parsed<OptionValue, Token>> parse_scalar(Range<Token> in);
Result<Parsed<MessageLiteral, Token>> parse_message_literal(Range<Token> in);
Result<Parsed<ListLiteral, Token>> parse_list_literal(Range<Token> in);
Result<Parsed<MessageLiteralField, Token>> parse_message_field(Range<Token> in);
Result<Parsed<OptionValue, Token>> parse_field_value(Range<Token> in);
Result<Parsed<std::vector<OptionNameComponent>, Token>> parse_option_name(Range<Token> in);
auto qualified_ident() {
return map(seq(name_token(), many(preceded(kind(TokenKind::Dot), name_token()))),
[](auto parts) {
std::string out(std::get<0>(parts).text);
for (const Token& t : std::get<1>(parts)) {
out += '.';
out.append(t.text);
}
return out;
});
}
auto field_name() {
return alt(map(name_token(),
[](const Token& t) {
MessageLiteralField f;
f.name = std::string(t.text); return f;
}),
map(seq(kind(TokenKind::LBracket), qualified_ident(),
opt(preceded(kind(TokenKind::Slash), qualified_ident())),
kind(TokenKind::RBracket)),
[](auto parts) {
MessageLiteralField f;
auto& type = std::get<2>(parts);
if (type.has_value()) { f.name_kind = MessageFieldNameKind::AnyTypeUrl;
f.name = std::move(std::get<1>(parts));
f.any_type = std::move(*type);
} else {
f.name_kind = MessageFieldNameKind::Extension;
f.name = std::move(std::get<1>(parts));
}
return f;
}));
}
auto option_name_component() {
return alt(map(name_token(),
[](const Token& t) { return OptionNameComponent{std::string(t.text), false}; }),
map(seq(kind(TokenKind::LParen), opt(kind(TokenKind::Dot)), qualified_ident(),
kind(TokenKind::RParen)),
[](auto parts) {
std::string name;
if (std::get<1>(parts).has_value()) {
name += '.'; }
name += std::get<2>(parts);
return OptionNameComponent{std::move(name), true};
}));
}
auto message_body() {
return map(many(seq(parse_message_field,
opt(alt(kind(TokenKind::Comma), kind(TokenKind::Semicolon))))),
[](auto items) {
std::vector<MessageLiteralField> fields;
fields.reserve(items.size());
for (auto& item : items) {
fields.push_back(std::move(std::get<0>(item)));
}
return fields;
});
}
auto compact_option() {
return map(seq(parse_option_name, cut(kind(TokenKind::Equals)), cut(parse_value)),
[](auto parts) {
Option opt;
opt.name = std::move(std::get<0>(parts));
opt.value = std::move(std::get<2>(parts));
return opt;
});
}
Result<Parsed<OptionValue, Token>> parse_scalar(Range<Token> in) {
return alt(
map(seq(opt(sign_token()), number_token()),
[](auto parts) { return interpret_number(std::get<0>(parts), std::get<1>(parts)); }),
map(kind(TokenKind::StringLiteral),
[](Token t) { return OptionValue{std::move(t.str_value)}; }),
map(name_token(),
[](const Token& t) { return OptionValue{Identifier{std::string(t.text)}}; }))(in);
}
Result<Parsed<std::vector<OptionNameComponent>, Token>> parse_option_name(Range<Token> in) {
return map(
seq(option_name_component(), many(preceded(kind(TokenKind::Dot), option_name_component()))),
[](auto parts) {
std::vector<OptionNameComponent> out;
out.push_back(std::move(std::get<0>(parts)));
for (auto& component : std::get<1>(parts)) {
out.push_back(std::move(component));
}
return out;
})(in);
}
Result<Parsed<OptionValue, Token>> parse_field_value(Range<Token> in) {
return alt(
preceded(kind(TokenKind::Colon), parse_value),
map(parse_message_literal, [](MessageLiteral m) { return OptionValue{std::move(m)}; }),
map(parse_list_literal, [](ListLiteral l) { return OptionValue{std::move(l)}; }))(in);
}
Result<Parsed<MessageLiteralField, Token>> parse_message_field(Range<Token> in) {
return map(seq(field_name(), parse_field_value), [](auto parts) {
MessageLiteralField field = std::move(std::get<0>(parts));
field.value = std::move(std::get<1>(parts));
return field;
})(in);
}
Result<Parsed<MessageLiteral, Token>> parse_message_literal(Range<Token> in) {
const DepthGuard guard;
if (!guard.within_limit()) {
return too_deep();
}
return alt(
map(delimited(kind(TokenKind::LBrace), message_body(), cut(kind(TokenKind::RBrace))),
[](std::vector<MessageLiteralField> f) { return MessageLiteral{std::move(f)}; }),
map(delimited(kind(TokenKind::LAngle), message_body(), cut(kind(TokenKind::RAngle))),
[](std::vector<MessageLiteralField> f) { return MessageLiteral{std::move(f)}; }))(in);
}
Result<Parsed<ListLiteral, Token>> parse_list_literal(Range<Token> in) {
const DepthGuard guard;
if (!guard.within_limit()) {
return too_deep();
}
return map(
delimited(kind(TokenKind::LBracket), separated_list(parse_value, kind(TokenKind::Comma)),
cut(kind(TokenKind::RBracket))),
[](std::vector<OptionValue> elems) { return ListLiteral{std::move(elems)}; })(in);
}
std::int32_t parse_int32(std::string_view text, bool negative) {
const auto [base, digits] = split_int_literal(text);
std::uint64_t mag = 0;
const char* first = digits.data();
const char* last = first + digits.size();
std::from_chars(first, last, mag, base);
const std::uint64_t value = negative ? std::uint64_t{0} - mag : mag;
return static_cast<std::int32_t>(value);
}
template <typename T>
std::vector<T> prepend(T first, std::vector<T> rest) {
std::vector<T> out;
out.reserve(rest.size() + 1);
out.push_back(std::move(first));
for (auto& item : rest) {
out.push_back(std::move(item));
}
return out;
}
auto signed_int() {
return map(seq(opt(kind(TokenKind::Minus)), kind(TokenKind::IntLiteral)), [](auto parts) {
return parse_int32(std::get<1>(parts).text, std::get<0>(parts).has_value());
});
}
Result<Parsed<NumberRange, Token>> reserved_range(Range<Token> in, std::int32_t max_sentinel) {
auto bound =
alt(map(kind(TokenKind::KwMax), [max_sentinel](const Token&) { return max_sentinel; }),
signed_int());
return map(seq(signed_int(), opt(preceded(kind(TokenKind::KwTo), bound))), [](auto parts) {
NumberRange range;
range.start = std::get<0>(parts);
range.end = std::get<1>(parts).has_value() ? *std::get<1>(parts) : range.start;
return range;
})(in);
}
auto reserved_range(std::int32_t max_sentinel) {
return [max_sentinel](Range<Token> in) { return reserved_range(in, max_sentinel); };
}
auto reserved_name() {
return alt(map(kind(TokenKind::StringLiteral), [](Token t) { return std::move(t.str_value); }),
map(name_token(), [](const Token& t) { return std::string(t.text); }));
}
Result<Parsed<ReservedNode, Token>> parse_reserved(Range<Token> in, std::int32_t max_sentinel) {
auto ranges = map(seq(reserved_range(max_sentinel),
many(preceded(kind(TokenKind::Comma), reserved_range(max_sentinel)))),
[](auto parts) {
ReservedNode node;
node.ranges =
prepend(std::move(std::get<0>(parts)), std::move(std::get<1>(parts)));
return node;
});
auto names = map(seq(reserved_name(), many(preceded(kind(TokenKind::Comma), reserved_name()))),
[](auto parts) {
ReservedNode node;
node.names =
prepend(std::move(std::get<0>(parts)), std::move(std::get<1>(parts)));
return node;
});
return delimited(kind(TokenKind::KwReserved), alt(ranges, names),
cut(kind(TokenKind::Semicolon)))(in);
}
auto enum_value_decl() {
return map(seq(name_token(), cut(kind(TokenKind::Equals)), cut(signed_int()),
opt(parse_compact_options), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
EnumValueNode value;
value.name = std::string(std::get<0>(parts).text);
value.number = std::get<2>(parts);
if (std::get<3>(parts).has_value()) {
value.options = std::move(*std::get<3>(parts));
}
return value;
});
}
auto visibility_modifier() {
return opt(alt(map(kind(TokenKind::KwExport), [](const Token&) { return Visibility::Export; }),
map(kind(TokenKind::KwLocal), [](const Token&) { return Visibility::Local; })));
}
using EnumElement = std::variant<EnumValueNode, Option, ReservedNode, std::monostate>;
auto enum_body() {
return many(
alt(map(parse_option_decl, [](Option o) { return EnumElement{std::move(o)}; }),
map([](Range<Token> i) { return parse_reserved(i, kMaxEnumNumber); },
[](ReservedNode r) { return EnumElement{std::move(r)}; }),
map(enum_value_decl(), [](EnumValueNode v) { return EnumElement{std::move(v)}; }),
map(kind(TokenKind::Semicolon),
[](const Token&) { return EnumElement{std::monostate{}}; })));
}
EnumNode assemble_enum(std::string_view name, std::vector<EnumElement>& elements,
SyntaxLevel syntax) {
EnumNode node;
node.name = std::string(name);
node.openness = syntax == SyntaxLevel::Proto2 ? EnumOpenness::Closed : EnumOpenness::Open;
for (auto& element : elements) {
if (auto* value = std::get_if<EnumValueNode>(&element)) {
node.values.push_back(std::move(*value));
} else if (auto* option = std::get_if<Option>(&element)) {
node.options.push_back(std::move(*option));
} else if (auto* reserved = std::get_if<ReservedNode>(&element)) {
node.reserved.push_back(std::move(*reserved));
}
}
return node;
}
auto type_name() {
return map(seq(opt(kind(TokenKind::Dot)), qualified_ident()), [](auto parts) {
std::string out;
if (std::get<0>(parts).has_value()) {
out += '.';
}
out += std::get<1>(parts);
return out;
});
}
auto field_number() {
return map(kind(TokenKind::IntLiteral),
[](const Token& t) { return parse_int32(t.text, false); });
}
enum class Cardinality : std::uint8_t { Required, Optional, Repeated };
auto cardinality() {
return alt(
map(kind(TokenKind::KwRequired), [](const Token&) { return Cardinality::Required; }),
map(kind(TokenKind::KwOptional), [](const Token&) { return Cardinality::Optional; }),
map(kind(TokenKind::KwRepeated), [](const Token&) { return Cardinality::Repeated; }));
}
RepeatedEncoding default_repeated_encoding(std::string_view type, SyntaxLevel syntax) {
if (!is_packable_scalar(type)) {
return RepeatedEncoding::Expanded; }
return syntax == SyntaxLevel::Proto2 ? RepeatedEncoding::Expanded : RepeatedEncoding::Packed;
}
FieldNode build_field(std::optional<Cardinality> card, std::string type, std::string_view name,
std::int32_t number, std::optional<std::vector<Option>> options,
SyntaxLevel syntax) {
FieldNode field;
field.name = std::string(name);
field.type_name = std::move(type);
field.number = number;
if (options.has_value()) {
field.options = std::move(*options);
}
if (card == Cardinality::Repeated) {
field.is_repeated = true;
field.repeated_encoding = default_repeated_encoding(field.type_name, syntax);
} else if (card == Cardinality::Required) {
field.presence = FieldPresence::Required;
} else if (!card.has_value() && syntax == SyntaxLevel::Proto3) {
field.presence = FieldPresence::Implicit;
} else {
field.presence = FieldPresence::Explicit;
}
return field;
}
Result<Parsed<FieldNode, Token>> oneof_field(Range<Token> in) {
return map(seq(type_name(), name_token(), cut(kind(TokenKind::Equals)), cut(field_number()),
opt(parse_compact_options), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
FieldNode field;
field.type_name = std::move(std::get<0>(parts));
field.name = std::string(std::get<1>(parts).text);
field.offset = std::get<1>(parts).byte_offset; field.number = std::get<3>(parts);
field.presence = FieldPresence::Explicit;
if (std::get<4>(parts).has_value()) {
field.options = std::move(*std::get<4>(parts));
}
return field;
})(in);
}
std::string to_lower(std::string_view text) {
std::string out(text);
for (char& c : out) {
c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
}
return out;
}
template <typename... Fs>
struct overloaded : Fs... {
using Fs::operator()...;
};
template <typename... Fs>
overloaded(Fs...) -> overloaded<Fs...>;
struct GroupDecl {
FieldNode field;
MessageNode message;
};
struct ExtendBundle {
ExtendNode node;
std::vector<MessageNode> group_messages;
};
struct OneofBundle {
OneofNode node;
std::vector<MessageNode> group_messages;
};
using OneofElement = std::variant<FieldNode, GroupDecl, Option>;
OneofBundle assemble_oneof(std::string_view name, std::vector<OneofElement>& elements) {
OneofBundle bundle;
bundle.node.name = std::string(name);
for (auto& element : elements) {
if (auto* field = std::get_if<FieldNode>(&element)) {
bundle.node.fields.push_back(std::move(*field));
} else if (auto* group = std::get_if<GroupDecl>(&element)) {
bundle.node.fields.push_back(std::move(group->field));
bundle.group_messages.push_back(std::move(group->message));
} else if (auto* option = std::get_if<Option>(&element)) {
bundle.node.options.push_back(std::move(*option));
}
}
return bundle;
}
struct MessageElement {
std::variant<FieldNode, MapFieldNode, OneofBundle, EnumNode, MessageNode, ReservedNode,
ExtensionRangeNode, ExtendBundle, Option, GroupDecl, std::monostate>
v;
};
Result<Parsed<std::vector<MessageElement>, Token>> message_body(Range<Token> in,
const ParseContext& ctx);
Result<Parsed<GroupDecl, Token>> parse_group(Range<Token> in, const ParseContext& ctx);
Result<Parsed<std::vector<OneofElement>, Token>> oneof_body(Range<Token> in,
const ParseContext& ctx);
Result<Parsed<OneofBundle, Token>> parse_oneof(Range<Token> in, const ParseContext& ctx);
Result<Parsed<ExtendBundle, Token>> parse_extend(Range<Token> in, const ParseContext& ctx);
Result<Parsed<ExtensionRangeNode, Token>> extension_range(Range<Token> in) {
auto ranges =
map(seq(reserved_range(kMaxMessageFieldNumber),
many(preceded(kind(TokenKind::Comma), reserved_range(kMaxMessageFieldNumber)))),
[](auto parts) {
return prepend(std::move(std::get<0>(parts)), std::move(std::get<1>(parts)));
});
return map(seq(preceded(kind(TokenKind::KwExtensions), ranges), opt(parse_compact_options),
cut(kind(TokenKind::Semicolon))),
[](auto parts) {
ExtensionRangeNode node;
node.ranges = std::move(std::get<0>(parts));
if (std::get<1>(parts).has_value()) {
node.options = std::move(*std::get<1>(parts));
}
return node;
})(in);
}
MessageNode assemble_message(std::string_view name, std::vector<MessageElement>& elements) {
MessageNode node;
node.name = std::string(name);
for (auto& element : elements) {
std::visit(overloaded{[&](FieldNode& f) { node.fields.push_back(std::move(f)); },
[&](MapFieldNode& m) { node.map_fields.push_back(std::move(m)); },
[&](OneofBundle& b) {
node.oneofs.push_back(std::move(b.node));
for (auto& gm : b.group_messages) {
node.nested_messages.push_back(std::move(gm));
}
},
[&](EnumNode& e) { node.enums.push_back(std::move(e)); },
[&](MessageNode& m) { node.nested_messages.push_back(std::move(m)); },
[&](ReservedNode& r) { node.reserved.push_back(std::move(r)); },
[&](ExtensionRangeNode& x) {
node.extension_ranges.push_back(std::move(x));
},
[&](ExtendBundle& b) {
node.extends.push_back(std::move(b.node));
for (auto& gm : b.group_messages) {
node.nested_messages.push_back(std::move(gm));
}
},
[&](Option& o) { node.options.push_back(std::move(o)); },
[&](GroupDecl& g) {
node.fields.push_back(std::move(g.field));
node.nested_messages.push_back(std::move(g.message));
},
[](std::monostate) {}},
element.v);
}
return node;
}
Result<Parsed<OneofBundle, Token>> parse_oneof(Range<Token> in, const ParseContext& ctx) {
return map(
seq(
kind(TokenKind::KwOneof), cut(name_token()), cut(kind(TokenKind::LBrace)),
[ctx](Range<Token> i) { return oneof_body(i, ctx); }, cut(kind(TokenKind::RBrace))),
[](auto parts) { return assemble_oneof(std::get<1>(parts).text, std::get<3>(parts)); })(in);
}
Result<Parsed<OneofElement, Token>> oneof_element(Range<Token> in, const ParseContext& ctx) {
if (!in.empty() &&
(in.front().kind == TokenKind::KwRequired || in.front().kind == TokenKind::KwOptional ||
in.front().kind == TokenKind::KwRepeated)) {
Error error{0, "a oneof member must not have a label (required/optional/repeated)"};
error.fatal = true;
return error;
}
return alt(map(parse_option_decl, [](Option o) { return OneofElement{std::move(o)}; }),
map([ctx](Range<Token> i) { return parse_group(i, ctx); },
[](GroupDecl g) { return OneofElement{std::move(g)}; }),
map(oneof_field, [](FieldNode f) { return OneofElement{std::move(f)}; }))(in);
}
Result<Parsed<std::vector<OneofElement>, Token>> oneof_body(Range<Token> in,
const ParseContext& ctx) {
return many([ctx](Range<Token> i) { return oneof_element(i, ctx); })(in);
}
Result<Parsed<MessageElement, Token>> message_element(Range<Token> in, const ParseContext& ctx) {
return alt(
map(parse_option_decl, [](Option o) { return MessageElement{std::move(o)}; }),
map(parse_map_field, [](MapFieldNode m) { return MessageElement{std::move(m)}; }),
map([ctx](Range<Token> i) { return parse_oneof(i, ctx); },
[](OneofBundle b) { return MessageElement{std::move(b)}; }),
map([](Range<Token> i) { return parse_reserved(i, kMaxMessageFieldNumber); },
[](ReservedNode r) { return MessageElement{std::move(r)}; }),
map(extension_range, [](ExtensionRangeNode x) { return MessageElement{std::move(x)}; }),
map([ctx](Range<Token> i) { return parse_extend(i, ctx); },
[](ExtendBundle b) { return MessageElement{std::move(b)}; }),
map([ctx](Range<Token> i) { return parse_message(i, ctx); },
[](MessageNode m) { return MessageElement{std::move(m)}; }),
map([ctx](Range<Token> i) { return parse_enum(i, ctx); },
[](EnumNode e) { return MessageElement{std::move(e)}; }),
map([ctx](Range<Token> i) { return parse_group(i, ctx); },
[](GroupDecl g) { return MessageElement{std::move(g)}; }),
map([ctx](Range<Token> i) { return parse_field(i, ctx); },
[](FieldNode f) { return MessageElement{std::move(f)}; }),
map(kind(TokenKind::Semicolon),
[](const Token&) { return MessageElement{std::monostate{}}; }))(in);
}
Result<Parsed<std::vector<MessageElement>, Token>> message_body(Range<Token> in,
const ParseContext& ctx) {
const DepthGuard guard;
if (!guard.within_limit()) {
return too_deep();
}
return many([ctx](Range<Token> i) { return message_element(i, ctx); })(in);
}
Result<Parsed<GroupDecl, Token>> parse_group(Range<Token> in, const ParseContext& ctx) {
const SyntaxLevel syntax = ctx.syntax_level;
return map(
seq(opt(cardinality()), preceded(kind(TokenKind::KwGroup), cut(name_token())),
preceded(cut(kind(TokenKind::Equals)), cut(field_number())), opt(parse_compact_options),
delimited(
cut(kind(TokenKind::LBrace)),
[ctx](Range<Token> i) { return message_body(i, ctx); },
cut(kind(TokenKind::RBrace)))),
[syntax](auto parts) {
const std::string group_name(std::get<1>(parts).text);
MessageNode message = assemble_message(group_name, std::get<4>(parts));
FieldNode field =
build_field(std::get<0>(parts), group_name, to_lower(group_name),
std::get<2>(parts), std::move(std::get<3>(parts)), syntax);
field.offset = std::get<1>(parts).byte_offset; field.is_group = true;
field.message_encoding = MessageEncoding::Delimited;
return GroupDecl{std::move(field), std::move(message)};
})(in);
}
using ExtendElement = std::variant<FieldNode, GroupDecl>;
Result<Parsed<ExtendElement, Token>> extend_element(Range<Token> in, const ParseContext& ctx) {
return alt(map([ctx](Range<Token> i) { return parse_group(i, ctx); },
[](GroupDecl g) { return ExtendElement{std::move(g)}; }),
map([ctx](Range<Token> i) { return parse_field(i, ctx); },
[](FieldNode f) { return ExtendElement{std::move(f)}; }))(in);
}
Result<Parsed<ExtendBundle, Token>> parse_extend(Range<Token> in, const ParseContext& ctx) {
const std::size_t offset = in.empty() ? 0 : in.front().byte_offset; return map(
seq(preceded(kind(TokenKind::KwExtend), cut(type_name())),
delimited(cut(kind(TokenKind::LBrace)),
many([ctx](Range<Token> i) { return extend_element(i, ctx); }),
cut(kind(TokenKind::RBrace)))),
[offset](auto parts) {
ExtendBundle bundle;
bundle.node.offset = offset;
bundle.node.extendee_type_name = std::move(std::get<0>(parts));
for (auto& element : std::get<1>(parts)) {
std::visit(
overloaded{[&](FieldNode& f) { bundle.node.fields.push_back(std::move(f)); },
[&](GroupDecl& g) {
bundle.node.fields.push_back(std::move(g.field));
bundle.group_messages.push_back(std::move(g.message));
}},
element);
}
return bundle;
})(in);
}
struct PackageName {
std::string name;
};
struct SyntaxInfo {
SyntaxLevel level = SyntaxLevel::Proto2;
std::string edition;
std::size_t edition_offset = 0; };
Result<Parsed<std::monostate, Token>> balanced_braces(Range<Token> in) {
if (in.empty() || in.front().kind != TokenKind::LBrace) {
return Error{0, "expected '{'"};
}
std::size_t depth = 0;
for (std::size_t i = 0; i < in.size(); ++i) {
if (in[i].kind == TokenKind::LBrace) {
++depth;
} else if (in[i].kind == TokenKind::RBrace && --depth == 0) {
return Parsed<std::monostate, Token>{in.subspan(i + 1), std::monostate{}};
}
}
return Error{in.size(), "unterminated '{' block"};
}
auto import_decl() {
return map(seq(preceded(kind(TokenKind::KwImport),
opt(alt(kind(TokenKind::KwWeak), kind(TokenKind::KwPublic),
kind(TokenKind::KwOption)))),
cut(kind(TokenKind::StringLiteral)), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
ImportNode node;
node.path = std::get<1>(parts).str_value;
if (std::get<0>(parts).has_value()) {
switch (std::get<0>(parts)->kind) {
case TokenKind::KwWeak:
node.kind = ImportKind::Weak;
break;
case TokenKind::KwPublic:
node.kind = ImportKind::Public;
break;
case TokenKind::KwOption:
node.kind = ImportKind::Option;
break;
default:
break;
}
}
return node;
});
}
auto package_decl() {
return map(seq(preceded(kind(TokenKind::KwPackage), cut(qualified_ident())),
cut(kind(TokenKind::Semicolon))),
[](auto parts) { return PackageName{std::move(std::get<0>(parts))}; });
}
auto service_decl() {
return map(seq(kind(TokenKind::KwService), cut(name_token()), cut(balanced_braces)),
[](const auto&) { return std::monostate{}; });
}
auto syntax_decl() {
return alt(map(seq(preceded(kind(TokenKind::KwSyntax), cut(kind(TokenKind::Equals))),
cut(kind(TokenKind::StringLiteral)), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
SyntaxInfo info;
info.level = std::get<1>(parts).str_value == "proto3" ? SyntaxLevel::Proto3
: SyntaxLevel::Proto2;
return info;
}),
map(seq(preceded(kind(TokenKind::KwEdition), cut(kind(TokenKind::Equals))),
cut(kind(TokenKind::StringLiteral)), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
SyntaxInfo info;
info.level = SyntaxLevel::Edition;
info.edition = std::get<1>(parts).str_value;
info.edition_offset = std::get<1>(parts).byte_offset;
return info;
}));
}
using FileElement = std::variant<ImportNode, PackageName, Option, MessageNode, EnumNode,
ExtendBundle, std::monostate>;
Result<Parsed<FileElement, Token>> file_element(Range<Token> in, const ParseContext& ctx) {
return alt(map(parse_option_decl, [](Option o) { return FileElement{std::move(o)}; }),
map(import_decl(), [](ImportNode i) { return FileElement{std::move(i)}; }),
map(package_decl(), [](PackageName p) { return FileElement{std::move(p)}; }),
map(service_decl(), [](std::monostate) { return FileElement{std::monostate{}}; }),
map([ctx](Range<Token> i) { return parse_extend(i, ctx); },
[](ExtendBundle b) { return FileElement{std::move(b)}; }),
map([ctx](Range<Token> i) { return parse_message(i, ctx); },
[](MessageNode m) { return FileElement{std::move(m)}; }),
map([ctx](Range<Token> i) { return parse_enum(i, ctx); },
[](EnumNode e) { return FileElement{std::move(e)}; }),
map(kind(TokenKind::Semicolon),
[](const Token&) { return FileElement{std::monostate{}}; }))(in);
}
void apply_file_element(FileNode& file, FileElement& element) {
std::visit(overloaded{[&](ImportNode& i) { file.imports.push_back(std::move(i)); },
[&](PackageName& p) { file.package = std::move(p.name); },
[&](Option& o) { file.options.push_back(std::move(o)); },
[&](MessageNode& m) { file.messages.push_back(std::move(m)); },
[&](EnumNode& e) { file.enums.push_back(std::move(e)); },
[&](ExtendBundle& b) {
file.extends.push_back(std::move(b.node));
for (auto& gm : b.group_messages) {
file.messages.push_back(std::move(gm));
}
},
[](std::monostate) {}},
element);
}
}
Result<Parsed<OptionValue, Token>> parse_value(Range<Token> in) {
return alt(
map(parse_message_literal, [](MessageLiteral m) { return OptionValue{std::move(m)}; }),
map(parse_list_literal, [](ListLiteral l) { return OptionValue{std::move(l)}; }),
parse_scalar)(in);
}
Result<Parsed<Option, Token>> parse_option_decl(Range<Token> in) {
return map(seq(kind(TokenKind::KwOption), cut(parse_option_name), cut(kind(TokenKind::Equals)),
cut(parse_value), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
Option opt;
opt.name = std::move(std::get<1>(parts));
opt.value = std::move(std::get<3>(parts));
return opt;
})(in);
}
Result<Parsed<std::vector<Option>, Token>> parse_compact_options(Range<Token> in) {
return delimited(kind(TokenKind::LBracket),
separated_list(compact_option(), kind(TokenKind::Comma)),
cut(kind(TokenKind::RBracket)))(in);
}
Result<Parsed<EnumNode, Token>> parse_enum(Range<Token> in, const ParseContext& ctx) {
const SyntaxLevel syntax = ctx.syntax_level;
return map(seq(visibility_modifier(), kind(TokenKind::KwEnum), cut(name_token()),
cut(kind(TokenKind::LBrace)), enum_body(), cut(kind(TokenKind::RBrace))),
[syntax](auto parts) {
EnumNode node =
assemble_enum(std::get<2>(parts).text, std::get<4>(parts), syntax);
if (std::get<0>(parts).has_value()) {
node.visibility = *std::get<0>(parts);
}
return node;
})(in);
}
Result<Parsed<FieldNode, Token>> parse_field(Range<Token> in, const ParseContext& ctx) {
const SyntaxLevel syntax = ctx.syntax_level;
return map(seq(opt(cardinality()), type_name(), name_token(),
preceded(cut(kind(TokenKind::Equals)), cut(field_number())),
opt(parse_compact_options), cut(kind(TokenKind::Semicolon))),
[syntax](auto parts) {
FieldNode field = build_field(std::get<0>(parts), std::move(std::get<1>(parts)),
std::get<2>(parts).text, std::get<3>(parts),
std::move(std::get<4>(parts)), syntax);
field.offset = std::get<2>(parts).byte_offset; return field;
})(in);
}
Result<Parsed<MapFieldNode, Token>> parse_map_field(Range<Token> in) {
return map(seq(preceded(seq(kind(TokenKind::KwMap), cut(kind(TokenKind::LAngle))),
cut(type_name())), preceded(cut(kind(TokenKind::Comma)), cut(type_name())), preceded(cut(kind(TokenKind::RAngle)), cut(name_token())), preceded(cut(kind(TokenKind::Equals)), cut(field_number())), opt(parse_compact_options), cut(kind(TokenKind::Semicolon))),
[](auto parts) {
MapFieldNode node;
node.key_type = std::move(std::get<0>(parts));
node.value_type = std::move(std::get<1>(parts));
node.name = std::string(std::get<2>(parts).text);
node.offset = std::get<2>(parts).byte_offset; node.number = std::get<3>(parts);
if (std::get<4>(parts).has_value()) {
node.options = std::move(*std::get<4>(parts));
}
return node;
})(in);
}
Result<Parsed<MessageNode, Token>> parse_message(Range<Token> in, const ParseContext& ctx) {
return map(seq(visibility_modifier(), kind(TokenKind::KwMessage), cut(name_token()),
delimited(
cut(kind(TokenKind::LBrace)),
[ctx](Range<Token> i) { return message_body(i, ctx); },
cut(kind(TokenKind::RBrace)))),
[](auto parts) {
MessageNode node = assemble_message(std::get<2>(parts).text, std::get<3>(parts));
if (std::get<0>(parts).has_value()) {
node.visibility = *std::get<0>(parts);
}
return node;
})(in);
}
Result<Parsed<FileNode, Token>> parse_file(Range<Token> in) {
ParseContext ctx; std::string edition;
std::size_t edition_offset = 0;
Range<Token> rest = in;
auto syntax = syntax_decl()(in);
if (syntax.is_ok()) {
ctx.syntax_level = syntax.value().value.level;
edition = std::move(syntax.value().value.edition);
edition_offset = syntax.value().value.edition_offset;
rest = syntax.value().remaining;
} else if (syntax.error().fatal) {
return std::move(syntax.error()); }
auto body = many([ctx](Range<Token> i) { return file_element(i, ctx); })(rest);
if (!body) {
Error e = std::move(body.error());
e.byte_offset += static_cast<std::size_t>(rest.data() - in.data());
return e;
}
FileNode file;
file.syntax_level = ctx.syntax_level;
file.edition = std::move(edition);
file.edition_offset = edition_offset;
for (auto& element : body.value().value) {
apply_file_element(file, element);
}
return Parsed<FileNode, Token>{body.value().remaining, std::move(file)};
}
}