| %{ |
| package protoparse |
| |
| //lint:file-ignore SA4006 generated parser has unused values |
| |
| import ( |
| "fmt" |
| "math" |
| "unicode" |
| |
| "github.com/jhump/protoreflect/desc/internal" |
| ) |
| |
| %} |
| |
| // fields inside this union end up as the fields in a structure known |
| // as ${PREFIX}SymType, of which a reference is passed to the lexer. |
| %union{ |
| file *fileNode |
| fileDecls []*fileElement |
| syn *syntaxNode |
| pkg *packageNode |
| imprt *importNode |
| msg *messageNode |
| msgDecls []*messageElement |
| fld *fieldNode |
| mapFld *mapFieldNode |
| mapType *mapTypeNode |
| grp *groupNode |
| oo *oneOfNode |
| ooDecls []*oneOfElement |
| ext *extensionRangeNode |
| resvd *reservedNode |
| en *enumNode |
| enDecls []*enumElement |
| env *enumValueNode |
| extend *extendNode |
| extDecls []*extendElement |
| svc *serviceNode |
| svcDecls []*serviceElement |
| mtd *methodNode |
| rpcType *rpcTypeNode |
| opts []*optionNode |
| optNm []*optionNamePartNode |
| cmpctOpts *compactOptionsNode |
| rngs []*rangeNode |
| names []*compoundStringNode |
| cid *compoundIdentNode |
| sl []valueNode |
| agg []*aggregateEntryNode |
| aggName *aggregateNameNode |
| v valueNode |
| il *compoundIntNode |
| str *compoundStringNode |
| s *stringLiteralNode |
| i *intLiteralNode |
| f *floatLiteralNode |
| id *identNode |
| b *basicNode |
| err error |
| } |
| |
| // any non-terminal which returns a value needs a type, which is |
| // really a field name in the above union struct |
| %type <file> file |
| %type <syn> syntax |
| %type <fileDecls> fileDecl fileDecls |
| %type <imprt> import |
| %type <pkg> package |
| %type <opts> option compactOption compactOptionDecls rpcOption rpcOptions |
| %type <optNm> optionName optionNameRest optionNameComponent |
| %type <cmpctOpts> compactOptions |
| %type <v> constant scalarConstant aggregate uintLit floatLit |
| %type <il> intLit negIntLit |
| %type <id> name keyType |
| %type <cid> ident typeIdent |
| %type <aggName> aggName |
| %type <sl> constantList |
| %type <agg> aggFields aggField aggFieldEntry |
| %type <fld> field oneofField |
| %type <oo> oneof |
| %type <grp> group oneofGroup |
| %type <mapFld> mapField |
| %type <mapType> mapType |
| %type <msg> message |
| %type <msgDecls> messageItem messageBody |
| %type <ooDecls> oneofItem oneofBody |
| %type <names> fieldNames |
| %type <resvd> msgReserved enumReserved reservedNames |
| %type <rngs> tagRange tagRanges enumRange enumRanges |
| %type <ext> extensions |
| %type <en> enum |
| %type <enDecls> enumItem enumBody |
| %type <env> enumField |
| %type <extend> extend |
| %type <extDecls> extendItem extendBody |
| %type <str> stringLit |
| %type <svc> service |
| %type <svcDecls> serviceItem serviceBody |
| %type <mtd> rpc |
| %type <rpcType> rpcType |
| |
| // same for terminals |
| %token <s> _STRING_LIT |
| %token <i> _INT_LIT |
| %token <f> _FLOAT_LIT |
| %token <id> _NAME |
| %token <id> _SYNTAX _IMPORT _WEAK _PUBLIC _PACKAGE _OPTION _TRUE _FALSE _INF _NAN _REPEATED _OPTIONAL _REQUIRED |
| %token <id> _DOUBLE _FLOAT _INT32 _INT64 _UINT32 _UINT64 _SINT32 _SINT64 _FIXED32 _FIXED64 _SFIXED32 _SFIXED64 |
| %token <id> _BOOL _STRING _BYTES _GROUP _ONEOF _MAP _EXTENSIONS _TO _MAX _RESERVED _ENUM _MESSAGE _EXTEND |
| %token <id> _SERVICE _RPC _STREAM _RETURNS |
| %token <err> _ERROR |
| // we define all of these, even ones that aren't used, to improve error messages |
| // so it shows the unexpected symbol instead of showing "$unk" |
| %token <b> '=' ';' ':' '{' '}' '\\' '/' '?' '.' ',' '>' '<' '+' '-' '(' ')' '[' ']' '*' '&' '^' '%' '$' '#' '@' '!' '~' '`' |
| |
| %% |
| |
| file : syntax { |
| $$ = &fileNode{syntax: $1} |
| $$.setRange($1, $1) |
| protolex.(*protoLex).res = $$ |
| } |
| | fileDecls { |
| $$ = &fileNode{decls: $1} |
| if len($1) > 0 { |
| $$.setRange($1[0], $1[len($1)-1]) |
| } |
| protolex.(*protoLex).res = $$ |
| } |
| | syntax fileDecls { |
| $$ = &fileNode{syntax: $1, decls: $2} |
| var end node |
| if len($2) > 0 { |
| end = $2[len($2)-1] |
| } else { |
| end = $1 |
| } |
| $$.setRange($1, end) |
| protolex.(*protoLex).res = $$ |
| } |
| | { |
| } |
| |
| fileDecls : fileDecls fileDecl { |
| $$ = append($1, $2...) |
| } |
| | fileDecl |
| |
| fileDecl : import { |
| $$ = []*fileElement{{imp: $1}} |
| } |
| | package { |
| $$ = []*fileElement{{pkg: $1}} |
| } |
| | option { |
| $$ = []*fileElement{{option: $1[0]}} |
| } |
| | message { |
| $$ = []*fileElement{{message: $1}} |
| } |
| | enum { |
| $$ = []*fileElement{{enum: $1}} |
| } |
| | extend { |
| $$ = []*fileElement{{extend: $1}} |
| } |
| | service { |
| $$ = []*fileElement{{service: $1}} |
| } |
| | ';' { |
| $$ = []*fileElement{{empty: $1}} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| syntax : _SYNTAX '=' stringLit ';' { |
| if $3.val != "proto2" && $3.val != "proto3" { |
| lexError(protolex, $3.start(), "syntax value must be 'proto2' or 'proto3'") |
| } |
| $$ = &syntaxNode{syntax: $3} |
| $$.setRange($1, $4) |
| } |
| |
| import : _IMPORT stringLit ';' { |
| $$ = &importNode{ name: $2 } |
| $$.setRange($1, $3) |
| } |
| | _IMPORT _WEAK stringLit ';' { |
| $$ = &importNode{ name: $3, weak: true } |
| $$.setRange($1, $4) |
| } |
| | _IMPORT _PUBLIC stringLit ';' { |
| $$ = &importNode{ name: $3, public: true } |
| $$.setRange($1, $4) |
| } |
| |
| package : _PACKAGE ident ';' { |
| $$ = &packageNode{name: $2} |
| $$.setRange($1, $3) |
| } |
| |
| ident : name { |
| $$ = &compoundIdentNode{val: $1.val} |
| $$.setRange($1, $1) |
| } |
| | ident '.' name { |
| $$ = &compoundIdentNode{val: $1.val + "." + $3.val} |
| $$.setRange($1, $3) |
| } |
| |
| option : _OPTION optionName '=' constant ';' { |
| n := &optionNameNode{parts: $2} |
| n.setRange($2[0], $2[len($2)-1]) |
| o := &optionNode{name: n, val: $4} |
| o.setRange($1, $5) |
| $$ = []*optionNode{o} |
| } |
| |
| optionName : ident { |
| $$ = toNameParts($1, 0) |
| } |
| | '(' typeIdent ')' { |
| p := &optionNamePartNode{text: $2, isExtension: true} |
| p.setRange($1, $3) |
| $$ = []*optionNamePartNode{p} |
| } |
| | '(' typeIdent ')' optionNameRest { |
| p := &optionNamePartNode{text: $2, isExtension: true} |
| p.setRange($1, $3) |
| ps := make([]*optionNamePartNode, 1, len($4)+1) |
| ps[0] = p |
| $$ = append(ps, $4...) |
| } |
| |
| optionNameRest : optionNameComponent |
| | optionNameComponent optionNameRest { |
| $$ = append($1, $2...) |
| } |
| |
| optionNameComponent : typeIdent { |
| $$ = toNameParts($1, 1 /* exclude leading dot */) |
| } |
| | '.' '(' typeIdent ')' { |
| p := &optionNamePartNode{text: $3, isExtension: true} |
| p.setRange($2, $4) |
| $$ = []*optionNamePartNode{p} |
| } |
| |
| constant : scalarConstant |
| | aggregate |
| |
| scalarConstant : stringLit { |
| $$ = $1 |
| } |
| | uintLit |
| | negIntLit { |
| $$ = $1 |
| } |
| | floatLit |
| | name { |
| if $1.val == "true" { |
| $$ = &boolLiteralNode{identNode: $1, val: true} |
| } else if $1.val == "false" { |
| $$ = &boolLiteralNode{identNode: $1, val: false} |
| } else if $1.val == "inf" { |
| f := &compoundFloatNode{val: math.Inf(1)} |
| f.setRange($1, $1) |
| $$ = f |
| } else if $1.val == "nan" { |
| f := &compoundFloatNode{val: math.NaN()} |
| f.setRange($1, $1) |
| $$ = f |
| } else { |
| $$ = $1 |
| } |
| } |
| |
| uintLit : _INT_LIT { |
| i := &compoundUintNode{val: $1.val} |
| i.setRange($1, $1) |
| $$ = i |
| } |
| | '+' _INT_LIT { |
| i := &compoundUintNode{val: $2.val} |
| i.setRange($1, $2) |
| $$ = i |
| } |
| |
| negIntLit : '-' _INT_LIT { |
| if $2.val > math.MaxInt64 + 1 { |
| lexError(protolex, $2.start(), fmt.Sprintf("numeric constant %d would underflow (allowed range is %d to %d)", $2.val, int64(math.MinInt64), int64(math.MaxInt64))) |
| } |
| i := &compoundIntNode{val: -int64($2.val)} |
| i.setRange($1, $2) |
| $$ = i |
| } |
| |
| intLit : negIntLit |
| | _INT_LIT { |
| // we don't allow uintLit because this is for enum numeric vals, which don't allow '+' |
| checkUint64InInt32Range(protolex, $1.start(), $1.val) |
| i := &compoundIntNode{val: int64($1.val)} |
| i.setRange($1, $1) |
| $$ = i |
| } |
| |
| floatLit : _FLOAT_LIT { |
| $$ = $1 |
| } |
| | '-' _FLOAT_LIT { |
| f := &compoundFloatNode{val: -$2.val} |
| f.setRange($1, $2) |
| $$ = f |
| } |
| | '+' _FLOAT_LIT { |
| f := &compoundFloatNode{val: $2.val} |
| f.setRange($1, $2) |
| $$ = f |
| } |
| | '+' _INF { |
| f := &compoundFloatNode{val: math.Inf(1)} |
| f.setRange($1, $2) |
| $$ = f |
| } |
| | '-' _INF { |
| f := &compoundFloatNode{val: math.Inf(-1)} |
| f.setRange($1, $2) |
| $$ = f |
| } |
| |
| stringLit : _STRING_LIT { |
| $$ = &compoundStringNode{val: $1.val} |
| $$.setRange($1, $1) |
| } |
| | stringLit _STRING_LIT { |
| $$ = &compoundStringNode{val: $1.val + $2.val} |
| $$.setRange($1, $2) |
| } |
| |
| aggregate : '{' aggFields '}' { |
| a := &aggregateLiteralNode{elements: $2} |
| a.setRange($1, $3) |
| $$ = a |
| } |
| |
| aggFields : aggField |
| | aggFields aggField { |
| $$ = append($1, $2...) |
| } |
| | { |
| $$ = nil |
| } |
| |
| aggField : aggFieldEntry |
| | aggFieldEntry ',' { |
| $$ = $1 |
| } |
| | aggFieldEntry ';' { |
| $$ = $1 |
| } |
| | error ',' { |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| aggFieldEntry : aggName ':' scalarConstant { |
| a := &aggregateEntryNode{name: $1, val: $3} |
| a.setRange($1, $3) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName ':' '[' ']' { |
| s := &sliceLiteralNode{} |
| s.setRange($3, $4) |
| a := &aggregateEntryNode{name: $1, val: s} |
| a.setRange($1, $4) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName ':' '[' constantList ']' { |
| s := &sliceLiteralNode{elements: $4} |
| s.setRange($3, $5) |
| a := &aggregateEntryNode{name: $1, val: s} |
| a.setRange($1, $5) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName ':' '[' error ']' { |
| } |
| | aggName ':' aggregate { |
| a := &aggregateEntryNode{name: $1, val: $3} |
| a.setRange($1, $3) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName aggregate { |
| a := &aggregateEntryNode{name: $1, val: $2} |
| a.setRange($1, $2) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName ':' '<' aggFields '>' { |
| s := &aggregateLiteralNode{elements: $4} |
| s.setRange($3, $5) |
| a := &aggregateEntryNode{name: $1, val: s} |
| a.setRange($1, $5) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName '<' aggFields '>' { |
| s := &aggregateLiteralNode{elements: $3} |
| s.setRange($2, $4) |
| a := &aggregateEntryNode{name: $1, val: s} |
| a.setRange($1, $4) |
| $$ = []*aggregateEntryNode{a} |
| } |
| | aggName ':' '<' error '>' { |
| } |
| | aggName '<' error '>' { |
| } |
| |
| aggName : name { |
| n := &compoundIdentNode{val: $1.val} |
| n.setRange($1, $1) |
| $$ = &aggregateNameNode{name: n} |
| $$.setRange($1, $1) |
| } |
| | '[' typeIdent ']' { |
| $$ = &aggregateNameNode{name: $2, isExtension: true} |
| $$.setRange($1, $3) |
| } |
| | '[' error ']' { |
| } |
| |
| constantList : constant { |
| $$ = []valueNode{$1} |
| } |
| | constantList ',' constant { |
| $$ = append($1, $3) |
| } |
| | constantList ';' constant { |
| $$ = append($1, $3) |
| } |
| | '<' aggFields '>' { |
| s := &aggregateLiteralNode{elements: $2} |
| s.setRange($1, $3) |
| $$ = []valueNode{s} |
| } |
| | constantList ',' '<' aggFields '>' { |
| s := &aggregateLiteralNode{elements: $4} |
| s.setRange($3, $5) |
| $$ = append($1, s) |
| } |
| | constantList ';' '<' aggFields '>' { |
| s := &aggregateLiteralNode{elements: $4} |
| s.setRange($3, $5) |
| $$ = append($1, s) |
| } |
| | '<' error '>' { |
| } |
| | constantList ',' '<' error '>' { |
| } |
| | constantList ';' '<' error '>' { |
| } |
| |
| typeIdent : ident |
| | '.' ident { |
| $$ = &compoundIdentNode{val: "." + $2.val} |
| $$.setRange($1, $2) |
| } |
| |
| field : _REQUIRED typeIdent name '=' _INT_LIT ';' { |
| checkTag(protolex, $5.start(), $5.val) |
| lbl := fieldLabel{identNode: $1, required: true} |
| $$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5} |
| $$.setRange($1, $6) |
| } |
| | _OPTIONAL typeIdent name '=' _INT_LIT ';' { |
| checkTag(protolex, $5.start(), $5.val) |
| lbl := fieldLabel{identNode: $1} |
| $$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5} |
| $$.setRange($1, $6) |
| } |
| | _REPEATED typeIdent name '=' _INT_LIT ';' { |
| checkTag(protolex, $5.start(), $5.val) |
| lbl := fieldLabel{identNode: $1, repeated: true} |
| $$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5} |
| $$.setRange($1, $6) |
| } |
| | typeIdent name '=' _INT_LIT ';' { |
| checkTag(protolex, $4.start(), $4.val) |
| $$ = &fieldNode{fldType: $1, name: $2, tag: $4} |
| $$.setRange($1, $5) |
| } |
| | _REQUIRED typeIdent name '=' _INT_LIT compactOptions ';' { |
| checkTag(protolex, $5.start(), $5.val) |
| lbl := fieldLabel{identNode: $1, required: true} |
| $$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $6} |
| $$.setRange($1, $7) |
| } |
| | _OPTIONAL typeIdent name '=' _INT_LIT compactOptions ';' { |
| checkTag(protolex, $5.start(), $5.val) |
| lbl := fieldLabel{identNode: $1} |
| $$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $6} |
| $$.setRange($1, $7) |
| } |
| | _REPEATED typeIdent name '=' _INT_LIT compactOptions ';' { |
| checkTag(protolex, $5.start(), $5.val) |
| lbl := fieldLabel{identNode: $1, repeated: true} |
| $$ = &fieldNode{label: lbl, fldType: $2, name: $3, tag: $5, options: $6} |
| $$.setRange($1, $7) |
| } |
| | typeIdent name '=' _INT_LIT compactOptions ';' { |
| checkTag(protolex, $4.start(), $4.val) |
| $$ = &fieldNode{fldType: $1, name: $2, tag: $4, options: $5} |
| $$.setRange($1, $6) |
| } |
| |
| compactOptions: '[' compactOptionDecls ']' { |
| $$ = &compactOptionsNode{decls: $2} |
| $$.setRange($1, $3) |
| } |
| |
| compactOptionDecls : compactOptionDecls ',' compactOption { |
| $$ = append($1, $3...) |
| } |
| | compactOption |
| |
| compactOption: optionName '=' constant { |
| n := &optionNameNode{parts: $1} |
| n.setRange($1[0], $1[len($1)-1]) |
| o := &optionNode{name: n, val: $3} |
| o.setRange($1[0], $3) |
| $$ = []*optionNode{o} |
| } |
| |
| group : _REQUIRED _GROUP name '=' _INT_LIT '{' messageBody '}' { |
| checkTag(protolex, $5.start(), $5.val) |
| if !unicode.IsUpper(rune($3.val[0])) { |
| lexError(protolex, $3.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $3.val)) |
| } |
| lbl := fieldLabel{identNode: $1, required: true} |
| $$ = &groupNode{groupKeyword: $2, label: lbl, name: $3, tag: $5, decls: $7} |
| $$.setRange($1, $8) |
| } |
| | _OPTIONAL _GROUP name '=' _INT_LIT '{' messageBody '}' { |
| checkTag(protolex, $5.start(), $5.val) |
| if !unicode.IsUpper(rune($3.val[0])) { |
| lexError(protolex, $3.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $3.val)) |
| } |
| lbl := fieldLabel{identNode: $1} |
| $$ = &groupNode{groupKeyword: $2, label: lbl, name: $3, tag: $5, decls: $7} |
| $$.setRange($1, $8) |
| } |
| | _REPEATED _GROUP name '=' _INT_LIT '{' messageBody '}' { |
| checkTag(protolex, $5.start(), $5.val) |
| if !unicode.IsUpper(rune($3.val[0])) { |
| lexError(protolex, $3.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $3.val)) |
| } |
| lbl := fieldLabel{identNode: $1, repeated: true} |
| $$ = &groupNode{groupKeyword: $2, label: lbl, name: $3, tag: $5, decls: $7} |
| $$.setRange($1, $8) |
| } |
| |
| oneof : _ONEOF name '{' oneofBody '}' { |
| c := 0 |
| for _, el := range $4 { |
| if el.field != nil { |
| c++ |
| } |
| } |
| if c == 0 { |
| lexError(protolex, $1.start(), "oneof must contain at least one field") |
| } |
| $$ = &oneOfNode{name: $2, decls: $4} |
| $$.setRange($1, $5) |
| } |
| |
| oneofBody : oneofBody oneofItem { |
| $$ = append($1, $2...) |
| } |
| | oneofItem |
| | { |
| $$ = nil |
| } |
| |
| oneofItem : option { |
| $$ = []*oneOfElement{{option: $1[0]}} |
| } |
| | oneofField { |
| $$ = []*oneOfElement{{field: $1}} |
| } |
| | oneofGroup { |
| $$ = []*oneOfElement{{group: $1}} |
| } |
| | ';' { |
| $$ = []*oneOfElement{{empty: $1}} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| oneofField : typeIdent name '=' _INT_LIT ';' { |
| checkTag(protolex, $4.start(), $4.val) |
| $$ = &fieldNode{fldType: $1, name: $2, tag: $4} |
| $$.setRange($1, $5) |
| } |
| | typeIdent name '=' _INT_LIT compactOptions ';' { |
| checkTag(protolex, $4.start(), $4.val) |
| $$ = &fieldNode{fldType: $1, name: $2, tag: $4, options: $5} |
| $$.setRange($1, $6) |
| } |
| |
| oneofGroup : _GROUP name '=' _INT_LIT '{' messageBody '}' { |
| checkTag(protolex, $4.start(), $4.val) |
| if !unicode.IsUpper(rune($2.val[0])) { |
| lexError(protolex, $2.start(), fmt.Sprintf("group %s should have a name that starts with a capital letter", $2.val)) |
| } |
| $$ = &groupNode{groupKeyword: $1, name: $2, tag: $4, decls: $6} |
| $$.setRange($1, $7) |
| } |
| |
| mapField : mapType name '=' _INT_LIT ';' { |
| checkTag(protolex, $4.start(), $4.val) |
| $$ = &mapFieldNode{mapType: $1, name: $2, tag: $4} |
| $$.setRange($1, $5) |
| } |
| | mapType name '=' _INT_LIT compactOptions ';' { |
| checkTag(protolex, $4.start(), $4.val) |
| $$ = &mapFieldNode{mapType: $1, name: $2, tag: $4, options: $5} |
| $$.setRange($1, $6) |
| } |
| |
| mapType : _MAP '<' keyType ',' typeIdent '>' { |
| $$ = &mapTypeNode{mapKeyword: $1, keyType: $3, valueType: $5} |
| $$.setRange($1, $6) |
| } |
| |
| keyType : _INT32 |
| | _INT64 |
| | _UINT32 |
| | _UINT64 |
| | _SINT32 |
| | _SINT64 |
| | _FIXED32 |
| | _FIXED64 |
| | _SFIXED32 |
| | _SFIXED64 |
| | _BOOL |
| | _STRING |
| |
| extensions : _EXTENSIONS tagRanges ';' { |
| $$ = &extensionRangeNode{ranges: $2} |
| $$.setRange($1, $3) |
| } |
| | _EXTENSIONS tagRanges compactOptions ';' { |
| $$ = &extensionRangeNode{ranges: $2, options: $3} |
| $$.setRange($1, $4) |
| } |
| |
| tagRanges : tagRanges ',' tagRange { |
| $$ = append($1, $3...) |
| } |
| | tagRange |
| |
| tagRange : _INT_LIT { |
| if $1.val > internal.MaxTag { |
| lexError(protolex, $1.start(), fmt.Sprintf("range includes out-of-range tag: %d (should be between 0 and %d)", $1.val, internal.MaxTag)) |
| } |
| r := &rangeNode{stNode: $1, enNode: $1, st: int32($1.val), en: int32($1.val)} |
| r.setRange($1, $1) |
| $$ = []*rangeNode{r} |
| } |
| | _INT_LIT _TO _INT_LIT { |
| if $1.val > internal.MaxTag { |
| lexError(protolex, $1.start(), fmt.Sprintf("range start is out-of-range tag: %d (should be between 0 and %d)", $1.val, internal.MaxTag)) |
| } |
| if $3.val > internal.MaxTag { |
| lexError(protolex, $3.start(), fmt.Sprintf("range end is out-of-range tag: %d (should be between 0 and %d)", $3.val, internal.MaxTag)) |
| } |
| if $1.val > $3.val { |
| lexError(protolex, $1.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", $1.val, $3.val)) |
| } |
| r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: int32($3.val)} |
| r.setRange($1, $3) |
| $$ = []*rangeNode{r} |
| } |
| | _INT_LIT _TO _MAX { |
| if $1.val > internal.MaxTag { |
| lexError(protolex, $1.start(), fmt.Sprintf("range start is out-of-range tag: %d (should be between 0 and %d)", $1.val, internal.MaxTag)) |
| } |
| r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: internal.MaxTag} |
| r.setRange($1, $3) |
| $$ = []*rangeNode{r} |
| } |
| |
| enumRanges : enumRanges ',' enumRange { |
| $$ = append($1, $3...) |
| } |
| | enumRange |
| |
| enumRange : intLit { |
| checkInt64InInt32Range(protolex, $1.start(), $1.val) |
| r := &rangeNode{stNode: $1, enNode: $1, st: int32($1.val), en: int32($1.val)} |
| r.setRange($1, $1) |
| $$ = []*rangeNode{r} |
| } |
| | intLit _TO intLit { |
| checkInt64InInt32Range(protolex, $1.start(), $1.val) |
| checkInt64InInt32Range(protolex, $3.start(), $3.val) |
| if $1.val > $3.val { |
| lexError(protolex, $1.start(), fmt.Sprintf("range, %d to %d, is invalid: start must be <= end", $1.val, $3.val)) |
| } |
| r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: int32($3.val)} |
| r.setRange($1, $3) |
| $$ = []*rangeNode{r} |
| } |
| | intLit _TO _MAX { |
| checkInt64InInt32Range(protolex, $1.start(), $1.val) |
| r := &rangeNode{stNode: $1, enNode: $3, st: int32($1.val), en: math.MaxInt32} |
| r.setRange($1, $3) |
| $$ = []*rangeNode{r} |
| } |
| |
| msgReserved : _RESERVED tagRanges ';' { |
| $$ = &reservedNode{ranges: $2} |
| $$.setRange($1, $3) |
| } |
| | reservedNames |
| |
| enumReserved : _RESERVED enumRanges ';' { |
| $$ = &reservedNode{ranges: $2} |
| $$.setRange($1, $3) |
| } |
| | reservedNames |
| |
| reservedNames : _RESERVED fieldNames ';' { |
| rsvd := map[string]struct{}{} |
| for _, n := range $2 { |
| if _, ok := rsvd[n.val]; ok { |
| lexError(protolex, n.start(), fmt.Sprintf("name %q is reserved multiple times", n.val)) |
| break |
| } |
| rsvd[n.val] = struct{}{} |
| } |
| $$ = &reservedNode{names: $2} |
| $$.setRange($1, $3) |
| } |
| |
| fieldNames : fieldNames ',' stringLit { |
| $$ = append($1, $3) |
| } |
| | stringLit { |
| $$ = []*compoundStringNode{$1} |
| } |
| |
| enum : _ENUM name '{' enumBody '}' { |
| c := 0 |
| for _, el := range $4 { |
| if el.value != nil { |
| c++ |
| } |
| } |
| if c == 0 { |
| lexError(protolex, $1.start(), "enums must define at least one value") |
| } |
| $$ = &enumNode{name: $2, decls: $4} |
| $$.setRange($1, $5) |
| } |
| |
| enumBody : enumBody enumItem { |
| $$ = append($1, $2...) |
| } |
| | enumItem |
| | { |
| $$ = nil |
| } |
| |
| enumItem : option { |
| $$ = []*enumElement{{option: $1[0]}} |
| } |
| | enumField { |
| $$ = []*enumElement{{value: $1}} |
| } |
| | enumReserved { |
| $$ = []*enumElement{{reserved: $1}} |
| } |
| | ';' { |
| $$ = []*enumElement{{empty: $1}} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| enumField : name '=' intLit ';' { |
| checkInt64InInt32Range(protolex, $3.start(), $3.val) |
| $$ = &enumValueNode{name: $1, number: $3} |
| $$.setRange($1, $4) |
| } |
| | name '=' intLit compactOptions ';' { |
| checkInt64InInt32Range(protolex, $3.start(), $3.val) |
| $$ = &enumValueNode{name: $1, number: $3, options: $4} |
| $$.setRange($1, $5) |
| } |
| |
| message : _MESSAGE name '{' messageBody '}' { |
| $$ = &messageNode{name: $2, decls: $4} |
| $$.setRange($1, $5) |
| } |
| |
| messageBody : messageBody messageItem { |
| $$ = append($1, $2...) |
| } |
| | messageItem |
| | { |
| $$ = nil |
| } |
| |
| messageItem : field { |
| $$ = []*messageElement{{field: $1}} |
| } |
| | enum { |
| $$ = []*messageElement{{enum: $1}} |
| } |
| | message { |
| $$ = []*messageElement{{nested: $1}} |
| } |
| | extend { |
| $$ = []*messageElement{{extend: $1}} |
| } |
| | extensions { |
| $$ = []*messageElement{{extensionRange: $1}} |
| } |
| | group { |
| $$ = []*messageElement{{group: $1}} |
| } |
| | option { |
| $$ = []*messageElement{{option: $1[0]}} |
| } |
| | oneof { |
| $$ = []*messageElement{{oneOf: $1}} |
| } |
| | mapField { |
| $$ = []*messageElement{{mapField: $1}} |
| } |
| | msgReserved { |
| $$ = []*messageElement{{reserved: $1}} |
| } |
| | ';' { |
| $$ = []*messageElement{{empty: $1}} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| extend : _EXTEND typeIdent '{' extendBody '}' { |
| c := 0 |
| for _, el := range $4 { |
| if el.field != nil || el.group != nil { |
| c++ |
| } |
| } |
| if c == 0 { |
| lexError(protolex, $1.start(), "extend sections must define at least one extension") |
| } |
| $$ = &extendNode{extendee: $2, decls: $4} |
| $$.setRange($1, $5) |
| } |
| |
| extendBody : extendBody extendItem { |
| $$ = append($1, $2...) |
| } |
| | extendItem |
| | { |
| $$ = nil |
| } |
| |
| extendItem : field { |
| $$ = []*extendElement{{field: $1}} |
| } |
| | group { |
| $$ = []*extendElement{{group: $1}} |
| } |
| | ';' { |
| $$ = []*extendElement{{empty: $1}} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| service : _SERVICE name '{' serviceBody '}' { |
| $$ = &serviceNode{name: $2, decls: $4} |
| $$.setRange($1, $5) |
| } |
| |
| serviceBody : serviceBody serviceItem { |
| $$ = append($1, $2...) |
| } |
| | serviceItem |
| | { |
| $$ = nil |
| } |
| |
| // NB: doc suggests support for "stream" declaration, separate from "rpc", but |
| // it does not appear to be supported in protoc (doc is likely from grammar for |
| // Google-internal version of protoc, with support for streaming stubby) |
| serviceItem : option { |
| $$ = []*serviceElement{{option: $1[0]}} |
| } |
| | rpc { |
| $$ = []*serviceElement{{rpc: $1}} |
| } |
| | ';' { |
| $$ = []*serviceElement{{empty: $1}} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| rpc : _RPC name '(' rpcType ')' _RETURNS '(' rpcType ')' ';' { |
| $$ = &methodNode{name: $2, input: $4, output: $8} |
| $$.setRange($1, $10) |
| } |
| | _RPC name '(' rpcType ')' _RETURNS '(' rpcType ')' '{' rpcOptions '}' { |
| $$ = &methodNode{name: $2, input: $4, output: $8, options: $11} |
| $$.setRange($1, $12) |
| } |
| |
| rpcType : _STREAM typeIdent { |
| $$ = &rpcTypeNode{msgType: $2, streamKeyword: $1} |
| $$.setRange($1, $2) |
| } |
| | typeIdent { |
| $$ = &rpcTypeNode{msgType: $1} |
| $$.setRange($1, $1) |
| } |
| |
| rpcOptions : rpcOptions rpcOption { |
| $$ = append($1, $2...) |
| } |
| | rpcOption |
| | { |
| $$ = []*optionNode{} |
| } |
| |
| rpcOption : option { |
| $$ = $1 |
| } |
| | ';' { |
| $$ = []*optionNode{} |
| } |
| | error ';' { |
| } |
| | error { |
| } |
| |
| name : _NAME |
| | _SYNTAX |
| | _IMPORT |
| | _WEAK |
| | _PUBLIC |
| | _PACKAGE |
| | _OPTION |
| | _TRUE |
| | _FALSE |
| | _INF |
| | _NAN |
| | _REPEATED |
| | _OPTIONAL |
| | _REQUIRED |
| | _DOUBLE |
| | _FLOAT |
| | _INT32 |
| | _INT64 |
| | _UINT32 |
| | _UINT64 |
| | _SINT32 |
| | _SINT64 |
| | _FIXED32 |
| | _FIXED64 |
| | _SFIXED32 |
| | _SFIXED64 |
| | _BOOL |
| | _STRING |
| | _BYTES |
| | _GROUP |
| | _ONEOF |
| | _MAP |
| | _EXTENSIONS |
| | _TO |
| | _MAX |
| | _RESERVED |
| | _ENUM |
| | _MESSAGE |
| | _EXTEND |
| | _SERVICE |
| | _RPC |
| | _STREAM |
| | _RETURNS |
| |
| %% |