grammar.peg.go

// DO NOT EDIT. Code generated by pigeon, run "go generate" to update.

package parser

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"unicode"
	"unicode/utf8"
)

type namespace struct {
	scope     string
	namespace string
}

type exception *Struct

type union *Struct

type include string

func toIfaceSlice(v interface{}) []interface{} {
	if v == nil {
		return nil
	}
	return v.([]interface{})
}

func ifaceSliceToString(v interface{}) string {
	ifs := toIfaceSlice(v)
	b := make([]byte, len(ifs))
	for i, v := range ifs {
		b[i] = v.([]uint8)[0]
	}
	return string(b)
}

// toStruct converts a union to a struct with all fields optional.
func unionToStruct(u union) *Struct {
	st := (*Struct)(u)
	for _, f := range st.Fields {
		f.Optional = true
	}
	return st
}

func toAnnotations(v interface{}) []*Annotation {
	if v == nil {
		return nil
	}
	return v.([]*Annotation)
}

var g = &grammar{
	rules: []*rule{
		{
			name: "Grammar",
			pos:  position{line: 56, col: 1, offset: 860},
			expr: &actionExpr{
				pos: position{line: 56, col: 11, offset: 872},
				run: (*parser).callonGrammar1,
				expr: &seqExpr{
					pos: position{line: 56, col: 11, offset: 872},
					exprs: []interface{}{
						&ruleRefExpr{
							pos:  position{line: 56, col: 11, offset: 872},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 56, col: 14, offset: 875},
							label: "statements",
							expr: &zeroOrMoreExpr{
								pos: position{line: 56, col: 25, offset: 886},
								expr: &seqExpr{
									pos: position{line: 56, col: 27, offset: 888},
									exprs: []interface{}{
										&ruleRefExpr{
											pos:  position{line: 56, col: 27, offset: 888},
											name: "Statement",
										},
										&ruleRefExpr{
											pos:  position{line: 56, col: 37, offset: 898},
											name: "__",
										},
									},
								},
							},
						},
						&choiceExpr{
							pos: position{line: 56, col: 44, offset: 905},
							alternatives: []interface{}{
								&ruleRefExpr{
									pos:  position{line: 56, col: 44, offset: 905},
									name: "EOF",
								},
								&ruleRefExpr{
									pos:  position{line: 56, col: 50, offset: 911},
									name: "SyntaxError",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "SyntaxError",
			pos:  position{line: 100, col: 1, offset: 2081},
			expr: &actionExpr{
				pos: position{line: 100, col: 15, offset: 2097},
				run: (*parser).callonSyntaxError1,
				expr: &anyMatcher{
					line: 100, col: 15, offset: 2097,
				},
			},
		},
		{
			name: "Include",
			pos:  position{line: 104, col: 1, offset: 2152},
			expr: &actionExpr{
				pos: position{line: 104, col: 11, offset: 2164},
				run: (*parser).callonInclude1,
				expr: &seqExpr{
					pos: position{line: 104, col: 11, offset: 2164},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 104, col: 11, offset: 2164},
							val:        "include",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 104, col: 21, offset: 2174},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 104, col: 23, offset: 2176},
							label: "file",
							expr: &ruleRefExpr{
								pos:  position{line: 104, col: 28, offset: 2181},
								name: "Literal",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 104, col: 36, offset: 2189},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "Statement",
			pos:  position{line: 108, col: 1, offset: 2234},
			expr: &choiceExpr{
				pos: position{line: 108, col: 13, offset: 2248},
				alternatives: []interface{}{
					&ruleRefExpr{
						pos:  position{line: 108, col: 13, offset: 2248},
						name: "Include",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 23, offset: 2258},
						name: "Namespace",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 35, offset: 2270},
						name: "Const",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 43, offset: 2278},
						name: "Enum",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 50, offset: 2285},
						name: "TypeDef",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 60, offset: 2295},
						name: "Struct",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 69, offset: 2304},
						name: "Exception",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 81, offset: 2316},
						name: "Union",
					},
					&ruleRefExpr{
						pos:  position{line: 108, col: 89, offset: 2324},
						name: "Service",
					},
				},
			},
		},
		{
			name: "Namespace",
			pos:  position{line: 110, col: 1, offset: 2333},
			expr: &actionExpr{
				pos: position{line: 110, col: 13, offset: 2347},
				run: (*parser).callonNamespace1,
				expr: &seqExpr{
					pos: position{line: 110, col: 13, offset: 2347},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 110, col: 13, offset: 2347},
							val:        "namespace",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 110, col: 25, offset: 2359},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 110, col: 27, offset: 2361},
							label: "scope",
							expr: &oneOrMoreExpr{
								pos: position{line: 110, col: 33, offset: 2367},
								expr: &charClassMatcher{
									pos:        position{line: 110, col: 33, offset: 2367},
									val:        "[*a-z.-]",
									chars:      []rune{'*', '.', '-'},
									ranges:     []rune{'a', 'z'},
									ignoreCase: false,
									inverted:   false,
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 110, col: 43, offset: 2377},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 110, col: 45, offset: 2379},
							label: "ns",
							expr: &ruleRefExpr{
								pos:  position{line: 110, col: 48, offset: 2382},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 110, col: 59, offset: 2393},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "Const",
			pos:  position{line: 117, col: 1, offset: 2504},
			expr: &actionExpr{
				pos: position{line: 117, col: 9, offset: 2514},
				run: (*parser).callonConst1,
				expr: &seqExpr{
					pos: position{line: 117, col: 9, offset: 2514},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 117, col: 9, offset: 2514},
							val:        "const",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 117, col: 17, offset: 2522},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 117, col: 19, offset: 2524},
							label: "typ",
							expr: &ruleRefExpr{
								pos:  position{line: 117, col: 23, offset: 2528},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 117, col: 33, offset: 2538},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 117, col: 35, offset: 2540},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 117, col: 40, offset: 2545},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 117, col: 51, offset: 2556},
							name: "__",
						},
						&litMatcher{
							pos:        position{line: 117, col: 54, offset: 2559},
							val:        "=",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 117, col: 58, offset: 2563},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 117, col: 61, offset: 2566},
							label: "value",
							expr: &ruleRefExpr{
								pos:  position{line: 117, col: 67, offset: 2572},
								name: "ConstValue",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 117, col: 78, offset: 2583},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "Enum",
			pos:  position{line: 125, col: 1, offset: 2691},
			expr: &actionExpr{
				pos: position{line: 125, col: 8, offset: 2700},
				run: (*parser).callonEnum1,
				expr: &seqExpr{
					pos: position{line: 125, col: 8, offset: 2700},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 125, col: 8, offset: 2700},
							val:        "enum",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 125, col: 15, offset: 2707},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 125, col: 17, offset: 2709},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 125, col: 22, offset: 2714},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 125, col: 33, offset: 2725},
							name: "__",
						},
						&litMatcher{
							pos:        position{line: 125, col: 36, offset: 2728},
							val:        "{",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 125, col: 40, offset: 2732},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 125, col: 43, offset: 2735},
							label: "values",
							expr: &zeroOrMoreExpr{
								pos: position{line: 125, col: 50, offset: 2742},
								expr: &seqExpr{
									pos: position{line: 125, col: 51, offset: 2743},
									exprs: []interface{}{
										&ruleRefExpr{
											pos:  position{line: 125, col: 51, offset: 2743},
											name: "EnumValue",
										},
										&ruleRefExpr{
											pos:  position{line: 125, col: 61, offset: 2753},
											name: "__",
										},
									},
								},
							},
						},
						&litMatcher{
							pos:        position{line: 125, col: 66, offset: 2758},
							val:        "}",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 125, col: 70, offset: 2762},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 125, col: 72, offset: 2764},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 125, col: 84, offset: 2776},
								expr: &ruleRefExpr{
									pos:  position{line: 125, col: 84, offset: 2776},
									name: "TypeAnnotations",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 125, col: 101, offset: 2793},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "EnumValue",
			pos:  position{line: 149, col: 1, offset: 3352},
			expr: &actionExpr{
				pos: position{line: 149, col: 13, offset: 3366},
				run: (*parser).callonEnumValue1,
				expr: &seqExpr{
					pos: position{line: 149, col: 13, offset: 3366},
					exprs: []interface{}{
						&labeledExpr{
							pos:   position{line: 149, col: 13, offset: 3366},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 149, col: 18, offset: 3371},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 149, col: 29, offset: 3382},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 149, col: 31, offset: 3384},
							label: "value",
							expr: &zeroOrOneExpr{
								pos: position{line: 149, col: 37, offset: 3390},
								expr: &seqExpr{
									pos: position{line: 149, col: 38, offset: 3391},
									exprs: []interface{}{
										&litMatcher{
											pos:        position{line: 149, col: 38, offset: 3391},
											val:        "=",
											ignoreCase: false,
										},
										&ruleRefExpr{
											pos:  position{line: 149, col: 42, offset: 3395},
											name: "_",
										},
										&ruleRefExpr{
											pos:  position{line: 149, col: 44, offset: 3397},
											name: "IntConstant",
										},
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 149, col: 58, offset: 3411},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 149, col: 60, offset: 3413},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 149, col: 72, offset: 3425},
								expr: &ruleRefExpr{
									pos:  position{line: 149, col: 72, offset: 3425},
									name: "TypeAnnotations",
								},
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 149, col: 89, offset: 3442},
							expr: &ruleRefExpr{
								pos:  position{line: 149, col: 89, offset: 3442},
								name: "ListSeparator",
							},
						},
					},
				},
			},
		},
		{
			name: "TypeDef",
			pos:  position{line: 161, col: 1, offset: 3664},
			expr: &actionExpr{
				pos: position{line: 161, col: 11, offset: 3676},
				run: (*parser).callonTypeDef1,
				expr: &seqExpr{
					pos: position{line: 161, col: 11, offset: 3676},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 161, col: 11, offset: 3676},
							val:        "typedef",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 161, col: 21, offset: 3686},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 161, col: 23, offset: 3688},
							label: "typ",
							expr: &ruleRefExpr{
								pos:  position{line: 161, col: 27, offset: 3692},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 161, col: 37, offset: 3702},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 161, col: 39, offset: 3704},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 161, col: 44, offset: 3709},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 161, col: 55, offset: 3720},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 161, col: 57, offset: 3722},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 161, col: 69, offset: 3734},
								expr: &ruleRefExpr{
									pos:  position{line: 161, col: 69, offset: 3734},
									name: "TypeAnnotations",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 161, col: 86, offset: 3751},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "Struct",
			pos:  position{line: 169, col: 1, offset: 3886},
			expr: &actionExpr{
				pos: position{line: 169, col: 10, offset: 3897},
				run: (*parser).callonStruct1,
				expr: &seqExpr{
					pos: position{line: 169, col: 10, offset: 3897},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 169, col: 10, offset: 3897},
							val:        "struct",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 169, col: 19, offset: 3906},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 169, col: 21, offset: 3908},
							label: "st",
							expr: &ruleRefExpr{
								pos:  position{line: 169, col: 24, offset: 3911},
								name: "StructLike",
							},
						},
					},
				},
			},
		},
		{
			name: "Exception",
			pos:  position{line: 170, col: 1, offset: 3951},
			expr: &actionExpr{
				pos: position{line: 170, col: 13, offset: 3965},
				run: (*parser).callonException1,
				expr: &seqExpr{
					pos: position{line: 170, col: 13, offset: 3965},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 170, col: 13, offset: 3965},
							val:        "exception",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 170, col: 25, offset: 3977},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 170, col: 27, offset: 3979},
							label: "st",
							expr: &ruleRefExpr{
								pos:  position{line: 170, col: 30, offset: 3982},
								name: "StructLike",
							},
						},
					},
				},
			},
		},
		{
			name: "Union",
			pos:  position{line: 171, col: 1, offset: 4033},
			expr: &actionExpr{
				pos: position{line: 171, col: 9, offset: 4043},
				run: (*parser).callonUnion1,
				expr: &seqExpr{
					pos: position{line: 171, col: 9, offset: 4043},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 171, col: 9, offset: 4043},
							val:        "union",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 171, col: 17, offset: 4051},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 171, col: 19, offset: 4053},
							label: "st",
							expr: &ruleRefExpr{
								pos:  position{line: 171, col: 22, offset: 4056},
								name: "StructLike",
							},
						},
					},
				},
			},
		},
		{
			name: "StructLike",
			pos:  position{line: 172, col: 1, offset: 4103},
			expr: &actionExpr{
				pos: position{line: 172, col: 14, offset: 4118},
				run: (*parser).callonStructLike1,
				expr: &seqExpr{
					pos: position{line: 172, col: 14, offset: 4118},
					exprs: []interface{}{
						&labeledExpr{
							pos:   position{line: 172, col: 14, offset: 4118},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 172, col: 19, offset: 4123},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 172, col: 30, offset: 4134},
							name: "__",
						},
						&litMatcher{
							pos:        position{line: 172, col: 33, offset: 4137},
							val:        "{",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 172, col: 37, offset: 4141},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 172, col: 40, offset: 4144},
							label: "fields",
							expr: &ruleRefExpr{
								pos:  position{line: 172, col: 47, offset: 4151},
								name: "FieldList",
							},
						},
						&litMatcher{
							pos:        position{line: 172, col: 57, offset: 4161},
							val:        "}",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 172, col: 61, offset: 4165},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 172, col: 63, offset: 4167},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 172, col: 75, offset: 4179},
								expr: &ruleRefExpr{
									pos:  position{line: 172, col: 75, offset: 4179},
									name: "TypeAnnotations",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 172, col: 92, offset: 4196},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "FieldList",
			pos:  position{line: 183, col: 1, offset: 4373},
			expr: &actionExpr{
				pos: position{line: 183, col: 13, offset: 4387},
				run: (*parser).callonFieldList1,
				expr: &labeledExpr{
					pos:   position{line: 183, col: 13, offset: 4387},
					label: "fields",
					expr: &zeroOrMoreExpr{
						pos: position{line: 183, col: 20, offset: 4394},
						expr: &seqExpr{
							pos: position{line: 183, col: 21, offset: 4395},
							exprs: []interface{}{
								&ruleRefExpr{
									pos:  position{line: 183, col: 21, offset: 4395},
									name: "Field",
								},
								&ruleRefExpr{
									pos:  position{line: 183, col: 27, offset: 4401},
									name: "__",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "Field",
			pos:  position{line: 192, col: 1, offset: 4561},
			expr: &actionExpr{
				pos: position{line: 192, col: 9, offset: 4571},
				run: (*parser).callonField1,
				expr: &seqExpr{
					pos: position{line: 192, col: 9, offset: 4571},
					exprs: []interface{}{
						&labeledExpr{
							pos:   position{line: 192, col: 9, offset: 4571},
							label: "id",
							expr: &ruleRefExpr{
								pos:  position{line: 192, col: 12, offset: 4574},
								name: "IntConstant",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 192, col: 24, offset: 4586},
							name: "_",
						},
						&litMatcher{
							pos:        position{line: 192, col: 26, offset: 4588},
							val:        ":",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 192, col: 30, offset: 4592},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 192, col: 32, offset: 4594},
							label: "req",
							expr: &zeroOrOneExpr{
								pos: position{line: 192, col: 36, offset: 4598},
								expr: &ruleRefExpr{
									pos:  position{line: 192, col: 36, offset: 4598},
									name: "FieldReq",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 192, col: 46, offset: 4608},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 192, col: 48, offset: 4610},
							label: "typ",
							expr: &ruleRefExpr{
								pos:  position{line: 192, col: 52, offset: 4614},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 192, col: 62, offset: 4624},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 192, col: 64, offset: 4626},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 192, col: 69, offset: 4631},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 192, col: 80, offset: 4642},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 192, col: 83, offset: 4645},
							label: "def",
							expr: &zeroOrOneExpr{
								pos: position{line: 192, col: 87, offset: 4649},
								expr: &seqExpr{
									pos: position{line: 192, col: 88, offset: 4650},
									exprs: []interface{}{
										&litMatcher{
											pos:        position{line: 192, col: 88, offset: 4650},
											val:        "=",
											ignoreCase: false,
										},
										&ruleRefExpr{
											pos:  position{line: 192, col: 92, offset: 4654},
											name: "_",
										},
										&ruleRefExpr{
											pos:  position{line: 192, col: 94, offset: 4656},
											name: "ConstValue",
										},
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 192, col: 107, offset: 4669},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 192, col: 109, offset: 4671},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 192, col: 121, offset: 4683},
								expr: &ruleRefExpr{
									pos:  position{line: 192, col: 121, offset: 4683},
									name: "TypeAnnotations",
								},
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 192, col: 138, offset: 4700},
							expr: &ruleRefExpr{
								pos:  position{line: 192, col: 138, offset: 4700},
								name: "ListSeparator",
							},
						},
					},
				},
			},
		},
		{
			name: "FieldReq",
			pos:  position{line: 208, col: 1, offset: 5003},
			expr: &actionExpr{
				pos: position{line: 208, col: 12, offset: 5016},
				run: (*parser).callonFieldReq1,
				expr: &choiceExpr{
					pos: position{line: 208, col: 13, offset: 5017},
					alternatives: []interface{}{
						&litMatcher{
							pos:        position{line: 208, col: 13, offset: 5017},
							val:        "required",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 208, col: 26, offset: 5030},
							val:        "optional",
							ignoreCase: false,
						},
					},
				},
			},
		},
		{
			name: "Service",
			pos:  position{line: 212, col: 1, offset: 5101},
			expr: &actionExpr{
				pos: position{line: 212, col: 11, offset: 5113},
				run: (*parser).callonService1,
				expr: &seqExpr{
					pos: position{line: 212, col: 11, offset: 5113},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 212, col: 11, offset: 5113},
							val:        "service",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 212, col: 21, offset: 5123},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 212, col: 23, offset: 5125},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 212, col: 28, offset: 5130},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 212, col: 39, offset: 5141},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 212, col: 41, offset: 5143},
							label: "extends",
							expr: &zeroOrOneExpr{
								pos: position{line: 212, col: 49, offset: 5151},
								expr: &seqExpr{
									pos: position{line: 212, col: 50, offset: 5152},
									exprs: []interface{}{
										&litMatcher{
											pos:        position{line: 212, col: 50, offset: 5152},
											val:        "extends",
											ignoreCase: false,
										},
										&ruleRefExpr{
											pos:  position{line: 212, col: 60, offset: 5162},
											name: "__",
										},
										&ruleRefExpr{
											pos:  position{line: 212, col: 63, offset: 5165},
											name: "Identifier",
										},
										&ruleRefExpr{
											pos:  position{line: 212, col: 74, offset: 5176},
											name: "__",
										},
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 212, col: 79, offset: 5181},
							name: "__",
						},
						&litMatcher{
							pos:        position{line: 212, col: 82, offset: 5184},
							val:        "{",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 212, col: 86, offset: 5188},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 212, col: 89, offset: 5191},
							label: "methods",
							expr: &zeroOrMoreExpr{
								pos: position{line: 212, col: 97, offset: 5199},
								expr: &seqExpr{
									pos: position{line: 212, col: 98, offset: 5200},
									exprs: []interface{}{
										&ruleRefExpr{
											pos:  position{line: 212, col: 98, offset: 5200},
											name: "Function",
										},
										&ruleRefExpr{
											pos:  position{line: 212, col: 107, offset: 5209},
											name: "__",
										},
									},
								},
							},
						},
						&choiceExpr{
							pos: position{line: 212, col: 113, offset: 5215},
							alternatives: []interface{}{
								&litMatcher{
									pos:        position{line: 212, col: 113, offset: 5215},
									val:        "}",
									ignoreCase: false,
								},
								&ruleRefExpr{
									pos:  position{line: 212, col: 119, offset: 5221},
									name: "EndOfServiceError",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 212, col: 138, offset: 5240},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 212, col: 140, offset: 5242},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 212, col: 152, offset: 5254},
								expr: &ruleRefExpr{
									pos:  position{line: 212, col: 152, offset: 5254},
									name: "TypeAnnotations",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 212, col: 170, offset: 5272},
							name: "EOS",
						},
					},
				},
			},
		},
		{
			name: "EndOfServiceError",
			pos:  position{line: 228, col: 1, offset: 5656},
			expr: &actionExpr{
				pos: position{line: 228, col: 21, offset: 5678},
				run: (*parser).callonEndOfServiceError1,
				expr: &anyMatcher{
					line: 228, col: 21, offset: 5678,
				},
			},
		},
		{
			name: "Function",
			pos:  position{line: 232, col: 1, offset: 5744},
			expr: &actionExpr{
				pos: position{line: 232, col: 12, offset: 5757},
				run: (*parser).callonFunction1,
				expr: &seqExpr{
					pos: position{line: 232, col: 12, offset: 5757},
					exprs: []interface{}{
						&labeledExpr{
							pos:   position{line: 232, col: 12, offset: 5757},
							label: "oneway",
							expr: &zeroOrOneExpr{
								pos: position{line: 232, col: 19, offset: 5764},
								expr: &seqExpr{
									pos: position{line: 232, col: 20, offset: 5765},
									exprs: []interface{}{
										&litMatcher{
											pos:        position{line: 232, col: 20, offset: 5765},
											val:        "oneway",
											ignoreCase: false,
										},
										&ruleRefExpr{
											pos:  position{line: 232, col: 29, offset: 5774},
											name: "__",
										},
									},
								},
							},
						},
						&labeledExpr{
							pos:   position{line: 232, col: 34, offset: 5779},
							label: "typ",
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 38, offset: 5783},
								name: "FunctionType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 232, col: 51, offset: 5796},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 232, col: 54, offset: 5799},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 59, offset: 5804},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 232, col: 70, offset: 5815},
							name: "_",
						},
						&litMatcher{
							pos:        position{line: 232, col: 72, offset: 5817},
							val:        "(",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 232, col: 76, offset: 5821},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 232, col: 79, offset: 5824},
							label: "arguments",
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 89, offset: 5834},
								name: "FieldList",
							},
						},
						&litMatcher{
							pos:        position{line: 232, col: 99, offset: 5844},
							val:        ")",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 232, col: 103, offset: 5848},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 232, col: 106, offset: 5851},
							label: "exceptions",
							expr: &zeroOrOneExpr{
								pos: position{line: 232, col: 117, offset: 5862},
								expr: &ruleRefExpr{
									pos:  position{line: 232, col: 117, offset: 5862},
									name: "Throws",
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 232, col: 125, offset: 5870},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 232, col: 127, offset: 5872},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 232, col: 139, offset: 5884},
								expr: &ruleRefExpr{
									pos:  position{line: 232, col: 139, offset: 5884},
									name: "TypeAnnotations",
								},
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 232, col: 156, offset: 5901},
							expr: &ruleRefExpr{
								pos:  position{line: 232, col: 156, offset: 5901},
								name: "ListSeparator",
							},
						},
					},
				},
			},
		},
		{
			name: "FunctionType",
			pos:  position{line: 256, col: 1, offset: 6325},
			expr: &actionExpr{
				pos: position{line: 256, col: 16, offset: 6342},
				run: (*parser).callonFunctionType1,
				expr: &labeledExpr{
					pos:   position{line: 256, col: 16, offset: 6342},
					label: "typ",
					expr: &choiceExpr{
						pos: position{line: 256, col: 21, offset: 6347},
						alternatives: []interface{}{
							&litMatcher{
								pos:        position{line: 256, col: 21, offset: 6347},
								val:        "void",
								ignoreCase: false,
							},
							&ruleRefExpr{
								pos:  position{line: 256, col: 30, offset: 6356},
								name: "FieldType",
							},
						},
					},
				},
			},
		},
		{
			name: "Throws",
			pos:  position{line: 263, col: 1, offset: 6463},
			expr: &actionExpr{
				pos: position{line: 263, col: 10, offset: 6474},
				run: (*parser).callonThrows1,
				expr: &seqExpr{
					pos: position{line: 263, col: 10, offset: 6474},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 263, col: 10, offset: 6474},
							val:        "throws",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 263, col: 19, offset: 6483},
							name: "__",
						},
						&litMatcher{
							pos:        position{line: 263, col: 22, offset: 6486},
							val:        "(",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 263, col: 26, offset: 6490},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 263, col: 29, offset: 6493},
							label: "exceptions",
							expr: &ruleRefExpr{
								pos:  position{line: 263, col: 40, offset: 6504},
								name: "FieldList",
							},
						},
						&litMatcher{
							pos:        position{line: 263, col: 50, offset: 6514},
							val:        ")",
							ignoreCase: false,
						},
					},
				},
			},
		},
		{
			name: "FieldType",
			pos:  position{line: 267, col: 1, offset: 6547},
			expr: &actionExpr{
				pos: position{line: 267, col: 13, offset: 6561},
				run: (*parser).callonFieldType1,
				expr: &labeledExpr{
					pos:   position{line: 267, col: 13, offset: 6561},
					label: "typ",
					expr: &choiceExpr{
						pos: position{line: 267, col: 18, offset: 6566},
						alternatives: []interface{}{
							&ruleRefExpr{
								pos:  position{line: 267, col: 18, offset: 6566},
								name: "BaseType",
							},
							&ruleRefExpr{
								pos:  position{line: 267, col: 29, offset: 6577},
								name: "ContainerType",
							},
							&ruleRefExpr{
								pos:  position{line: 267, col: 45, offset: 6593},
								name: "Identifier",
							},
						},
					},
				},
			},
		},
		{
			name: "DefinitionType",
			pos:  position{line: 274, col: 1, offset: 6703},
			expr: &actionExpr{
				pos: position{line: 274, col: 18, offset: 6722},
				run: (*parser).callonDefinitionType1,
				expr: &labeledExpr{
					pos:   position{line: 274, col: 18, offset: 6722},
					label: "typ",
					expr: &choiceExpr{
						pos: position{line: 274, col: 23, offset: 6727},
						alternatives: []interface{}{
							&ruleRefExpr{
								pos:  position{line: 274, col: 23, offset: 6727},
								name: "BaseType",
							},
							&ruleRefExpr{
								pos:  position{line: 274, col: 34, offset: 6738},
								name: "ContainerType",
							},
						},
					},
				},
			},
		},
		{
			name: "BaseType",
			pos:  position{line: 278, col: 1, offset: 6775},
			expr: &actionExpr{
				pos: position{line: 278, col: 12, offset: 6788},
				run: (*parser).callonBaseType1,
				expr: &seqExpr{
					pos: position{line: 278, col: 12, offset: 6788},
					exprs: []interface{}{
						&labeledExpr{
							pos:   position{line: 278, col: 12, offset: 6788},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 278, col: 17, offset: 6793},
								name: "BaseTypeName",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 278, col: 30, offset: 6806},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 278, col: 32, offset: 6808},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 278, col: 44, offset: 6820},
								expr: &ruleRefExpr{
									pos:  position{line: 278, col: 44, offset: 6820},
									name: "TypeAnnotations",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "BaseTypeName",
			pos:  position{line: 285, col: 1, offset: 6931},
			expr: &actionExpr{
				pos: position{line: 285, col: 16, offset: 6948},
				run: (*parser).callonBaseTypeName1,
				expr: &choiceExpr{
					pos: position{line: 285, col: 17, offset: 6949},
					alternatives: []interface{}{
						&litMatcher{
							pos:        position{line: 285, col: 17, offset: 6949},
							val:        "bool",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 26, offset: 6958},
							val:        "byte",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 35, offset: 6967},
							val:        "i16",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 43, offset: 6975},
							val:        "i32",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 51, offset: 6983},
							val:        "i64",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 59, offset: 6991},
							val:        "double",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 70, offset: 7002},
							val:        "string",
							ignoreCase: false,
						},
						&litMatcher{
							pos:        position{line: 285, col: 81, offset: 7013},
							val:        "binary",
							ignoreCase: false,
						},
					},
				},
			},
		},
		{
			name: "ContainerType",
			pos:  position{line: 289, col: 1, offset: 7057},
			expr: &actionExpr{
				pos: position{line: 289, col: 17, offset: 7075},
				run: (*parser).callonContainerType1,
				expr: &labeledExpr{
					pos:   position{line: 289, col: 17, offset: 7075},
					label: "typ",
					expr: &choiceExpr{
						pos: position{line: 289, col: 22, offset: 7080},
						alternatives: []interface{}{
							&ruleRefExpr{
								pos:  position{line: 289, col: 22, offset: 7080},
								name: "MapType",
							},
							&ruleRefExpr{
								pos:  position{line: 289, col: 32, offset: 7090},
								name: "SetType",
							},
							&ruleRefExpr{
								pos:  position{line: 289, col: 42, offset: 7100},
								name: "ListType",
							},
						},
					},
				},
			},
		},
		{
			name: "MapType",
			pos:  position{line: 293, col: 1, offset: 7132},
			expr: &actionExpr{
				pos: position{line: 293, col: 11, offset: 7144},
				run: (*parser).callonMapType1,
				expr: &seqExpr{
					pos: position{line: 293, col: 11, offset: 7144},
					exprs: []interface{}{
						&zeroOrOneExpr{
							pos: position{line: 293, col: 11, offset: 7144},
							expr: &ruleRefExpr{
								pos:  position{line: 293, col: 11, offset: 7144},
								name: "CppType",
							},
						},
						&litMatcher{
							pos:        position{line: 293, col: 20, offset: 7153},
							val:        "map",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 293, col: 26, offset: 7159},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 293, col: 29, offset: 7162},
							val:        "<",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 293, col: 33, offset: 7166},
							name: "WS",
						},
						&labeledExpr{
							pos:   position{line: 293, col: 36, offset: 7169},
							label: "key",
							expr: &ruleRefExpr{
								pos:  position{line: 293, col: 40, offset: 7173},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 293, col: 50, offset: 7183},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 293, col: 53, offset: 7186},
							val:        ",",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 293, col: 57, offset: 7190},
							name: "WS",
						},
						&labeledExpr{
							pos:   position{line: 293, col: 60, offset: 7193},
							label: "value",
							expr: &ruleRefExpr{
								pos:  position{line: 293, col: 66, offset: 7199},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 293, col: 76, offset: 7209},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 293, col: 79, offset: 7212},
							val:        ">",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 293, col: 83, offset: 7216},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 293, col: 85, offset: 7218},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 293, col: 97, offset: 7230},
								expr: &ruleRefExpr{
									pos:  position{line: 293, col: 97, offset: 7230},
									name: "TypeAnnotations",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "SetType",
			pos:  position{line: 302, col: 1, offset: 7385},
			expr: &actionExpr{
				pos: position{line: 302, col: 11, offset: 7397},
				run: (*parser).callonSetType1,
				expr: &seqExpr{
					pos: position{line: 302, col: 11, offset: 7397},
					exprs: []interface{}{
						&zeroOrOneExpr{
							pos: position{line: 302, col: 11, offset: 7397},
							expr: &ruleRefExpr{
								pos:  position{line: 302, col: 11, offset: 7397},
								name: "CppType",
							},
						},
						&litMatcher{
							pos:        position{line: 302, col: 20, offset: 7406},
							val:        "set",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 302, col: 26, offset: 7412},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 302, col: 29, offset: 7415},
							val:        "<",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 302, col: 33, offset: 7419},
							name: "WS",
						},
						&labeledExpr{
							pos:   position{line: 302, col: 36, offset: 7422},
							label: "typ",
							expr: &ruleRefExpr{
								pos:  position{line: 302, col: 40, offset: 7426},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 302, col: 50, offset: 7436},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 302, col: 53, offset: 7439},
							val:        ">",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 302, col: 57, offset: 7443},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 302, col: 59, offset: 7445},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 302, col: 71, offset: 7457},
								expr: &ruleRefExpr{
									pos:  position{line: 302, col: 71, offset: 7457},
									name: "TypeAnnotations",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ListType",
			pos:  position{line: 310, col: 1, offset: 7586},
			expr: &actionExpr{
				pos: position{line: 310, col: 12, offset: 7599},
				run: (*parser).callonListType1,
				expr: &seqExpr{
					pos: position{line: 310, col: 12, offset: 7599},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 310, col: 12, offset: 7599},
							val:        "list",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 310, col: 19, offset: 7606},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 310, col: 22, offset: 7609},
							val:        "<",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 310, col: 26, offset: 7613},
							name: "WS",
						},
						&labeledExpr{
							pos:   position{line: 310, col: 29, offset: 7616},
							label: "typ",
							expr: &ruleRefExpr{
								pos:  position{line: 310, col: 33, offset: 7620},
								name: "FieldType",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 310, col: 43, offset: 7630},
							name: "WS",
						},
						&litMatcher{
							pos:        position{line: 310, col: 46, offset: 7633},
							val:        ">",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 310, col: 50, offset: 7637},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 310, col: 52, offset: 7639},
							label: "annotations",
							expr: &zeroOrOneExpr{
								pos: position{line: 310, col: 64, offset: 7651},
								expr: &ruleRefExpr{
									pos:  position{line: 310, col: 64, offset: 7651},
									name: "TypeAnnotations",
								},
							},
						},
					},
				},
			},
		},
		{
			name: "CppType",
			pos:  position{line: 318, col: 1, offset: 7781},
			expr: &actionExpr{
				pos: position{line: 318, col: 11, offset: 7793},
				run: (*parser).callonCppType1,
				expr: &seqExpr{
					pos: position{line: 318, col: 11, offset: 7793},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 318, col: 11, offset: 7793},
							val:        "cpp_type",
							ignoreCase: false,
						},
						&labeledExpr{
							pos:   position{line: 318, col: 22, offset: 7804},
							label: "cppType",
							expr: &ruleRefExpr{
								pos:  position{line: 318, col: 30, offset: 7812},
								name: "Literal",
							},
						},
					},
				},
			},
		},
		{
			name: "ConstValue",
			pos:  position{line: 322, col: 1, offset: 7846},
			expr: &choiceExpr{
				pos: position{line: 322, col: 14, offset: 7861},
				alternatives: []interface{}{
					&ruleRefExpr{
						pos:  position{line: 322, col: 14, offset: 7861},
						name: "Literal",
					},
					&ruleRefExpr{
						pos:  position{line: 322, col: 24, offset: 7871},
						name: "DoubleConstant",
					},
					&ruleRefExpr{
						pos:  position{line: 322, col: 41, offset: 7888},
						name: "IntConstant",
					},
					&ruleRefExpr{
						pos:  position{line: 322, col: 55, offset: 7902},
						name: "ConstMap",
					},
					&ruleRefExpr{
						pos:  position{line: 322, col: 66, offset: 7913},
						name: "ConstList",
					},
					&ruleRefExpr{
						pos:  position{line: 322, col: 78, offset: 7925},
						name: "Identifier",
					},
				},
			},
		},
		{
			name: "TypeAnnotations",
			pos:  position{line: 324, col: 1, offset: 7937},
			expr: &actionExpr{
				pos: position{line: 324, col: 19, offset: 7957},
				run: (*parser).callonTypeAnnotations1,
				expr: &seqExpr{
					pos: position{line: 324, col: 19, offset: 7957},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 324, col: 19, offset: 7957},
							val:        "(",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 324, col: 23, offset: 7961},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 324, col: 26, offset: 7964},
							label: "annotations",
							expr: &zeroOrMoreExpr{
								pos: position{line: 324, col: 38, offset: 7976},
								expr: &ruleRefExpr{
									pos:  position{line: 324, col: 38, offset: 7976},
									name: "TypeAnnotation",
								},
							},
						},
						&litMatcher{
							pos:        position{line: 324, col: 54, offset: 7992},
							val:        ")",
							ignoreCase: false,
						},
					},
				},
			},
		},
		{
			name: "TypeAnnotation",
			pos:  position{line: 332, col: 1, offset: 8138},
			expr: &actionExpr{
				pos: position{line: 332, col: 18, offset: 8157},
				run: (*parser).callonTypeAnnotation1,
				expr: &seqExpr{
					pos: position{line: 332, col: 18, offset: 8157},
					exprs: []interface{}{
						&labeledExpr{
							pos:   position{line: 332, col: 18, offset: 8157},
							label: "name",
							expr: &ruleRefExpr{
								pos:  position{line: 332, col: 23, offset: 8162},
								name: "Identifier",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 332, col: 34, offset: 8173},
							name: "_",
						},
						&labeledExpr{
							pos:   position{line: 332, col: 36, offset: 8175},
							label: "value",
							expr: &zeroOrOneExpr{
								pos: position{line: 332, col: 42, offset: 8181},
								expr: &actionExpr{
									pos: position{line: 332, col: 43, offset: 8182},
									run: (*parser).callonTypeAnnotation8,
									expr: &seqExpr{
										pos: position{line: 332, col: 43, offset: 8182},
										exprs: []interface{}{
											&litMatcher{
												pos:        position{line: 332, col: 43, offset: 8182},
												val:        "=",
												ignoreCase: false,
											},
											&ruleRefExpr{
												pos:  position{line: 332, col: 47, offset: 8186},
												name: "__",
											},
											&labeledExpr{
												pos:   position{line: 332, col: 50, offset: 8189},
												label: "value",
												expr: &ruleRefExpr{
													pos:  position{line: 332, col: 56, offset: 8195},
													name: "Literal",
												},
											},
										},
									},
								},
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 332, col: 88, offset: 8227},
							expr: &ruleRefExpr{
								pos:  position{line: 332, col: 88, offset: 8227},
								name: "ListSeparator",
							},
						},
						&ruleRefExpr{
							pos:  position{line: 332, col: 103, offset: 8242},
							name: "__",
						},
					},
				},
			},
		},
		{
			name: "IntConstant",
			pos:  position{line: 343, col: 1, offset: 8405},
			expr: &actionExpr{
				pos: position{line: 343, col: 15, offset: 8421},
				run: (*parser).callonIntConstant1,
				expr: &seqExpr{
					pos: position{line: 343, col: 15, offset: 8421},
					exprs: []interface{}{
						&zeroOrOneExpr{
							pos: position{line: 343, col: 15, offset: 8421},
							expr: &charClassMatcher{
								pos:        position{line: 343, col: 15, offset: 8421},
								val:        "[-+]",
								chars:      []rune{'-', '+'},
								ignoreCase: false,
								inverted:   false,
							},
						},
						&oneOrMoreExpr{
							pos: position{line: 343, col: 21, offset: 8427},
							expr: &ruleRefExpr{
								pos:  position{line: 343, col: 21, offset: 8427},
								name: "Digit",
							},
						},
					},
				},
			},
		},
		{
			name: "DoubleConstant",
			pos:  position{line: 347, col: 1, offset: 8488},
			expr: &actionExpr{
				pos: position{line: 347, col: 18, offset: 8507},
				run: (*parser).callonDoubleConstant1,
				expr: &seqExpr{
					pos: position{line: 347, col: 18, offset: 8507},
					exprs: []interface{}{
						&zeroOrOneExpr{
							pos: position{line: 347, col: 18, offset: 8507},
							expr: &charClassMatcher{
								pos:        position{line: 347, col: 18, offset: 8507},
								val:        "[+-]",
								chars:      []rune{'+', '-'},
								ignoreCase: false,
								inverted:   false,
							},
						},
						&zeroOrMoreExpr{
							pos: position{line: 347, col: 24, offset: 8513},
							expr: &ruleRefExpr{
								pos:  position{line: 347, col: 24, offset: 8513},
								name: "Digit",
							},
						},
						&litMatcher{
							pos:        position{line: 347, col: 31, offset: 8520},
							val:        ".",
							ignoreCase: false,
						},
						&zeroOrMoreExpr{
							pos: position{line: 347, col: 35, offset: 8524},
							expr: &ruleRefExpr{
								pos:  position{line: 347, col: 35, offset: 8524},
								name: "Digit",
							},
						},
						&zeroOrOneExpr{
							pos: position{line: 347, col: 42, offset: 8531},
							expr: &seqExpr{
								pos: position{line: 347, col: 44, offset: 8533},
								exprs: []interface{}{
									&charClassMatcher{
										pos:        position{line: 347, col: 44, offset: 8533},
										val:        "['Ee']",
										chars:      []rune{'\'', 'E', 'e', '\''},
										ignoreCase: false,
										inverted:   false,
									},
									&ruleRefExpr{
										pos:  position{line: 347, col: 51, offset: 8540},
										name: "IntConstant",
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ConstList",
			pos:  position{line: 351, col: 1, offset: 8607},
			expr: &actionExpr{
				pos: position{line: 351, col: 13, offset: 8621},
				run: (*parser).callonConstList1,
				expr: &seqExpr{
					pos: position{line: 351, col: 13, offset: 8621},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 351, col: 13, offset: 8621},
							val:        "[",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 351, col: 17, offset: 8625},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 351, col: 20, offset: 8628},
							label: "values",
							expr: &zeroOrMoreExpr{
								pos: position{line: 351, col: 27, offset: 8635},
								expr: &seqExpr{
									pos: position{line: 351, col: 28, offset: 8636},
									exprs: []interface{}{
										&ruleRefExpr{
											pos:  position{line: 351, col: 28, offset: 8636},
											name: "ConstValue",
										},
										&ruleRefExpr{
											pos:  position{line: 351, col: 39, offset: 8647},
											name: "__",
										},
										&zeroOrOneExpr{
											pos: position{line: 351, col: 42, offset: 8650},
											expr: &ruleRefExpr{
												pos:  position{line: 351, col: 42, offset: 8650},
												name: "ListSeparator",
											},
										},
										&ruleRefExpr{
											pos:  position{line: 351, col: 57, offset: 8665},
											name: "__",
										},
									},
								},
							},
						},
						&ruleRefExpr{
							pos:  position{line: 351, col: 62, offset: 8670},
							name: "__",
						},
						&litMatcher{
							pos:        position{line: 351, col: 65, offset: 8673},
							val:        "]",
							ignoreCase: false,
						},
					},
				},
			},
		},
		{
			name: "ConstMap",
			pos:  position{line: 360, col: 1, offset: 8846},
			expr: &actionExpr{
				pos: position{line: 360, col: 12, offset: 8859},
				run: (*parser).callonConstMap1,
				expr: &seqExpr{
					pos: position{line: 360, col: 12, offset: 8859},
					exprs: []interface{}{
						&litMatcher{
							pos:        position{line: 360, col: 12, offset: 8859},
							val:        "{",
							ignoreCase: false,
						},
						&ruleRefExpr{
							pos:  position{line: 360, col: 16, offset: 8863},
							name: "__",
						},
						&labeledExpr{
							pos:   position{line: 360, col: 19, offset: 8866},
							label: "values",
							expr: &zeroOrMoreExpr{
								pos: position{line: 360, col: 26, offset: 8873},
								expr: &seqExpr{
									pos: position{line: 360, col: 27, offset: 8874},
									exprs: []interface{}{
										&ruleRefExpr{
											pos:  position{line: 360, col: 27, offset: 8874},
											name: "ConstValue",
										},
										&ruleRefExpr{
											pos:  position{line: 360, col: 38, offset: 8885},
											name: "__",
										},
										&litMatcher{
											pos:        position{line: 360, col: 41, offset: 8888},
											val:        ":",
											ignoreCase: false,
										},
										&ruleRefExpr{
											pos:  position{line: 360, col: 45, offset: 8892},
											name: "__",
										},
										&ruleRefExpr{
											pos:  position{line: 360, col: 48, offset: 8895},
											name: "ConstValue",
										},
										&ruleRefExpr{
											pos:  position{line: 360, col: 59, offset: 8906},
											name: "__",
										},
										&choiceExpr{
											pos: position{line: 360, col: 63, offset: 8910},
											alternatives: []interface{}{
												&litMatcher{
													pos:        position{line: 360, col: 63, offset: 8910},
													val:        ",",
													ignoreCase: false,
												},
												&andExpr{
													pos: position{line: 360, col: 69, offset: 8916},
													expr: &litMatcher{
														pos:        position{line: 360, col: 70, offset: 8917},
														val:        "}",
														ignoreCase: false,
													},
												},
											},
										},
										&ruleRefExpr{
											pos:  position{line: 360, col: 75, offset: 8922},
											name: "__",
										},
									},
								},
							},
						},
						&litMatcher{
							pos:        position{line: 360, col: 80, offset: 8927},
							val:        "}",
							ignoreCase: false,
						},
					},
				},
			},
		},
		{
			name: "Literal",
			pos:  position{line: 376, col: 1, offset: 9173},
			expr: &actionExpr{
				pos: position{line: 376, col: 11, offset: 9185},
				run: (*parser).callonLiteral1,
				expr: &choiceExpr{
					pos: position{line: 376, col: 12, offset: 9186},
					alternatives: []interface{}{
						&seqExpr{
							pos: position{line: 376, col: 13, offset: 9187},
							exprs: []interface{}{
								&litMatcher{
									pos:        position{line: 376, col: 13, offset: 9187},
									val:        "\"",
									ignoreCase: false,
								},
								&zeroOrMoreExpr{
									pos: position{line: 376, col: 17, offset: 9191},
									expr: &choiceExpr{
										pos: position{line: 376, col: 18, offset: 9192},
										alternatives: []interface{}{
											&litMatcher{
												pos:        position{line: 376, col: 18, offset: 9192},
												val:        "\\\"",
												ignoreCase: false,
											},
											&charClassMatcher{
												pos:        position{line: 376, col: 25, offset: 9199},
												val:        "[^\"]",
												chars:      []rune{'"'},
												ignoreCase: false,
												inverted:   true,
											},
										},
									},
								},
								&litMatcher{
									pos:        position{line: 376, col: 32, offset: 9206},
									val:        "\"",
									ignoreCase: false,
								},
							},
						},
						&seqExpr{
							pos: position{line: 376, col: 40, offset: 9214},
							exprs: []interface{}{
								&litMatcher{
									pos:        position{line: 376, col: 40, offset: 9214},
									val:        "'",
									ignoreCase: false,
								},
								&zeroOrMoreExpr{
									pos: position{line: 376, col: 45, offset: 9219},
									expr: &choiceExpr{
										pos: position{line: 376, col: 46, offset: 9220},
										alternatives: []interface{}{
											&litMatcher{
												pos:        position{line: 376, col: 46, offset: 9220},
												val:        "\\'",
												ignoreCase: false,
											},
											&charClassMatcher{
												pos:        position{line: 376, col: 53, offset: 9227},
												val:        "[^']",
												chars:      []rune{'\''},
												ignoreCase: false,
												inverted:   true,
											},
										},
									},
								},
								&litMatcher{
									pos:        position{line: 376, col: 60, offset: 9234},
									val:        "'",
									ignoreCase: false,
								},
							},
						},
					},
				},
			},
		},
		{
			name: "Identifier",
			pos:  position{line: 383, col: 1, offset: 9435},
			expr: &actionExpr{
				pos: position{line: 383, col: 14, offset: 9450},
				run: (*parser).callonIdentifier1,
				expr: &seqExpr{
					pos: position{line: 383, col: 14, offset: 9450},
					exprs: []interface{}{
						&oneOrMoreExpr{
							pos: position{line: 383, col: 14, offset: 9450},
							expr: &choiceExpr{
								pos: position{line: 383, col: 15, offset: 9451},
								alternatives: []interface{}{
									&ruleRefExpr{
										pos:  position{line: 383, col: 15, offset: 9451},
										name: "Letter",
									},
									&litMatcher{
										pos:        position{line: 383, col: 24, offset: 9460},
										val:        "_",
										ignoreCase: false,
									},
								},
							},
						},
						&zeroOrMoreExpr{
							pos: position{line: 383, col: 30, offset: 9466},
							expr: &choiceExpr{
								pos: position{line: 383, col: 31, offset: 9467},
								alternatives: []interface{}{
									&ruleRefExpr{
										pos:  position{line: 383, col: 31, offset: 9467},
										name: "Letter",
									},
									&ruleRefExpr{
										pos:  position{line: 383, col: 40, offset: 9476},
										name: "Digit",
									},
									&charClassMatcher{
										pos:        position{line: 383, col: 48, offset: 9484},
										val:        "[._]",
										chars:      []rune{'.', '_'},
										ignoreCase: false,
										inverted:   false,
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "ListSeparator",
			pos:  position{line: 387, col: 1, offset: 9536},
			expr: &charClassMatcher{
				pos:        position{line: 387, col: 17, offset: 9554},
				val:        "[,;]",
				chars:      []rune{',', ';'},
				ignoreCase: false,
				inverted:   false,
			},
		},
		{
			name: "Letter",
			pos:  position{line: 388, col: 1, offset: 9559},
			expr: &charClassMatcher{
				pos:        position{line: 388, col: 10, offset: 9570},
				val:        "[A-Za-z]",
				ranges:     []rune{'A', 'Z', 'a', 'z'},
				ignoreCase: false,
				inverted:   false,
			},
		},
		{
			name: "Digit",
			pos:  position{line: 389, col: 1, offset: 9579},
			expr: &charClassMatcher{
				pos:        position{line: 389, col: 9, offset: 9589},
				val:        "[0-9]",
				ranges:     []rune{'0', '9'},
				ignoreCase: false,
				inverted:   false,
			},
		},
		{
			name: "SourceChar",
			pos:  position{line: 393, col: 1, offset: 9600},
			expr: &anyMatcher{
				line: 393, col: 14, offset: 9615,
			},
		},
		{
			name: "Comment",
			pos:  position{line: 394, col: 1, offset: 9617},
			expr: &choiceExpr{
				pos: position{line: 394, col: 11, offset: 9629},
				alternatives: []interface{}{
					&ruleRefExpr{
						pos:  position{line: 394, col: 11, offset: 9629},
						name: "MultiLineComment",
					},
					&ruleRefExpr{
						pos:  position{line: 394, col: 30, offset: 9648},
						name: "SingleLineComment",
					},
				},
			},
		},
		{
			name: "MultiLineComment",
			pos:  position{line: 395, col: 1, offset: 9666},
			expr: &seqExpr{
				pos: position{line: 395, col: 20, offset: 9687},
				exprs: []interface{}{
					&litMatcher{
						pos:        position{line: 395, col: 20, offset: 9687},
						val:        "/*",
						ignoreCase: false,
					},
					&zeroOrMoreExpr{
						pos: position{line: 395, col: 25, offset: 9692},
						expr: &seqExpr{
							pos: position{line: 395, col: 27, offset: 9694},
							exprs: []interface{}{
								&notExpr{
									pos: position{line: 395, col: 27, offset: 9694},
									expr: &litMatcher{
										pos:        position{line: 395, col: 28, offset: 9695},
										val:        "*/",
										ignoreCase: false,
									},
								},
								&ruleRefExpr{
									pos:  position{line: 395, col: 33, offset: 9700},
									name: "SourceChar",
								},
							},
						},
					},
					&litMatcher{
						pos:        position{line: 395, col: 47, offset: 9714},
						val:        "*/",
						ignoreCase: false,
					},
				},
			},
		},
		{
			name: "MultiLineCommentNoLineTerminator",
			pos:  position{line: 396, col: 1, offset: 9719},
			expr: &seqExpr{
				pos: position{line: 396, col: 36, offset: 9756},
				exprs: []interface{}{
					&litMatcher{
						pos:        position{line: 396, col: 36, offset: 9756},
						val:        "/*",
						ignoreCase: false,
					},
					&zeroOrMoreExpr{
						pos: position{line: 396, col: 41, offset: 9761},
						expr: &seqExpr{
							pos: position{line: 396, col: 43, offset: 9763},
							exprs: []interface{}{
								&notExpr{
									pos: position{line: 396, col: 43, offset: 9763},
									expr: &choiceExpr{
										pos: position{line: 396, col: 46, offset: 9766},
										alternatives: []interface{}{
											&litMatcher{
												pos:        position{line: 396, col: 46, offset: 9766},
												val:        "*/",
												ignoreCase: false,
											},
											&ruleRefExpr{
												pos:  position{line: 396, col: 53, offset: 9773},
												name: "EOL",
											},
										},
									},
								},
								&ruleRefExpr{
									pos:  position{line: 396, col: 59, offset: 9779},
									name: "SourceChar",
								},
							},
						},
					},
					&litMatcher{
						pos:        position{line: 396, col: 73, offset: 9793},
						val:        "*/",
						ignoreCase: false,
					},
				},
			},
		},
		{
			name: "SingleLineComment",
			pos:  position{line: 397, col: 1, offset: 9798},
			expr: &choiceExpr{
				pos: position{line: 397, col: 21, offset: 9820},
				alternatives: []interface{}{
					&seqExpr{
						pos: position{line: 397, col: 22, offset: 9821},
						exprs: []interface{}{
							&litMatcher{
								pos:        position{line: 397, col: 22, offset: 9821},
								val:        "//",
								ignoreCase: false,
							},
							&zeroOrMoreExpr{
								pos: position{line: 397, col: 27, offset: 9826},
								expr: &seqExpr{
									pos: position{line: 397, col: 29, offset: 9828},
									exprs: []interface{}{
										&notExpr{
											pos: position{line: 397, col: 29, offset: 9828},
											expr: &ruleRefExpr{
												pos:  position{line: 397, col: 30, offset: 9829},
												name: "EOL",
											},
										},
										&ruleRefExpr{
											pos:  position{line: 397, col: 34, offset: 9833},
											name: "SourceChar",
										},
									},
								},
							},
						},
					},
					&seqExpr{
						pos: position{line: 397, col: 52, offset: 9851},
						exprs: []interface{}{
							&litMatcher{
								pos:        position{line: 397, col: 52, offset: 9851},
								val:        "#",
								ignoreCase: false,
							},
							&zeroOrMoreExpr{
								pos: position{line: 397, col: 56, offset: 9855},
								expr: &seqExpr{
									pos: position{line: 397, col: 58, offset: 9857},
									exprs: []interface{}{
										&notExpr{
											pos: position{line: 397, col: 58, offset: 9857},
											expr: &ruleRefExpr{
												pos:  position{line: 397, col: 59, offset: 9858},
												name: "EOL",
											},
										},
										&ruleRefExpr{
											pos:  position{line: 397, col: 63, offset: 9862},
											name: "SourceChar",
										},
									},
								},
							},
						},
					},
				},
			},
		},
		{
			name: "__",
			pos:  position{line: 399, col: 1, offset: 9878},
			expr: &zeroOrMoreExpr{
				pos: position{line: 399, col: 6, offset: 9885},
				expr: &choiceExpr{
					pos: position{line: 399, col: 8, offset: 9887},
					alternatives: []interface{}{
						&ruleRefExpr{
							pos:  position{line: 399, col: 8, offset: 9887},
							name: "Whitespace",
						},
						&ruleRefExpr{
							pos:  position{line: 399, col: 21, offset: 9900},
							name: "EOL",
						},
						&ruleRefExpr{
							pos:  position{line: 399, col: 27, offset: 9906},
							name: "Comment",
						},
					},
				},
			},
		},
		{
			name: "_",
			pos:  position{line: 400, col: 1, offset: 9917},
			expr: &zeroOrMoreExpr{
				pos: position{line: 400, col: 5, offset: 9923},
				expr: &choiceExpr{
					pos: position{line: 400, col: 7, offset: 9925},
					alternatives: []interface{}{
						&ruleRefExpr{
							pos:  position{line: 400, col: 7, offset: 9925},
							name: "Whitespace",
						},
						&ruleRefExpr{
							pos:  position{line: 400, col: 20, offset: 9938},
							name: "MultiLineCommentNoLineTerminator",
						},
					},
				},
			},
		},
		{
			name: "WS",
			pos:  position{line: 401, col: 1, offset: 9974},
			expr: &zeroOrMoreExpr{
				pos: position{line: 401, col: 6, offset: 9981},
				expr: &ruleRefExpr{
					pos:  position{line: 401, col: 6, offset: 9981},
					name: "Whitespace",
				},
			},
		},
		{
			name: "Whitespace",
			pos:  position{line: 403, col: 1, offset: 9994},
			expr: &charClassMatcher{
				pos:        position{line: 403, col: 14, offset: 10009},
				val:        "[ \\t\\r]",
				chars:      []rune{' ', '\t', '\r'},
				ignoreCase: false,
				inverted:   false,
			},
		},
		{
			name: "EOL",
			pos:  position{line: 404, col: 1, offset: 10017},
			expr: &litMatcher{
				pos:        position{line: 404, col: 7, offset: 10025},
				val:        "\n",
				ignoreCase: false,
			},
		},
		{
			name: "EOS",
			pos:  position{line: 405, col: 1, offset: 10030},
			expr: &choiceExpr{
				pos: position{line: 405, col: 7, offset: 10038},
				alternatives: []interface{}{
					&seqExpr{
						pos: position{line: 405, col: 7, offset: 10038},
						exprs: []interface{}{
							&ruleRefExpr{
								pos:  position{line: 405, col: 7, offset: 10038},
								name: "__",
							},
							&litMatcher{
								pos:        position{line: 405, col: 10, offset: 10041},
								val:        ";",
								ignoreCase: false,
							},
						},
					},
					&seqExpr{
						pos: position{line: 405, col: 16, offset: 10047},
						exprs: []interface{}{
							&ruleRefExpr{
								pos:  position{line: 405, col: 16, offset: 10047},
								name: "_",
							},
							&zeroOrOneExpr{
								pos: position{line: 405, col: 18, offset: 10049},
								expr: &ruleRefExpr{
									pos:  position{line: 405, col: 18, offset: 10049},
									name: "SingleLineComment",
								},
							},
							&ruleRefExpr{
								pos:  position{line: 405, col: 37, offset: 10068},
								name: "EOL",
							},
						},
					},
					&seqExpr{
						pos: position{line: 405, col: 43, offset: 10074},
						exprs: []interface{}{
							&ruleRefExpr{
								pos:  position{line: 405, col: 43, offset: 10074},
								name: "__",
							},
							&ruleRefExpr{
								pos:  position{line: 405, col: 46, offset: 10077},
								name: "EOF",
							},
						},
					},
				},
			},
		},
		{
			name: "EOF",
			pos:  position{line: 407, col: 1, offset: 10082},
			expr: &notExpr{
				pos: position{line: 407, col: 7, offset: 10090},
				expr: &anyMatcher{
					line: 407, col: 8, offset: 10091,
				},
			},
		},
	},
}

func (c *current) onGrammar1(statements interface{}) (interface{}, error) {
	thrift := &Thrift{
		Includes:   make(map[string]string),
		Namespaces: make(map[string]string),
		Typedefs:   make(map[string]*Typedef),
		Constants:  make(map[string]*Constant),
		Enums:      make(map[string]*Enum),
		Structs:    make(map[string]*Struct),
		Exceptions: make(map[string]*Struct),
		Unions:     make(map[string]*Struct),
		Services:   make(map[string]*Service),
	}
	stmts := toIfaceSlice(statements)
	for _, st := range stmts {
		switch v := st.([]interface{})[0].(type) {
		case *namespace:
			thrift.Namespaces[v.scope] = v.namespace
		case *Constant:
			thrift.Constants[v.Name] = v
		case *Enum:
			thrift.Enums[v.Name] = v
		case *Typedef:
			thrift.Typedefs[v.Alias] = v
		case *Struct:
			thrift.Structs[v.Name] = v
		case exception:
			thrift.Exceptions[v.Name] = (*Struct)(v)
		case union:
			thrift.Unions[v.Name] = unionToStruct(v)
		case *Service:
			thrift.Services[v.Name] = v
		case include:
			name := filepath.Base(string(v))
			if ix := strings.LastIndex(name, "."); ix > 0 {
				name = name[:ix]
			}
			thrift.Includes[name] = string(v)
		default:
			return nil, fmt.Errorf("parser: unknown value %#v", v)
		}
	}
	return thrift, nil
}

func (p *parser) callonGrammar1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onGrammar1(stack["statements"])
}

func (c *current) onSyntaxError1() (interface{}, error) {
	return nil, errors.New("parser: syntax error")
}

func (p *parser) callonSyntaxError1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSyntaxError1()
}

func (c *current) onInclude1(file interface{}) (interface{}, error) {
	return include(file.(string)), nil
}

func (p *parser) callonInclude1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onInclude1(stack["file"])
}

func (c *current) onNamespace1(scope, ns interface{}) (interface{}, error) {
	return &namespace{
		scope:     ifaceSliceToString(scope),
		namespace: string(ns.(Identifier)),
	}, nil
}

func (p *parser) callonNamespace1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onNamespace1(stack["scope"], stack["ns"])
}

func (c *current) onConst1(typ, name, value interface{}) (interface{}, error) {
	return &Constant{
		Name:  string(name.(Identifier)),
		Type:  typ.(*Type),
		Value: value,
	}, nil
}

func (p *parser) callonConst1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConst1(stack["typ"], stack["name"], stack["value"])
}

func (c *current) onEnum1(name, values, annotations interface{}) (interface{}, error) {
	vs := toIfaceSlice(values)
	en := &Enum{
		Name:        string(name.(Identifier)),
		Values:      make(map[string]*EnumValue, len(vs)),
		Annotations: toAnnotations(annotations),
	}
	// Assigns numbers in order. This will behave badly if some values are
	// defined and other are not, but I think that's ok since that's a silly
	// thing to do.
	next := 0
	for _, v := range vs {
		ev := v.([]interface{})[0].(*EnumValue)
		if ev.Value < 0 {
			ev.Value = next
		}
		if ev.Value >= next {
			next = ev.Value + 1
		}
		en.Values[ev.Name] = ev
	}
	return en, nil
}

func (p *parser) callonEnum1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEnum1(stack["name"], stack["values"], stack["annotations"])
}

func (c *current) onEnumValue1(name, value, annotations interface{}) (interface{}, error) {
	ev := &EnumValue{
		Name:        string(name.(Identifier)),
		Value:       -1,
		Annotations: toAnnotations(annotations),
	}
	if value != nil {
		ev.Value = int(value.([]interface{})[2].(int64))
	}
	return ev, nil
}

func (p *parser) callonEnumValue1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEnumValue1(stack["name"], stack["value"], stack["annotations"])
}

func (c *current) onTypeDef1(typ, name, annotations interface{}) (interface{}, error) {
	return &Typedef{
		Type:        typ.(*Type),
		Alias:       string(name.(Identifier)),
		Annotations: toAnnotations(annotations),
	}, nil
}

func (p *parser) callonTypeDef1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTypeDef1(stack["typ"], stack["name"], stack["annotations"])
}

func (c *current) onStruct1(st interface{}) (interface{}, error) {
	return st.(*Struct), nil
}

func (p *parser) callonStruct1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStruct1(stack["st"])
}

func (c *current) onException1(st interface{}) (interface{}, error) {
	return exception(st.(*Struct)), nil
}

func (p *parser) callonException1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onException1(stack["st"])
}

func (c *current) onUnion1(st interface{}) (interface{}, error) {
	return union(st.(*Struct)), nil
}

func (p *parser) callonUnion1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onUnion1(stack["st"])
}

func (c *current) onStructLike1(name, fields, annotations interface{}) (interface{}, error) {
	st := &Struct{
		Name:        string(name.(Identifier)),
		Annotations: toAnnotations(annotations),
	}
	if fields != nil {
		st.Fields = fields.([]*Field)
	}
	return st, nil
}

func (p *parser) callonStructLike1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onStructLike1(stack["name"], stack["fields"], stack["annotations"])
}

func (c *current) onFieldList1(fields interface{}) (interface{}, error) {
	fs := fields.([]interface{})
	flds := make([]*Field, len(fs))
	for i, f := range fs {
		flds[i] = f.([]interface{})[0].(*Field)
	}
	return flds, nil
}

func (p *parser) callonFieldList1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldList1(stack["fields"])
}

func (c *current) onField1(id, req, typ, name, def, annotations interface{}) (interface{}, error) {
	f := &Field{
		ID:          int(id.(int64)),
		Name:        string(name.(Identifier)),
		Type:        typ.(*Type),
		Annotations: toAnnotations(annotations),
	}
	if req != nil && !req.(bool) {
		f.Optional = true
	}
	if def != nil {
		f.Default = def.([]interface{})[2]
	}
	return f, nil
}

func (p *parser) callonField1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onField1(stack["id"], stack["req"], stack["typ"], stack["name"], stack["def"], stack["annotations"])
}

func (c *current) onFieldReq1() (interface{}, error) {
	return !bytes.Equal(c.text, []byte("optional")), nil
}

func (p *parser) callonFieldReq1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldReq1()
}

func (c *current) onService1(name, extends, methods, annotations interface{}) (interface{}, error) {
	ms := methods.([]interface{})
	svc := &Service{
		Name:        string(name.(Identifier)),
		Methods:     make(map[string]*Method, len(ms)),
		Annotations: toAnnotations(annotations),
	}
	if extends != nil {
		svc.Extends = string(extends.([]interface{})[2].(Identifier))
	}
	for _, m := range ms {
		mt := m.([]interface{})[0].(*Method)
		svc.Methods[mt.Name] = mt
	}
	return svc, nil
}

func (p *parser) callonService1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onService1(stack["name"], stack["extends"], stack["methods"], stack["annotations"])
}

func (c *current) onEndOfServiceError1() (interface{}, error) {
	return nil, errors.New("parser: expected end of service")
}

func (p *parser) callonEndOfServiceError1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onEndOfServiceError1()
}

func (c *current) onFunction1(oneway, typ, name, arguments, exceptions, annotations interface{}) (interface{}, error) {
	m := &Method{
		Name:        string(name.(Identifier)),
		Annotations: toAnnotations(annotations),
	}
	t := typ.(*Type)
	if t.Name != "void" {
		m.ReturnType = t
	}
	if oneway != nil {
		m.Oneway = true
	}
	if arguments != nil {
		m.Arguments = arguments.([]*Field)
	}
	if exceptions != nil {
		m.Exceptions = exceptions.([]*Field)
		for _, e := range m.Exceptions {
			e.Optional = true
		}
	}
	return m, nil
}

func (p *parser) callonFunction1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFunction1(stack["oneway"], stack["typ"], stack["name"], stack["arguments"], stack["exceptions"], stack["annotations"])
}

func (c *current) onFunctionType1(typ interface{}) (interface{}, error) {
	if t, ok := typ.(*Type); ok {
		return t, nil
	}
	return &Type{Name: string(c.text)}, nil
}

func (p *parser) callonFunctionType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFunctionType1(stack["typ"])
}

func (c *current) onThrows1(exceptions interface{}) (interface{}, error) {
	return exceptions, nil
}

func (p *parser) callonThrows1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onThrows1(stack["exceptions"])
}

func (c *current) onFieldType1(typ interface{}) (interface{}, error) {
	if t, ok := typ.(Identifier); ok {
		return &Type{Name: string(t)}, nil
	}
	return typ, nil
}

func (p *parser) callonFieldType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onFieldType1(stack["typ"])
}

func (c *current) onDefinitionType1(typ interface{}) (interface{}, error) {
	return typ, nil
}

func (p *parser) callonDefinitionType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDefinitionType1(stack["typ"])
}

func (c *current) onBaseType1(name, annotations interface{}) (interface{}, error) {
	return &Type{
		Name:        name.(string),
		Annotations: toAnnotations(annotations),
	}, nil
}

func (p *parser) callonBaseType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBaseType1(stack["name"], stack["annotations"])
}

func (c *current) onBaseTypeName1() (interface{}, error) {
	return string(c.text), nil
}

func (p *parser) callonBaseTypeName1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onBaseTypeName1()
}

func (c *current) onContainerType1(typ interface{}) (interface{}, error) {
	return typ, nil
}

func (p *parser) callonContainerType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onContainerType1(stack["typ"])
}

func (c *current) onMapType1(key, value, annotations interface{}) (interface{}, error) {
	return &Type{
		Name:        "map",
		KeyType:     key.(*Type),
		ValueType:   value.(*Type),
		Annotations: toAnnotations(annotations),
	}, nil
}

func (p *parser) callonMapType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onMapType1(stack["key"], stack["value"], stack["annotations"])
}

func (c *current) onSetType1(typ, annotations interface{}) (interface{}, error) {
	return &Type{
		Name:        "set",
		ValueType:   typ.(*Type),
		Annotations: toAnnotations(annotations),
	}, nil
}

func (p *parser) callonSetType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onSetType1(stack["typ"], stack["annotations"])
}

func (c *current) onListType1(typ, annotations interface{}) (interface{}, error) {
	return &Type{
		Name:        "list",
		ValueType:   typ.(*Type),
		Annotations: toAnnotations(annotations),
	}, nil
}

func (p *parser) callonListType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onListType1(stack["typ"], stack["annotations"])
}

func (c *current) onCppType1(cppType interface{}) (interface{}, error) {
	return cppType, nil
}

func (p *parser) callonCppType1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onCppType1(stack["cppType"])
}

func (c *current) onTypeAnnotations1(annotations interface{}) (interface{}, error) {
	var anns []*Annotation
	for _, ann := range annotations.([]interface{}) {
		anns = append(anns, ann.(*Annotation))
	}
	return anns, nil
}

func (p *parser) callonTypeAnnotations1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTypeAnnotations1(stack["annotations"])
}

func (c *current) onTypeAnnotation8(value interface{}) (interface{}, error) {
	return value, nil
}

func (p *parser) callonTypeAnnotation8() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTypeAnnotation8(stack["value"])
}

func (c *current) onTypeAnnotation1(name, value interface{}) (interface{}, error) {
	var optValue string
	if value != nil {
		optValue = value.(string)
	}
	return &Annotation{
		Name:  string(name.(Identifier)),
		Value: optValue,
	}, nil
}

func (p *parser) callonTypeAnnotation1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onTypeAnnotation1(stack["name"], stack["value"])
}

func (c *current) onIntConstant1() (interface{}, error) {
	return strconv.ParseInt(string(c.text), 10, 64)
}

func (p *parser) callonIntConstant1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onIntConstant1()
}

func (c *current) onDoubleConstant1() (interface{}, error) {
	return strconv.ParseFloat(string(c.text), 64)
}

func (p *parser) callonDoubleConstant1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onDoubleConstant1()
}

func (c *current) onConstList1(values interface{}) (interface{}, error) {
	valueSlice := values.([]interface{})
	vs := make([]interface{}, len(valueSlice))
	for i, v := range valueSlice {
		vs[i] = v.([]interface{})[0]
	}
	return vs, nil
}

func (p *parser) callonConstList1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConstList1(stack["values"])
}

func (c *current) onConstMap1(values interface{}) (interface{}, error) {
	if values == nil {
		return nil, nil
	}
	vals := values.([]interface{})
	kvs := make([]KeyValue, len(vals))
	for i, kv := range vals {
		v := kv.([]interface{})
		kvs[i] = KeyValue{
			Key:   v[0],
			Value: v[4],
		}
	}
	return kvs, nil
}

func (p *parser) callonConstMap1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onConstMap1(stack["values"])
}

func (c *current) onLiteral1() (interface{}, error) {
	if len(c.text) != 0 && c.text[0] == '\'' {
		return strconv.Unquote(`"` + strings.Replace(string(c.text[1:len(c.text)-1]), `\'`, `'`, -1) + `"`)
	}
	return strconv.Unquote(string(c.text))
}

func (p *parser) callonLiteral1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onLiteral1()
}

func (c *current) onIdentifier1() (interface{}, error) {
	return Identifier(string(c.text)), nil
}

func (p *parser) callonIdentifier1() (interface{}, error) {
	stack := p.vstack[len(p.vstack)-1]
	_ = stack
	return p.cur.onIdentifier1()
}

var (
	// errNoRule is returned when the grammar to parse has no rule.
	errNoRule = errors.New("grammar has no rule")

	// errInvalidEncoding is returned when the source is not properly
	// utf8-encoded.
	errInvalidEncoding = errors.New("invalid encoding")

	// errNoMatch is returned if no match could be found.
	errNoMatch = errors.New("no match found")
)

// Option is a function that can set an option on the parser. It returns
// the previous setting as an Option.
type Option func(*parser) Option

// Debug creates an Option to set the debug flag to b. When set to true,
// debugging information is printed to stdout while parsing.
//
// The default is false.
func Debug(b bool) Option {
	return func(p *parser) Option {
		old := p.debug
		p.debug = b
		return Debug(old)
	}
}

// Memoize creates an Option to set the memoize flag to b. When set to true,
// the parser will cache all results so each expression is evaluated only
// once. This guarantees linear parsing time even for pathological cases,
// at the expense of more memory and slower times for typical cases.
//
// The default is false.
func Memoize(b bool) Option {
	return func(p *parser) Option {
		old := p.memoize
		p.memoize = b
		return Memoize(old)
	}
}

// Recover creates an Option to set the recover flag to b. When set to
// true, this causes the parser to recover from panics and convert it
// to an error. Setting it to false can be useful while debugging to
// access the full stack trace.
//
// The default is true.
func Recover(b bool) Option {
	return func(p *parser) Option {
		old := p.recover
		p.recover = b
		return Recover(old)
	}
}

// ParseFile parses the file identified by filename.
func ParseFile(filename string, opts ...Option) (interface{}, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	return ParseReader(filename, f, opts...)
}

// ParseReader parses the data from r using filename as information in the
// error messages.
func ParseReader(filename string, r io.Reader, opts ...Option) (interface{}, error) {
	b, err := ioutil.ReadAll(r)
	if err != nil {
		return nil, err
	}

	return Parse(filename, b, opts...)
}

// Parse parses the data from b using filename as information in the
// error messages.
func Parse(filename string, b []byte, opts ...Option) (interface{}, error) {
	return newParser(filename, b, opts...).parse(g)
}

// position records a position in the text.
type position struct {
	line, col, offset int
}

func (p position) String() string {
	return fmt.Sprintf("%d:%d [%d]", p.line, p.col, p.offset)
}

// savepoint stores all state required to go back to this point in the
// parser.
type savepoint struct {
	position
	rn rune
	w  int
}

type current struct {
	pos  position // start position of the match
	text []byte   // raw text of the match
}

// the AST types...

type grammar struct {
	pos   position
	rules []*rule
}

type rule struct {
	pos         position
	name        string
	displayName string
	expr        interface{}
}

type choiceExpr struct {
	pos          position
	alternatives []interface{}
}

type actionExpr struct {
	pos  position
	expr interface{}
	run  func(*parser) (interface{}, error)
}

type seqExpr struct {
	pos   position
	exprs []interface{}
}

type labeledExpr struct {
	pos   position
	label string
	expr  interface{}
}

type expr struct {
	pos  position
	expr interface{}
}

type andExpr expr
type notExpr expr
type zeroOrOneExpr expr
type zeroOrMoreExpr expr
type oneOrMoreExpr expr

type ruleRefExpr struct {
	pos  position
	name string
}

type andCodeExpr struct {
	pos position
	run func(*parser) (bool, error)
}

type notCodeExpr struct {
	pos position
	run func(*parser) (bool, error)
}

type litMatcher struct {
	pos        position
	val        string
	ignoreCase bool
}

type charClassMatcher struct {
	pos        position
	val        string
	chars      []rune
	ranges     []rune
	classes    []*unicode.RangeTable
	ignoreCase bool
	inverted   bool
}

type anyMatcher position

// errList cumulates the errors found by the parser.
type errList []error

func (e *errList) add(err error) {
	*e = append(*e, err)
}

func (e errList) err() error {
	if len(e) == 0 {
		return nil
	}
	e.dedupe()
	return e
}

func (e *errList) dedupe() {
	var cleaned []error
	set := make(map[string]bool)
	for _, err := range *e {
		if msg := err.Error(); !set[msg] {
			set[msg] = true
			cleaned = append(cleaned, err)
		}
	}
	*e = cleaned
}

func (e errList) Error() string {
	switch len(e) {
	case 0:
		return ""
	case 1:
		return e[0].Error()
	default:
		var buf bytes.Buffer

		for i, err := range e {
			if i > 0 {
				buf.WriteRune('\n')
			}
			buf.WriteString(err.Error())
		}
		return buf.String()
	}
}

// parserError wraps an error with a prefix indicating the rule in which
// the error occurred. The original error is stored in the Inner field.
type parserError struct {
	Inner  error
	pos    position
	prefix string
}

// Error returns the error message.
func (p *parserError) Error() string {
	return p.prefix + ": " + p.Inner.Error()
}

// newParser creates a parser with the specified input source and options.
func newParser(filename string, b []byte, opts ...Option) *parser {
	p := &parser{
		filename: filename,
		errs:     new(errList),
		data:     b,
		pt:       savepoint{position: position{line: 1}},
		recover:  true,
	}
	p.setOptions(opts)
	return p
}

// setOptions applies the options to the parser.
func (p *parser) setOptions(opts []Option) {
	for _, opt := range opts {
		opt(p)
	}
}

type resultTuple struct {
	v   interface{}
	b   bool
	end savepoint
}

type parser struct {
	filename string
	pt       savepoint
	cur      current

	data []byte
	errs *errList

	recover bool
	debug   bool
	depth   int

	memoize bool
	// memoization table for the packrat algorithm:
	// map[offset in source] map[expression or rule] {value, match}
	memo map[int]map[interface{}]resultTuple

	// rules table, maps the rule identifier to the rule node
	rules map[string]*rule
	// variables stack, map of label to value
	vstack []map[string]interface{}
	// rule stack, allows identification of the current rule in errors
	rstack []*rule

	// stats
	exprCnt int
}

// push a variable set on the vstack.
func (p *parser) pushV() {
	if cap(p.vstack) == len(p.vstack) {
		// create new empty slot in the stack
		p.vstack = append(p.vstack, nil)
	} else {
		// slice to 1 more
		p.vstack = p.vstack[:len(p.vstack)+1]
	}

	// get the last args set
	m := p.vstack[len(p.vstack)-1]
	if m != nil && len(m) == 0 {
		// empty map, all good
		return
	}

	m = make(map[string]interface{})
	p.vstack[len(p.vstack)-1] = m
}

// pop a variable set from the vstack.
func (p *parser) popV() {
	// if the map is not empty, clear it
	m := p.vstack[len(p.vstack)-1]
	if len(m) > 0 {
		// GC that map
		p.vstack[len(p.vstack)-1] = nil
	}
	p.vstack = p.vstack[:len(p.vstack)-1]
}

func (p *parser) print(prefix, s string) string {
	if !p.debug {
		return s
	}

	fmt.Printf("%s %d:%d:%d: %s [%#U]\n",
		prefix, p.pt.line, p.pt.col, p.pt.offset, s, p.pt.rn)
	return s
}

func (p *parser) in(s string) string {
	p.depth++
	return p.print(strings.Repeat(" ", p.depth)+">", s)
}

func (p *parser) out(s string) string {
	p.depth--
	return p.print(strings.Repeat(" ", p.depth)+"<", s)
}

func (p *parser) addErr(err error) {
	p.addErrAt(err, p.pt.position)
}

func (p *parser) addErrAt(err error, pos position) {
	var buf bytes.Buffer
	if p.filename != "" {
		buf.WriteString(p.filename)
	}
	if buf.Len() > 0 {
		buf.WriteString(":")
	}
	buf.WriteString(fmt.Sprintf("%d:%d (%d)", pos.line, pos.col, pos.offset))
	if len(p.rstack) > 0 {
		if buf.Len() > 0 {
			buf.WriteString(": ")
		}
		rule := p.rstack[len(p.rstack)-1]
		if rule.displayName != "" {
			buf.WriteString("rule " + rule.displayName)
		} else {
			buf.WriteString("rule " + rule.name)
		}
	}
	pe := &parserError{Inner: err, prefix: buf.String()}
	p.errs.add(pe)
}

// read advances the parser to the next rune.
func (p *parser) read() {
	p.pt.offset += p.pt.w
	rn, n := utf8.DecodeRune(p.data[p.pt.offset:])
	p.pt.rn = rn
	p.pt.w = n
	p.pt.col++
	if rn == '\n' {
		p.pt.line++
		p.pt.col = 0
	}

	if rn == utf8.RuneError {
		if n > 0 {
			p.addErr(errInvalidEncoding)
		}
	}
}

// restore parser position to the savepoint pt.
func (p *parser) restore(pt savepoint) {
	if p.debug {
		defer p.out(p.in("restore"))
	}
	if pt.offset == p.pt.offset {
		return
	}
	p.pt = pt
}

// get the slice of bytes from the savepoint start to the current position.
func (p *parser) sliceFrom(start savepoint) []byte {
	return p.data[start.position.offset:p.pt.position.offset]
}

func (p *parser) getMemoized(node interface{}) (resultTuple, bool) {
	if len(p.memo) == 0 {
		return resultTuple{}, false
	}
	m := p.memo[p.pt.offset]
	if len(m) == 0 {
		return resultTuple{}, false
	}
	res, ok := m[node]
	return res, ok
}

func (p *parser) setMemoized(pt savepoint, node interface{}, tuple resultTuple) {
	if p.memo == nil {
		p.memo = make(map[int]map[interface{}]resultTuple)
	}
	m := p.memo[pt.offset]
	if m == nil {
		m = make(map[interface{}]resultTuple)
		p.memo[pt.offset] = m
	}
	m[node] = tuple
}

func (p *parser) buildRulesTable(g *grammar) {
	p.rules = make(map[string]*rule, len(g.rules))
	for _, r := range g.rules {
		p.rules[r.name] = r
	}
}

func (p *parser) parse(g *grammar) (val interface{}, err error) {
	if len(g.rules) == 0 {
		p.addErr(errNoRule)
		return nil, p.errs.err()
	}

	// TODO : not super critical but this could be generated
	p.buildRulesTable(g)

	if p.recover {
		// panic can be used in action code to stop parsing immediately
		// and return the panic as an error.
		defer func() {
			if e := recover(); e != nil {
				if p.debug {
					defer p.out(p.in("panic handler"))
				}
				val = nil
				switch e := e.(type) {
				case error:
					p.addErr(e)
				default:
					p.addErr(fmt.Errorf("%v", e))
				}
				err = p.errs.err()
			}
		}()
	}

	// start rule is rule [0]
	p.read() // advance to first rune
	val, ok := p.parseRule(g.rules[0])
	if !ok {
		if len(*p.errs) == 0 {
			// make sure this doesn't go out silently
			p.addErr(errNoMatch)
		}
		return nil, p.errs.err()
	}
	return val, p.errs.err()
}

func (p *parser) parseRule(rule *rule) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseRule " + rule.name))
	}

	if p.memoize {
		res, ok := p.getMemoized(rule)
		if ok {
			p.restore(res.end)
			return res.v, res.b
		}
	}

	start := p.pt
	p.rstack = append(p.rstack, rule)
	p.pushV()
	val, ok := p.parseExpr(rule.expr)
	p.popV()
	p.rstack = p.rstack[:len(p.rstack)-1]
	if ok && p.debug {
		p.print(strings.Repeat(" ", p.depth)+"MATCH", string(p.sliceFrom(start)))
	}

	if p.memoize {
		p.setMemoized(start, rule, resultTuple{val, ok, p.pt})
	}
	return val, ok
}

func (p *parser) parseExpr(expr interface{}) (interface{}, bool) {
	var pt savepoint
	var ok bool

	if p.memoize {
		res, ok := p.getMemoized(expr)
		if ok {
			p.restore(res.end)
			return res.v, res.b
		}
		pt = p.pt
	}

	p.exprCnt++
	var val interface{}
	switch expr := expr.(type) {
	case *actionExpr:
		val, ok = p.parseActionExpr(expr)
	case *andCodeExpr:
		val, ok = p.parseAndCodeExpr(expr)
	case *andExpr:
		val, ok = p.parseAndExpr(expr)
	case *anyMatcher:
		val, ok = p.parseAnyMatcher(expr)
	case *charClassMatcher:
		val, ok = p.parseCharClassMatcher(expr)
	case *choiceExpr:
		val, ok = p.parseChoiceExpr(expr)
	case *labeledExpr:
		val, ok = p.parseLabeledExpr(expr)
	case *litMatcher:
		val, ok = p.parseLitMatcher(expr)
	case *notCodeExpr:
		val, ok = p.parseNotCodeExpr(expr)
	case *notExpr:
		val, ok = p.parseNotExpr(expr)
	case *oneOrMoreExpr:
		val, ok = p.parseOneOrMoreExpr(expr)
	case *ruleRefExpr:
		val, ok = p.parseRuleRefExpr(expr)
	case *seqExpr:
		val, ok = p.parseSeqExpr(expr)
	case *zeroOrMoreExpr:
		val, ok = p.parseZeroOrMoreExpr(expr)
	case *zeroOrOneExpr:
		val, ok = p.parseZeroOrOneExpr(expr)
	default:
		panic(fmt.Sprintf("unknown expression type %T", expr))
	}
	if p.memoize {
		p.setMemoized(pt, expr, resultTuple{val, ok, p.pt})
	}
	return val, ok
}

func (p *parser) parseActionExpr(act *actionExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseActionExpr"))
	}

	start := p.pt
	val, ok := p.parseExpr(act.expr)
	if ok {
		p.cur.pos = start.position
		p.cur.text = p.sliceFrom(start)
		actVal, err := act.run(p)
		if err != nil {
			p.addErrAt(err, start.position)
		}
		val = actVal
	}
	if ok && p.debug {
		p.print(strings.Repeat(" ", p.depth)+"MATCH", string(p.sliceFrom(start)))
	}
	return val, ok
}

func (p *parser) parseAndCodeExpr(and *andCodeExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseAndCodeExpr"))
	}

	ok, err := and.run(p)
	if err != nil {
		p.addErr(err)
	}
	return nil, ok
}

func (p *parser) parseAndExpr(and *andExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseAndExpr"))
	}

	pt := p.pt
	p.pushV()
	_, ok := p.parseExpr(and.expr)
	p.popV()
	p.restore(pt)
	return nil, ok
}

func (p *parser) parseAnyMatcher(any *anyMatcher) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseAnyMatcher"))
	}

	if p.pt.rn != utf8.RuneError {
		start := p.pt
		p.read()
		return p.sliceFrom(start), true
	}
	return nil, false
}

func (p *parser) parseCharClassMatcher(chr *charClassMatcher) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseCharClassMatcher"))
	}

	cur := p.pt.rn
	// can't match EOF
	if cur == utf8.RuneError {
		return nil, false
	}
	start := p.pt
	if chr.ignoreCase {
		cur = unicode.ToLower(cur)
	}

	// try to match in the list of available chars
	for _, rn := range chr.chars {
		if rn == cur {
			if chr.inverted {
				return nil, false
			}
			p.read()
			return p.sliceFrom(start), true
		}
	}

	// try to match in the list of ranges
	for i := 0; i < len(chr.ranges); i += 2 {
		if cur >= chr.ranges[i] && cur <= chr.ranges[i+1] {
			if chr.inverted {
				return nil, false
			}
			p.read()
			return p.sliceFrom(start), true
		}
	}

	// try to match in the list of Unicode classes
	for _, cl := range chr.classes {
		if unicode.Is(cl, cur) {
			if chr.inverted {
				return nil, false
			}
			p.read()
			return p.sliceFrom(start), true
		}
	}

	if chr.inverted {
		p.read()
		return p.sliceFrom(start), true
	}
	return nil, false
}

func (p *parser) parseChoiceExpr(ch *choiceExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseChoiceExpr"))
	}

	for _, alt := range ch.alternatives {
		p.pushV()
		val, ok := p.parseExpr(alt)
		p.popV()
		if ok {
			return val, ok
		}
	}
	return nil, false
}

func (p *parser) parseLabeledExpr(lab *labeledExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseLabeledExpr"))
	}

	p.pushV()
	val, ok := p.parseExpr(lab.expr)
	p.popV()
	if ok && lab.label != "" {
		m := p.vstack[len(p.vstack)-1]
		m[lab.label] = val
	}
	return val, ok
}

func (p *parser) parseLitMatcher(lit *litMatcher) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseLitMatcher"))
	}

	start := p.pt
	for _, want := range lit.val {
		cur := p.pt.rn
		if lit.ignoreCase {
			cur = unicode.ToLower(cur)
		}
		if cur != want {
			p.restore(start)
			return nil, false
		}
		p.read()
	}
	return p.sliceFrom(start), true
}

func (p *parser) parseNotCodeExpr(not *notCodeExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseNotCodeExpr"))
	}

	ok, err := not.run(p)
	if err != nil {
		p.addErr(err)
	}
	return nil, !ok
}

func (p *parser) parseNotExpr(not *notExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseNotExpr"))
	}

	pt := p.pt
	p.pushV()
	_, ok := p.parseExpr(not.expr)
	p.popV()
	p.restore(pt)
	return nil, !ok
}

func (p *parser) parseOneOrMoreExpr(expr *oneOrMoreExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseOneOrMoreExpr"))
	}

	var vals []interface{}

	for {
		p.pushV()
		val, ok := p.parseExpr(expr.expr)
		p.popV()
		if !ok {
			if len(vals) == 0 {
				// did not match once, no match
				return nil, false
			}
			return vals, true
		}
		vals = append(vals, val)
	}
}

func (p *parser) parseRuleRefExpr(ref *ruleRefExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseRuleRefExpr " + ref.name))
	}

	if ref.name == "" {
		panic(fmt.Sprintf("%s: invalid rule: missing name", ref.pos))
	}

	rule := p.rules[ref.name]
	if rule == nil {
		p.addErr(fmt.Errorf("undefined rule: %s", ref.name))
		return nil, false
	}
	return p.parseRule(rule)
}

func (p *parser) parseSeqExpr(seq *seqExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseSeqExpr"))
	}

	var vals []interface{}

	pt := p.pt
	for _, expr := range seq.exprs {
		val, ok := p.parseExpr(expr)
		if !ok {
			p.restore(pt)
			return nil, false
		}
		vals = append(vals, val)
	}
	return vals, true
}

func (p *parser) parseZeroOrMoreExpr(expr *zeroOrMoreExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseZeroOrMoreExpr"))
	}

	var vals []interface{}

	for {
		p.pushV()
		val, ok := p.parseExpr(expr.expr)
		p.popV()
		if !ok {
			return vals, true
		}
		vals = append(vals, val)
	}
}

func (p *parser) parseZeroOrOneExpr(expr *zeroOrOneExpr) (interface{}, bool) {
	if p.debug {
		defer p.out(p.in("parseZeroOrOneExpr"))
	}

	p.pushV()
	val, _ := p.parseExpr(expr.expr)
	p.popV()
	// whether it matched or not, consider it a match
	return val, true
}

func rangeTable(class string) *unicode.RangeTable {
	if rt, ok := unicode.Categories[class]; ok {
		return rt
	}
	if rt, ok := unicode.Properties[class]; ok {
		return rt
	}
	if rt, ok := unicode.Scripts[class]; ok {
		return rt
	}

	// cannot happen
	panic(fmt.Sprintf("invalid Unicode class: %s", class))
}