Method build_grammar

common/peg-parser.cpp:1599–1827

GBNF generation implementation

// GBNF generation implementation
void common_peg_arena::build_grammar(const common_grammar_builder & builder, bool lazy) const {
    auto schema_delegates = [](const common_peg_schema_parser & s) -> bool {
        if (!s.schema) {
            return true;
        }
        if (s.raw && s.schema->contains("type")) {
            const auto & type_val = s.schema->at("type");
            if (type_val.is_string() && type_val == "string") {
                return true;
            }
            // Handle nullable types like ["string", "null"] - delegate when the
            // non-null type is string, since the tagged format uses raw text
            if (type_val.is_array()) {
                for (const auto & t : type_val) {
                    if (t.is_string() && t.get<std::string>() != "null") {
                        return t.get<std::string>() == "string";
                    }
                }
            }
        }
        // Delegate for enum schemas in raw mode - enum values are literal strings
        if (s.raw && !s.schema->contains("type") && s.schema->contains("enum")) {
            return true;
        }
        return false;
    };

    // Unwrap the parser so we can properly check if it's a sequence or choice
    auto effective_parser = [&](common_peg_parser_id id) -> const common_peg_parser_variant & {
        while (true) {
            const auto & p = parsers_.at(id);
            if (const auto * tag = std::get_if<common_peg_tag_parser>(&p)) {
                id = tag->child;
            } else if (const auto * atomic = std::get_if<common_peg_atomic_parser>(&p)) {
                id = atomic->child;
            } else if (const auto * schema = std::get_if<common_peg_schema_parser>(&p)) {
                if (schema_delegates(*schema)) {
                    id = schema->child;
                } else {
                    return p;
                }
            } else {
                return p;
            }
        }
    };

    // Generate GBNF for a parser
    std::function<std::string(common_peg_parser_id)> to_gbnf = [&](common_peg_parser_id id) -> std::string {
        const auto & parser = parsers_.at(id);

        return std::visit([&](const auto & p) -> std::string {
            using T = std::decay_t<decltype(p)>;

            if constexpr (std::is_same_v<T, common_peg_epsilon_parser> ||
                          std::is_same_v<T, common_peg_start_parser> ||
                          std::is_same_v<T, common_peg_end_parser>) {
                return "";