Compiler Explorer

Source code

#include <boost/spirit/include/qi.hpp>
#include <string>

namespace qi = boost::spirit::qi;

// http://developers.google.com/protocol-buffers/docs/reference/proto2-spec
template <typename It>
struct proto_grammar : qi::grammar<It> {

typedef qi::rule<It, char()> char_rule_type;
    typedef qi::rule<It, std::string()> string_rule_type;

proto_grammar() : proto_grammar::base_type(_proto) {

using qi::lit;
        using qi::digit;
        using qi::no_skip;
        using qi::char_;

const auto init_id_ = [&no_skip, &char_](
            char_rule_type& id, char_rule_type& l
            , char_rule_type& dd, char_rule_type& underscore) {

id %= no_skip[l >> *(l | dd | underscore)];
        };

const auto init_type_ = [&no_skip](
            char_rule_type& dot, string_rule_type& id
            , string_rule_type& name, string_rule_type& type) {

type %= no_skip[(dot
                >> *(id >> dot) >> name
                | *(id >> dot) >> name
                )];
        };

// Delimiters and such
        _underscore %= char_("_");
        _backslash %= char_("\\");
        _dot %= char_(".");
        _zed %= char_("0");
        _ex %= char_("xX");
        _ex %= char_("eE");
        _plus_minus %= char_("+-");
        _inf %= lit("inf");
        _nan %= lit("nan");
        _quote %= char_("\"");
        _tick %= char_("'");
        _eq %= char_("=");
        _eos %= char_(";");
        _paren_open %= char_("(");
        _paren_close %= char_(")");
        _comma %= char_(",");
        _square_bracket_open %= char_("[");
        _square_bracket_close %= char_("]");
        _brace_open %= char_("{");
        _brace_close %= char_("}");
        _bracket_open %= char_("<");
        _bracket_close %= char_(">");

// Letters and digits
        _let %= char_("A-Za-z");
        _cap_let %= char_("A-Z");
        _dec_dig %= char_("0-9");
        _oct_dig %= char_("0-7");
        _hex_dig %= char_("0-9A-Fa-f");

// Identifiers
        init_id_(_let, _dec_dig, _id);
        init_id_(_let, _dec_dig, _full_id);
        init_id_(_let, _dec_dig, _msg_name);
        init_id_(_let, _dec_dig, _enum_name);
        init_id_(_let, _dec_dig, _field_name);
        init_id_(_let, _dec_dig, _oneof_name);
        init_id_(_let, _dec_dig, _oneof_name);
        init_id_(_let, _dec_dig, _map_name);
        init_id_(_let, _dec_dig, _service_name);
        init_id_(_let, _dec_dig, _rpc_name);
        init_id_(_let, _dec_dig, _stream_name);

init_type_(_dot, _id, _msg_name, _msg_type);
        init_type_(_dot, _id, _enum_name, _enum_type);

_group_name %= _cap_let >> *(_let >> _dec_dig >> _underscore);

// Integer literals
        _dec_lit %= no_skip[char_("1-9") >> *_dec_dig];
        _oct_lit %= no_skip[_zed >> *_oct_dig];
        _hex_lit %= no_skip[_zed >> _ex >> +_hex_dig];
        _int_lit %= _dec_lit | _oct_lit | _hex_lit;

// Floating-point literals
        _decs %= +_dec_dig;
        _exp %= _ee >> (_decs | _plus_minus >> _decs);
        // TODO: TBD: this one is a bit tricky: there's probably better ways to attack this one from a Boost Spirit POV...
        // floatLit = ( decimals "." [ decimals ] [ exponent ] | decimals exponent | "."decimals [ exponent ] ) | "inf" | "nan"
        _float_lit %= (_decs >> _dot >> -_decs >> -_exp | _decs >> _exp | _dot >> _decs >> -_exp) | _inf | _nan;

// Boolean
        _bool_lit %= lit("true") | lit("false");

// String literals
        _quote_or_tick %= char_("'\"");
        _char_esc %= _backslash >> char_("abfnrtv\\'\"");
        _oct_esc %= _backslash >> _oct_dig >> _oct_dig >> _oct_dig;
        _hex_esc %= _backslash >> _ex >> _hex_dig >> _hex_dig;
        // The last bit in this phrase is literally, "Or Any Characters Not in the Sequence".
        _char_val %= _hex_esc | _oct_esc | _char_esc | !char_("\0\n\\");
        /* Kleene zero or more might work as well:
            * strLit = ( "'" { charValue } "'" ) | ( '"' { charValue } '"' )
            */
        _str_lit %= (_tick >> (_tick | +_char_val >> _tick))
            | (_quote >> (_quote | +_char_val >> _quote));

// Empty Statement
        _empty_statement %= _eos;

// Constant
        _const %= _full_id
            | (-_plus_minus >> _int_lit)
            | (-_plus_minus >> _float_lit)
            | _str_lit | _bool_lit
            ;

// Syntax
        // This is just lazy spec authorship IMO: syntax = "syntax" "=" quote "proto2" quote ";"
        _syntax %= lit("syntax") >> _eq >> no_skip[
            (_tick >> lit("proto2") >> _tick)
                | (_quote >> lit("proto2") >> _quote)
        ];

// Import Statement
        // import = "import" [ "weak" | "public" ] strLit ";" 
        _import %= lit("import") >> -(lit("weak") | lit("public")) >> _str_lit >> _empty_statement;

// Package
        // package = "package" fullIdent ";"
        _package %= lit("package") >> _full_id >> _empty_statement;

// Option
        _opt_name %= no_skip[
            (_id
                | _paren_open >> _full_id >> _paren_close)
                >> *(_dot >> _id)
        ];

_opt %= lit("option") >> _opt_name >> _eq >> _const >> _empty_statement;

// Normal field
        _field_opt %= _opt_name >> _eq >> _const;
        _field_opts %= _field_opt % _comma;
        _field %= _label >> _type >> _field_name >> _eq >> _field_num
            >> -(_square_bracket_open >> _field_opts >> _square_bracket_closed) >> _empty_statement;

// Group field
        _group %= _label >> lit("group") >> _group_name >> _eq >> _field_num >> _msg_body;

// Oneof and oneof field
        _oneof_field %= _type >> _field_name >> _eq >> _field_num >> -(_square_bracket_open >> _field_opts >> _square_bracket_closed) >> _empty_statement;
        _oneof %= lit("oneof") >> _oneof_name >> _brace_open >> *(_oneof_field >> _empty_statement) >> _brace_closed;

// Map field
        _key_type %= lit("int32")
            | lit("int64")
            | lit("uint32")
            | lit("uint64")
            | lit("sint32")
            | lit("sint64")
            | lit("fixed32")
            | lit("fixed64")
            | lit("sfixed32")
            | lit("sfixed64")
            | lit("bool")
            | lit("string")
            ;
        // Long-winded phrase to say this: mapField = "map" "<" keyType "," type ">" mapName "=" fieldNumber [ "[" fieldOptions "]" ] ";"
        _map_field %= lit("map") >> _bracket_open >> _key_type >> _comma >> _type >> _bracket_close >> _map_name
            >> _eq >> _field_num >> -(_square_bracket_open >> _field_opts >> _square_bracket_closed) >> _empty_statement;

// Extensions and Reserved, Extensions ...
        _range %= _int_lit >> -(lit("to") >> (_int_lit | lit("max"));
        _ranges %= _range % _comma;
        _extensions %= lit("extensions") >> _ranges >> _empty_statement;

// Reserved
        _reserved %= lit("reserved") >> (_ranges | _field_names) >> _empty_statement;
        _field_names %= _field_name % _comma;

// Up to this point it has been elementary bits and pieces...

// Enum definition
        _enum_val_opt %= _opt_name >> _eq >> _const;
        _enum_field %= _id >> _eq > _int_lit >> -(_square_bracket_open >> (_enum_val_opt % _comma) >> _square_bracket_closed) >> _empty_statement;
        _enum_body %= _brace_open >> *(_opt | _enum_field | _empty_statement) >> _brace_closed;
        _enum %= lit("enum") >> _enum_name >> _enum_body;

// Extend
        _extend %= lit("extend") >> _msg_type >> _brace_open >> *(_field | _group | _empty_statement) >> _brace_closed;

// Service definition
        _service %= lit("service") >> _service_name >> _brace_open >> *(_opt | _rpc | _stream | _empty_statement) >> _brace_closed;
        _rpc %= lit("rpc") >> _rpc_name >> _paren_open >> -lit("stream") >> _msg_type >> _paren_close
            >> lit("returns") >> _paren_open >> -lit("stream") >> _msg_type >> _paren_close >> ((_brace_open
                >> *(_opt | _empty_statement) >> _brace_closed) | _empty_statement)
            ;
        _stream %= lit("stream") >> _stream_name >> _paren_open >> _msg_type >> _comma >> _msg_type >> _paren_close
            >> ((_brace_open >> *(_opt | _empty_statement) >> _brace_closed) | _empty_statement)
            ;

// Proto file
        _top_level_def %= _msg | _enum | _extend | _service;
        _proto %= _syntax >> *(_import | _package | _opt | _top_level_def | _empty_statement);
    }

private:

char_rule_type _underscore;
    char_rule_type _backslash;
    char_rule_type _dot;
    char_rule_type _zed;
    char_rule_type _ex;
    char_rule_type _ee;
    char_rule_type _eq;
    char_rule_type _plus_minus;
    string_rule_type _inf;
    string_rule_type _nan;
    char_rule_type _quote;
    char_rule_type _tick;
    char_rule_type _paren_open;
    char_rule_type _paren_close;
    char_rule_type _square_bracket_open;
    char_rule_type _square_bracket_closed;
    char_rule_type _brace_open;
    char_rule_type _brace_closed;
    char_rule_type _comma;
    char_rule_type _bracket_open;
    char_rule_type _bracket_closed;

char_rule_type _let;
    char_rule_type _cap_let;
    char_rule_type _dec_dig;
    char_rule_type _oct_dig;
    char_rule_type _hex_dig;

string_rule_type _id;
    string_rule_type _full_id;
    string_rule_type _msg_name;
    string_rule_type _enum_name;
    string_rule_type _field_name;
    string_rule_type _oneof_name;
    string_rule_type _map_name;
    string_rule_type _service_name;
    string_rule_type _rpc_name;
    string_rule_type _stream_name;
    string_rule_type _msg_type;
    string_rule_type _enum_type;
    string_rule_type _group_name;

string_rule_type _int_lit;
    string_rule_type _dec_lit;
    string_rule_type _oct_lit;
    string_rule_type _hex_lit;

string_rule_type _float_lit;
    string_rule_type _decs;
    string_rule_type _exp;

string_rule_type _bool_lit;

char_rule_type _quote_or_tick;
    string_rule_type _char_esc;
    string_rule_type _oct_esc;
    string_rule_type _hex_esc;
    string_rule_type _char_val;
    string_rule_type _str_lit;

string_rule_type _empty_statement;

string_rule_type _const;

string_rule_type _syntax;

string_rule_type _import;

string_rule_type _package;

string_rule_type _opt;
    string_rule_type _opt_name;

string_rule_type _label;
    string_rule_type _type;
    string_rule_type _field_num;

string_rule_type _field;
    string_rule_type _field_opt;
    string_rule_type _field_opts;

string_rule_type _group;

string_rule_type _oneof;
    string_rule_type _oneof_field;

string_rule_type _map_field;
    string_rule_type _key_type;

string_rule_type _range;
    string_rule_type _ranges;
    string_rule_type _extensions;

string_rule_type _reserved;
    string_rule_type _field_names;

string_rule_type _enum_val_opt;
    string_rule_type _enum_field;
    string_rule_type _enum_body;
    string_rule_type _enum;

string_rule_type _msg;
    string_rule_type _msg_body;

string_rule_type _extend;

string_rule_type _service;
    string_rule_type _rpc;
    string_rule_type _stream;

string_rule_type _top_level_def;
    string_rule_type _proto;
};

int main() {
    return 0;
}