diff options
Diffstat (limited to 'parser')
| -rw-r--r-- | parser/errors.go | 107 | ||||
| -rw-r--r-- | parser/grammar.peg | 126 | ||||
| -rw-r--r-- | parser/parser.go | 2767 |
3 files changed, 3000 insertions, 0 deletions
diff --git a/parser/errors.go b/parser/errors.go new file mode 100644 index 0000000..c2ed049 --- /dev/null +++ b/parser/errors.go @@ -0,0 +1,107 @@ +package parser + +import ( + "bytes" + "errors" + "fmt" + "strings" +) + +type ErrorLister interface { + Errors() []error +} + +func (e errList) Errors() []error { + return e +} + +// ParserError is the public interface to errors of type parserError +type ParserError interface { + Error() string + InnerError() error + Pos() (int, int, int) + Expected() []string +} + +func (p *parserError) InnerError() error { + return p.Inner +} + +func (p *parserError) Pos() (line, col, offset int) { + return p.pos.line, p.pos.col, p.pos.offset +} + +func (p *parserError) Expected() []string { + return p.expected +} + +func CaretErrors(err error, input string) error { + if el, ok := err.(ErrorLister); ok { + var buffer bytes.Buffer + for _, e := range el.Errors() { + err1, shouldReturn := caretError(e, input, buffer, err) + if shouldReturn { + return err1 + } + } + return errors.New(buffer.String()) + } + return err +} + +func caretError(e error, input string, buffer bytes.Buffer, err error) (error, bool) { + if parserErr, ok := e.(ParserError); ok { + _, col, off := parserErr.Pos() + line := extractLine(input, off) + if col >= len(line) { + col = len(line) - 1 + } else { + if col > 0 { + col-- + } + } + if col < 0 { + col = 0 + } + pos := col + for _, chr := range line[:col] { + if chr == '\t' { + pos += 7 + } + } + fmt.Fprintf(&buffer, "%s\n%s\n%s\n", line, strings.Repeat(" ", pos)+"^", err.Error()) + + return err, true + } else { + return err, true + } + return nil, false +} + +func extractLine(input string, initPos int) string { + if initPos < 0 { + initPos = 0 + } + if initPos >= len(input) && len(input) > 0 { + initPos = len(input) - 1 + } + startPos := initPos + endPos := initPos + for ; startPos > 0; startPos-- { + if input[startPos] == '\n' { + if startPos != initPos { + startPos++ + break + } + } + } + for ; endPos < len(input); endPos++ { + if input[endPos] == '\n' { + if endPos == initPos { + endPos++ + } + break + } + } + return input[startPos:endPos] +} diff --git a/parser/grammar.peg b/parser/grammar.peg new file mode 100644 index 0000000..38b6dc8 --- /dev/null +++ b/parser/grammar.peg @@ -0,0 +1,126 @@ +{ + // Package parser parses conf language. + package parser + + import ( + "strconv" + "errors" + + "go.neonxp.ru/conf/model" + ) + + func toAnySlice(v any) []any { + if v == nil { + return nil + } + if v := v.([]any); len(v) == 0 { + return nil + } + + return v.([]any) + } +} + +Config ← _ stmts:( Command* ) EOF { + if stmts == nil { + return model.Group{}, nil + } + groupAny := toAnySlice(stmts) + groupSl := make(model.Group, len(groupAny)) + for i, e := range groupAny { + groupSl[i] = e.(model.Command) + } + return groupSl, nil +} + +Group ← '{' _ stmts:( Command* ) _ '}' { + if stmts == nil { + return model.Group{}, nil + } + groupAny := toAnySlice(stmts) + groupSl := make(model.Group, len(groupAny)) + for i, e := range groupAny { + groupSl[i] = e.(model.Command) + } + return groupSl, nil +} + +Command ← name:Ident _ args:Args _ { + var group model.Group + rawArgs := args.([]any) + argsSlice := make([]any, 0, len(rawArgs)) + if len(rawArgs) > 0 { + for _, s := range rawArgs { + if s == nil { + continue + } + if g, ok := s.(model.Group); ok { + group = g + continue + } + if l, ok := s.([]any); ok { + l = slices.DeleteFunc(l, func(x any) bool { return x == nil }) + argsSlice = append(argsSlice, l...) + } + } + } + return model.Command{Name: name.(model.Ident), Args: argsSlice, Group: group}, nil +} + +Args ← Values? (Group / EOS) + +Values ← vals:Value* { return toAnySlice(vals), nil } + +Value ← val:( Ident / String / Number / Boolean ) __ { return val, nil } +String ← ( '"' DoubleStringChar* '"' / "'" SingleStringChar "'" / '`' RawStringChar* '`' ) { + return string(c.text), nil +} + +// Сервисные литералы + +// {{{ Строки +DoubleStringChar ← !( '"' / "\\" / EOL ) SourceChar / "\\" DoubleStringEscape +SingleStringChar ← !( "'" / "\\" / EOL ) SourceChar / "\\" SingleStringEscape +RawStringChar ← !'`' SourceChar + +DoubleStringEscape ← '"' / CommonEscapeSequence +SingleStringEscape ← "'" / CommonEscapeSequence + +CommonEscapeSequence ← SingleCharEscape / OctalEscape / HexEscape / LongUnicodeEscape / ShortUnicodeEscape +SingleCharEscape ← 'a' / 'b' / 'n' / 'f' / 'r' / 't' / 'v' / '\\' +OctalEscape ← OctalDigit OctalDigit OctalDigit +HexEscape ← 'x' HexDigit HexDigit +LongUnicodeEscape ← 'U' HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit +ShortUnicodeEscape ← 'u' HexDigit HexDigit HexDigit HexDigit + +OctalDigit ← [0-7] +DecimalDigit ← [0-9] +HexDigit ← [0-9a-f]i +SourceChar ← . +// }}} + +// {{{ Числа +Number ← '-'? Integer ( '.' DecimalDigit+ )? Exponent? { return strconv.ParseFloat(string(c.text), 64) } +Integer ← '0' / NonZeroDecimalDigit DecimalDigit* +Exponent ← 'e'i [+-]? DecimalDigit+ +DecimalDigit ← [0-9] +NonZeroDecimalDigit ← [1-9] +// }}} + +// {{{ Идентификатор +Ident ← (Alpha / AllowedSpec) (Alpha / AllowedSpec / Number)* { return model.Ident(c.text), nil } +Alpha ← [a-zA-Z] +AllowedSpec ← '$' / '@' / '%' / '_' / '-' / '+' +// }}} + +Boolean ← "true" { return true, nil } / "false" { return false, nil } + +Comment ← '#' ( ![\r\n] . )* +__ ← ( Whitespace / EOL / Comment )* +_ ← ( [ \t\r\n] / Comment )* + +Whitespace ← [ \t\r] +EOL ← '\n' +EOS ← __ ';' { return nil, nil } / _ Comment? EOL { return nil, nil } / __ EOF { return nil, nil } + +EOF ← !.
\ No newline at end of file diff --git a/parser/parser.go b/parser/parser.go new file mode 100644 index 0000000..e6abdaf --- /dev/null +++ b/parser/parser.go @@ -0,0 +1,2767 @@ +// Code generated by pigeon; DO NOT EDIT. + +// Package parser parses conf language. +package parser + +import ( + "bytes" + "errors" + "fmt" + "io" + "math" + "os" + "slices" + "sort" + "strconv" + "strings" + "unicode" + "unicode/utf8" + + "go.neonxp.ru/conf/model" +) + +func toAnySlice(v any) []any { + if v == nil { + return nil + } + if v := v.([]any); len(v) == 0 { + return nil + } + + return v.([]any) +} + +var g = &grammar{ + rules: []*rule{ + { + name: "Config", + pos: position{line: 24, col: 1, offset: 355}, + expr: &actionExpr{ + pos: position{line: 24, col: 10, offset: 366}, + run: (*parser).callonConfig1, + expr: &seqExpr{ + pos: position{line: 24, col: 10, offset: 366}, + exprs: []any{ + &zeroOrMoreExpr{ + pos: position{line: 120, col: 5, offset: 3403}, + expr: &choiceExpr{ + pos: position{line: 120, col: 7, offset: 3405}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 120, col: 7, offset: 3405}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &labeledExpr{ + pos: position{line: 24, col: 12, offset: 368}, + label: "stmts", + expr: &zeroOrMoreExpr{ + pos: position{line: 24, col: 20, offset: 376}, + expr: &ruleRefExpr{ + pos: position{line: 24, col: 20, offset: 376}, + name: "Command", + }, + }, + }, + ¬Expr{ + pos: position{line: 126, col: 7, offset: 3575}, + expr: &anyMatcher{ + line: 126, col: 8, offset: 3576, + }, + }, + }, + }, + }, + }, + { + name: "Group", + pos: position{line: 36, col: 1, offset: 642}, + expr: &actionExpr{ + pos: position{line: 36, col: 9, offset: 652}, + run: (*parser).callonGroup1, + expr: &seqExpr{ + pos: position{line: 36, col: 9, offset: 652}, + exprs: []any{ + &litMatcher{ + pos: position{line: 36, col: 9, offset: 652}, + val: "{", + ignoreCase: false, + want: "\"{\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 120, col: 5, offset: 3403}, + expr: &choiceExpr{ + pos: position{line: 120, col: 7, offset: 3405}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 120, col: 7, offset: 3405}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &labeledExpr{ + pos: position{line: 36, col: 15, offset: 658}, + label: "stmts", + expr: &zeroOrMoreExpr{ + pos: position{line: 36, col: 23, offset: 666}, + expr: &ruleRefExpr{ + pos: position{line: 36, col: 23, offset: 666}, + name: "Command", + }, + }, + }, + &zeroOrMoreExpr{ + pos: position{line: 120, col: 5, offset: 3403}, + expr: &choiceExpr{ + pos: position{line: 120, col: 7, offset: 3405}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 120, col: 7, offset: 3405}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &litMatcher{ + pos: position{line: 36, col: 36, offset: 679}, + val: "}", + ignoreCase: false, + want: "\"}\"", + }, + }, + }, + }, + }, + { + name: "Command", + pos: position{line: 48, col: 1, offset: 934}, + expr: &actionExpr{ + pos: position{line: 48, col: 11, offset: 946}, + run: (*parser).callonCommand1, + expr: &seqExpr{ + pos: position{line: 48, col: 11, offset: 946}, + exprs: []any{ + &labeledExpr{ + pos: position{line: 48, col: 11, offset: 946}, + label: "name", + expr: &actionExpr{ + pos: position{line: 111, col: 9, offset: 3087}, + run: (*parser).callonCommand4, + expr: &seqExpr{ + pos: position{line: 111, col: 9, offset: 3087}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 112, col: 9, offset: 3187}, + val: "[$@%_-+a-zA-Z]", + chars: []rune{'$', '@', '%', '_', '-', '+'}, + ranges: []rune{'a', 'z', 'A', 'Z'}, + ignoreCase: false, + inverted: false, + }, + &zeroOrMoreExpr{ + pos: position{line: 111, col: 31, offset: 3109}, + expr: &choiceExpr{ + pos: position{line: 111, col: 32, offset: 3110}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 112, col: 9, offset: 3187}, + val: "[$@%_-+a-zA-Z]", + chars: []rune{'$', '@', '%', '_', '-', '+'}, + ranges: []rune{'a', 'z', 'A', 'Z'}, + ignoreCase: false, + inverted: false, + }, + &actionExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + run: (*parser).callonCommand10, + expr: &seqExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + exprs: []any{ + &zeroOrOneExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + expr: &litMatcher{ + pos: position{line: 103, col: 10, offset: 2796}, + val: "-", + ignoreCase: false, + want: "\"-\"", + }, + }, + &choiceExpr{ + pos: position{line: 104, col: 11, offset: 2904}, + alternatives: []any{ + &litMatcher{ + pos: position{line: 104, col: 11, offset: 2904}, + val: "0", + ignoreCase: false, + want: "\"0\"", + }, + &seqExpr{ + pos: position{line: 104, col: 17, offset: 2910}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 107, col: 23, offset: 3029}, + val: "[1-9]", + ranges: []rune{'1', '9'}, + ignoreCase: false, + inverted: false, + }, + &zeroOrMoreExpr{ + pos: position{line: 104, col: 37, offset: 2930}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 103, col: 23, offset: 2809}, + expr: &seqExpr{ + pos: position{line: 103, col: 25, offset: 2811}, + exprs: []any{ + &litMatcher{ + pos: position{line: 103, col: 25, offset: 2811}, + val: ".", + ignoreCase: false, + want: "\".\"", + }, + &oneOrMoreExpr{ + pos: position{line: 103, col: 29, offset: 2815}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 103, col: 46, offset: 2832}, + expr: &seqExpr{ + pos: position{line: 105, col: 12, offset: 2957}, + exprs: []any{ + &litMatcher{ + pos: position{line: 105, col: 12, offset: 2957}, + val: "e", + ignoreCase: true, + want: "\"e\"i", + }, + &zeroOrOneExpr{ + pos: position{line: 105, col: 17, offset: 2962}, + expr: &charClassMatcher{ + pos: position{line: 105, col: 17, offset: 2962}, + val: "[+-]", + chars: []rune{'+', '-'}, + ignoreCase: false, + inverted: false, + }, + }, + &oneOrMoreExpr{ + pos: position{line: 105, col: 23, offset: 2968}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &zeroOrMoreExpr{ + pos: position{line: 120, col: 5, offset: 3403}, + expr: &choiceExpr{ + pos: position{line: 120, col: 7, offset: 3405}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 120, col: 7, offset: 3405}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &labeledExpr{ + pos: position{line: 48, col: 24, offset: 959}, + label: "args", + expr: &ruleRefExpr{ + pos: position{line: 48, col: 29, offset: 964}, + name: "Args", + }, + }, + &zeroOrMoreExpr{ + pos: position{line: 120, col: 5, offset: 3403}, + expr: &choiceExpr{ + pos: position{line: 120, col: 7, offset: 3405}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 120, col: 7, offset: 3405}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + name: "Args", + pos: position{line: 70, col: 1, offset: 1602}, + expr: &seqExpr{ + pos: position{line: 70, col: 8, offset: 1611}, + exprs: []any{ + &zeroOrOneExpr{ + pos: position{line: 70, col: 8, offset: 1611}, + expr: &actionExpr{ + pos: position{line: 72, col: 10, offset: 1645}, + run: (*parser).callonArgs3, + expr: &labeledExpr{ + pos: position{line: 72, col: 10, offset: 1645}, + label: "vals", + expr: &zeroOrMoreExpr{ + pos: position{line: 72, col: 15, offset: 1650}, + expr: &actionExpr{ + pos: position{line: 74, col: 9, offset: 1701}, + run: (*parser).callonArgs6, + expr: &seqExpr{ + pos: position{line: 74, col: 9, offset: 1701}, + exprs: []any{ + &labeledExpr{ + pos: position{line: 74, col: 9, offset: 1701}, + label: "val", + expr: &choiceExpr{ + pos: position{line: 74, col: 15, offset: 1707}, + alternatives: []any{ + &actionExpr{ + pos: position{line: 111, col: 9, offset: 3087}, + run: (*parser).callonArgs10, + expr: &seqExpr{ + pos: position{line: 111, col: 9, offset: 3087}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 112, col: 9, offset: 3187}, + val: "[$@%_-+a-zA-Z]", + chars: []rune{'$', '@', '%', '_', '-', '+'}, + ranges: []rune{'a', 'z', 'A', 'Z'}, + ignoreCase: false, + inverted: false, + }, + &zeroOrMoreExpr{ + pos: position{line: 111, col: 31, offset: 3109}, + expr: &choiceExpr{ + pos: position{line: 111, col: 32, offset: 3110}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 112, col: 9, offset: 3187}, + val: "[$@%_-+a-zA-Z]", + chars: []rune{'$', '@', '%', '_', '-', '+'}, + ranges: []rune{'a', 'z', 'A', 'Z'}, + ignoreCase: false, + inverted: false, + }, + &actionExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + run: (*parser).callonArgs16, + expr: &seqExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + exprs: []any{ + &zeroOrOneExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + expr: &litMatcher{ + pos: position{line: 103, col: 10, offset: 2796}, + val: "-", + ignoreCase: false, + want: "\"-\"", + }, + }, + &choiceExpr{ + pos: position{line: 104, col: 11, offset: 2904}, + alternatives: []any{ + &litMatcher{ + pos: position{line: 104, col: 11, offset: 2904}, + val: "0", + ignoreCase: false, + want: "\"0\"", + }, + &seqExpr{ + pos: position{line: 104, col: 17, offset: 2910}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 107, col: 23, offset: 3029}, + val: "[1-9]", + ranges: []rune{'1', '9'}, + ignoreCase: false, + inverted: false, + }, + &zeroOrMoreExpr{ + pos: position{line: 104, col: 37, offset: 2930}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 103, col: 23, offset: 2809}, + expr: &seqExpr{ + pos: position{line: 103, col: 25, offset: 2811}, + exprs: []any{ + &litMatcher{ + pos: position{line: 103, col: 25, offset: 2811}, + val: ".", + ignoreCase: false, + want: "\".\"", + }, + &oneOrMoreExpr{ + pos: position{line: 103, col: 29, offset: 2815}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 103, col: 46, offset: 2832}, + expr: &seqExpr{ + pos: position{line: 105, col: 12, offset: 2957}, + exprs: []any{ + &litMatcher{ + pos: position{line: 105, col: 12, offset: 2957}, + val: "e", + ignoreCase: true, + want: "\"e\"i", + }, + &zeroOrOneExpr{ + pos: position{line: 105, col: 17, offset: 2962}, + expr: &charClassMatcher{ + pos: position{line: 105, col: 17, offset: 2962}, + val: "[+-]", + chars: []rune{'+', '-'}, + ignoreCase: false, + inverted: false, + }, + }, + &oneOrMoreExpr{ + pos: position{line: 105, col: 23, offset: 2968}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &actionExpr{ + pos: position{line: 75, col: 10, offset: 1777}, + run: (*parser).callonArgs38, + expr: &choiceExpr{ + pos: position{line: 75, col: 12, offset: 1779}, + alternatives: []any{ + &seqExpr{ + pos: position{line: 75, col: 12, offset: 1779}, + exprs: []any{ + &litMatcher{ + pos: position{line: 75, col: 12, offset: 1779}, + val: "\"", + ignoreCase: false, + want: "\"\\\"\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 75, col: 16, offset: 1783}, + expr: &choiceExpr{ + pos: position{line: 82, col: 20, offset: 1976}, + alternatives: []any{ + &seqExpr{ + pos: position{line: 82, col: 20, offset: 1976}, + exprs: []any{ + ¬Expr{ + pos: position{line: 82, col: 20, offset: 1976}, + expr: &charClassMatcher{ + pos: position{line: 82, col: 23, offset: 1979}, + val: "[\"\\\\\\n]", + chars: []rune{'"', '\\', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 99, col: 14, offset: 2757, + }, + }, + }, + &seqExpr{ + pos: position{line: 82, col: 55, offset: 2011}, + exprs: []any{ + &litMatcher{ + pos: position{line: 82, col: 55, offset: 2011}, + val: "\\", + ignoreCase: false, + want: "\"\\\\\"", + }, + &choiceExpr{ + pos: position{line: 86, col: 22, offset: 2173}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 90, col: 20, offset: 2381}, + val: "[abnf\"rtv\\\\]", + chars: []rune{'a', 'b', 'n', 'f', '"', 'r', 't', 'v', '\\'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 91, col: 15, offset: 2444}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 96, col: 14, offset: 2690}, + val: "[0-7]", + ranges: []rune{'0', '7'}, + ignoreCase: false, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 96, col: 14, offset: 2690}, + val: "[0-7]", + ranges: []rune{'0', '7'}, + ignoreCase: false, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 96, col: 14, offset: 2690}, + val: "[0-7]", + ranges: []rune{'0', '7'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + &seqExpr{ + pos: position{line: 92, col: 13, offset: 2491}, + exprs: []any{ + &litMatcher{ + pos: position{line: 92, col: 13, offset: 2491}, + val: "x", + ignoreCase: false, + want: "\"x\"", + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + }, + }, + &seqExpr{ + pos: position{line: 93, col: 21, offset: 2535}, + exprs: []any{ + &litMatcher{ + pos: position{line: 93, col: 21, offset: 2535}, + val: "U", + ignoreCase: false, + want: "\"U\"", + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + }, + }, + &seqExpr{ + pos: position{line: 94, col: 22, offset: 2634}, + exprs: []any{ + &litMatcher{ + pos: position{line: 94, col: 22, offset: 2634}, + val: "u", + ignoreCase: false, + want: "\"u\"", + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &litMatcher{ + pos: position{line: 75, col: 34, offset: 1801}, + val: "\"", + ignoreCase: false, + want: "\"\\\"\"", + }, + }, + }, + &seqExpr{ + pos: position{line: 75, col: 40, offset: 1807}, + exprs: []any{ + &litMatcher{ + pos: position{line: 75, col: 40, offset: 1807}, + val: "'", + ignoreCase: false, + want: "\"'\"", + }, + &choiceExpr{ + pos: position{line: 83, col: 20, offset: 2056}, + alternatives: []any{ + &seqExpr{ + pos: position{line: 83, col: 20, offset: 2056}, + exprs: []any{ + ¬Expr{ + pos: position{line: 83, col: 20, offset: 2056}, + expr: &charClassMatcher{ + pos: position{line: 83, col: 23, offset: 2059}, + val: "[\\\\\\\\n]", + chars: []rune{'\'', '\\', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 99, col: 14, offset: 2757, + }, + }, + }, + &seqExpr{ + pos: position{line: 83, col: 55, offset: 2091}, + exprs: []any{ + &litMatcher{ + pos: position{line: 83, col: 55, offset: 2091}, + val: "\\", + ignoreCase: false, + want: "\"\\\\\"", + }, + &choiceExpr{ + pos: position{line: 87, col: 22, offset: 2223}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 90, col: 20, offset: 2381}, + val: "[abnf\\rtv\\\\]", + chars: []rune{'a', 'b', 'n', 'f', '\'', 'r', 't', 'v', '\\'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 91, col: 15, offset: 2444}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 96, col: 14, offset: 2690}, + val: "[0-7]", + ranges: []rune{'0', '7'}, + ignoreCase: false, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 96, col: 14, offset: 2690}, + val: "[0-7]", + ranges: []rune{'0', '7'}, + ignoreCase: false, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 96, col: 14, offset: 2690}, + val: "[0-7]", + ranges: []rune{'0', '7'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + &seqExpr{ + pos: position{line: 92, col: 13, offset: 2491}, + exprs: []any{ + &litMatcher{ + pos: position{line: 92, col: 13, offset: 2491}, + val: "x", + ignoreCase: false, + want: "\"x\"", + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + }, + }, + &seqExpr{ + pos: position{line: 93, col: 21, offset: 2535}, + exprs: []any{ + &litMatcher{ + pos: position{line: 93, col: 21, offset: 2535}, + val: "U", + ignoreCase: false, + want: "\"U\"", + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + }, + }, + &seqExpr{ + pos: position{line: 94, col: 22, offset: 2634}, + exprs: []any{ + &litMatcher{ + pos: position{line: 94, col: 22, offset: 2634}, + val: "u", + ignoreCase: false, + want: "\"u\"", + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + &charClassMatcher{ + pos: position{line: 98, col: 12, offset: 2732}, + val: "[0-9a-f]i", + ranges: []rune{'0', '9', 'a', 'f'}, + ignoreCase: true, + inverted: false, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &litMatcher{ + pos: position{line: 75, col: 61, offset: 1828}, + val: "'", + ignoreCase: false, + want: "\"'\"", + }, + }, + }, + &seqExpr{ + pos: position{line: 75, col: 67, offset: 1834}, + exprs: []any{ + &litMatcher{ + pos: position{line: 75, col: 67, offset: 1834}, + val: "`", + ignoreCase: false, + want: "\"`\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 75, col: 71, offset: 1838}, + expr: &seqExpr{ + pos: position{line: 84, col: 17, offset: 2133}, + exprs: []any{ + ¬Expr{ + pos: position{line: 84, col: 17, offset: 2133}, + expr: &litMatcher{ + pos: position{line: 84, col: 18, offset: 2134}, + val: "`", + ignoreCase: false, + want: "\"`\"", + }, + }, + &anyMatcher{ + line: 99, col: 14, offset: 2757, + }, + }, + }, + }, + &litMatcher{ + pos: position{line: 75, col: 86, offset: 1853}, + val: "`", + ignoreCase: false, + want: "\"`\"", + }, + }, + }, + }, + }, + }, + &actionExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + run: (*parser).callonArgs121, + expr: &seqExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + exprs: []any{ + &zeroOrOneExpr{ + pos: position{line: 103, col: 10, offset: 2796}, + expr: &litMatcher{ + pos: position{line: 103, col: 10, offset: 2796}, + val: "-", + ignoreCase: false, + want: "\"-\"", + }, + }, + &choiceExpr{ + pos: position{line: 104, col: 11, offset: 2904}, + alternatives: []any{ + &litMatcher{ + pos: position{line: 104, col: 11, offset: 2904}, + val: "0", + ignoreCase: false, + want: "\"0\"", + }, + &seqExpr{ + pos: position{line: 104, col: 17, offset: 2910}, + exprs: []any{ + &charClassMatcher{ + pos: position{line: 107, col: 23, offset: 3029}, + val: "[1-9]", + ranges: []rune{'1', '9'}, + ignoreCase: false, + inverted: false, + }, + &zeroOrMoreExpr{ + pos: position{line: 104, col: 37, offset: 2930}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 103, col: 23, offset: 2809}, + expr: &seqExpr{ + pos: position{line: 103, col: 25, offset: 2811}, + exprs: []any{ + &litMatcher{ + pos: position{line: 103, col: 25, offset: 2811}, + val: ".", + ignoreCase: false, + want: "\".\"", + }, + &oneOrMoreExpr{ + pos: position{line: 103, col: 29, offset: 2815}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 103, col: 46, offset: 2832}, + expr: &seqExpr{ + pos: position{line: 105, col: 12, offset: 2957}, + exprs: []any{ + &litMatcher{ + pos: position{line: 105, col: 12, offset: 2957}, + val: "e", + ignoreCase: true, + want: "\"e\"i", + }, + &zeroOrOneExpr{ + pos: position{line: 105, col: 17, offset: 2962}, + expr: &charClassMatcher{ + pos: position{line: 105, col: 17, offset: 2962}, + val: "[+-]", + chars: []rune{'+', '-'}, + ignoreCase: false, + inverted: false, + }, + }, + &oneOrMoreExpr{ + pos: position{line: 105, col: 23, offset: 2968}, + expr: &charClassMatcher{ + pos: position{line: 106, col: 16, offset: 2999}, + val: "[0-9]", + ranges: []rune{'0', '9'}, + ignoreCase: false, + inverted: false, + }, + }, + }, + }, + }, + }, + }, + }, + &actionExpr{ + pos: position{line: 116, col: 11, offset: 3266}, + run: (*parser).callonArgs143, + expr: &litMatcher{ + pos: position{line: 116, col: 11, offset: 3266}, + val: "true", + ignoreCase: false, + want: "\"true\"", + }, + }, + &actionExpr{ + pos: position{line: 116, col: 41, offset: 3296}, + run: (*parser).callonArgs145, + expr: &litMatcher{ + pos: position{line: 116, col: 41, offset: 3296}, + val: "false", + ignoreCase: false, + want: "\"false\"", + }, + }, + }, + }, + }, + &zeroOrMoreExpr{ + pos: position{line: 119, col: 6, offset: 3365}, + expr: &choiceExpr{ + pos: position{line: 119, col: 8, offset: 3367}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 122, col: 14, offset: 3444}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &choiceExpr{ + pos: position{line: 70, col: 17, offset: 1620}, + alternatives: []any{ + &ruleRefExpr{ + pos: position{line: 70, col: 17, offset: 1620}, + name: "Group", + }, + &actionExpr{ + pos: position{line: 124, col: 7, offset: 3473}, + run: (*parser).callonArgs159, + expr: &seqExpr{ + pos: position{line: 124, col: 7, offset: 3473}, + exprs: []any{ + &zeroOrMoreExpr{ + pos: position{line: 119, col: 6, offset: 3365}, + expr: &choiceExpr{ + pos: position{line: 119, col: 8, offset: 3367}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 122, col: 14, offset: 3444}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &litMatcher{ + pos: position{line: 124, col: 10, offset: 3476}, + val: ";", + ignoreCase: false, + want: "\";\"", + }, + }, + }, + }, + &actionExpr{ + pos: position{line: 124, col: 36, offset: 3502}, + run: (*parser).callonArgs172, + expr: &seqExpr{ + pos: position{line: 124, col: 36, offset: 3502}, + exprs: []any{ + &zeroOrMoreExpr{ + pos: position{line: 120, col: 5, offset: 3403}, + expr: &choiceExpr{ + pos: position{line: 120, col: 7, offset: 3405}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 120, col: 7, offset: 3405}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &zeroOrOneExpr{ + pos: position{line: 124, col: 38, offset: 3504}, + expr: &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + &litMatcher{ + pos: position{line: 123, col: 7, offset: 3460}, + val: "\n", + ignoreCase: false, + want: "\"\\n\"", + }, + }, + }, + }, + &actionExpr{ + pos: position{line: 124, col: 73, offset: 3539}, + run: (*parser).callonArgs193, + expr: &seqExpr{ + pos: position{line: 124, col: 73, offset: 3539}, + exprs: []any{ + &zeroOrMoreExpr{ + pos: position{line: 119, col: 6, offset: 3365}, + expr: &choiceExpr{ + pos: position{line: 119, col: 8, offset: 3367}, + alternatives: []any{ + &charClassMatcher{ + pos: position{line: 122, col: 14, offset: 3444}, + val: "[ \\t\\r\\n]", + chars: []rune{' ', '\t', '\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + &seqExpr{ + pos: position{line: 118, col: 11, offset: 3339}, + exprs: []any{ + &litMatcher{ + pos: position{line: 118, col: 11, offset: 3339}, + val: "#", + ignoreCase: false, + want: "\"#\"", + }, + &zeroOrMoreExpr{ + pos: position{line: 118, col: 15, offset: 3343}, + expr: &seqExpr{ + pos: position{line: 118, col: 17, offset: 3345}, + exprs: []any{ + ¬Expr{ + pos: position{line: 118, col: 17, offset: 3345}, + expr: &charClassMatcher{ + pos: position{line: 118, col: 18, offset: 3346}, + val: "[\\r\\n]", + chars: []rune{'\r', '\n'}, + ignoreCase: false, + inverted: false, + }, + }, + &anyMatcher{ + line: 118, col: 25, offset: 3353, + }, + }, + }, + }, + }, + }, + }, + }, + }, + ¬Expr{ + pos: position{line: 126, col: 7, offset: 3575}, + expr: &anyMatcher{ + line: 126, col: 8, offset: 3576, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, +} + +func (c *current) onConfig1(stmts any) (any, error) { + if stmts == nil { + return model.Group{}, nil + } + groupAny := toAnySlice(stmts) + groupSl := make(model.Group, len(groupAny)) + for i, e := range groupAny { + groupSl[i] = e.(model.Command) + } + return groupSl, nil +} + +func (p *parser) callonConfig1() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onConfig1(stack["stmts"]) +} + +func (c *current) onGroup1(stmts any) (any, error) { + if stmts == nil { + return model.Group{}, nil + } + groupAny := toAnySlice(stmts) + groupSl := make(model.Group, len(groupAny)) + for i, e := range groupAny { + groupSl[i] = e.(model.Command) + } + return groupSl, nil +} + +func (p *parser) callonGroup1() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onGroup1(stack["stmts"]) +} + +func (c *current) onCommand10() (any, error) { + return strconv.ParseFloat(string(c.text), 64) +} + +func (p *parser) callonCommand10() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onCommand10() +} + +func (c *current) onCommand4() (any, error) { + return model.Ident(c.text), nil +} + +func (p *parser) callonCommand4() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onCommand4() +} + +func (c *current) onCommand1(name, args any) (any, error) { + var group model.Group + rawArgs := args.([]any) + argsSlice := make([]any, 0, len(rawArgs)) + if len(rawArgs) > 0 { + for _, s := range rawArgs { + if s == nil { + continue + } + if g, ok := s.(model.Group); ok { + group = g + continue + } + if l, ok := s.([]any); ok { + l = slices.DeleteFunc(l, func(x any) bool { return x == nil }) + argsSlice = append(argsSlice, l...) + } + } + } + return model.Command{Name: name.(model.Ident), Args: argsSlice, Group: group}, nil +} + +func (p *parser) callonCommand1() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onCommand1(stack["name"], stack["args"]) +} + +func (c *current) onArgs16() (any, error) { + return strconv.ParseFloat(string(c.text), 64) +} + +func (p *parser) callonArgs16() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs16() +} + +func (c *current) onArgs10() (any, error) { + return model.Ident(c.text), nil +} + +func (p *parser) callonArgs10() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs10() +} + +func (c *current) onArgs38() (any, error) { + return string(c.text), nil +} + +func (p *parser) callonArgs38() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs38() +} + +func (c *current) onArgs121() (any, error) { + return strconv.ParseFloat(string(c.text), 64) +} + +func (p *parser) callonArgs121() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs121() +} + +func (c *current) onArgs143() (any, error) { + return true, nil +} + +func (p *parser) callonArgs143() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs143() +} + +func (c *current) onArgs145() (any, error) { + return false, nil +} + +func (p *parser) callonArgs145() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs145() +} + +func (c *current) onArgs6(val any) (any, error) { + return val, nil +} + +func (p *parser) callonArgs6() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs6(stack["val"]) +} + +func (c *current) onArgs3(vals any) (any, error) { + return toAnySlice(vals), nil +} + +func (p *parser) callonArgs3() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs3(stack["vals"]) +} + +func (c *current) onArgs159() (any, error) { + return nil, nil +} + +func (p *parser) callonArgs159() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs159() +} + +func (c *current) onArgs172() (any, error) { + return nil, nil +} + +func (p *parser) callonArgs172() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs172() +} + +func (c *current) onArgs193() (any, error) { + return nil, nil +} + +func (p *parser) callonArgs193() (any, error) { + stack := p.vstack[len(p.vstack)-1] + _ = stack + return p.cur.onArgs193() +} + +var ( + // errNoRule is returned when the grammar to parse has no rule. + errNoRule = errors.New("grammar has no rule") + + // errInvalidEntrypoint is returned when the specified entrypoint rule + // does not exit. + errInvalidEntrypoint = errors.New("invalid entrypoint") + + // errInvalidEncoding is returned when the source is not properly + // utf8-encoded. + errInvalidEncoding = errors.New("invalid encoding") + + // errMaxExprCnt is used to signal that the maximum number of + // expressions have been parsed. + errMaxExprCnt = errors.New("max number of expressions parsed") +) + +// 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 + +// MaxExpressions creates an Option to stop parsing after the provided +// number of expressions have been parsed, if the value is 0 then the parser will +// parse for as many steps as needed (possibly an infinite number). +// +// The default for maxExprCnt is 0. +func MaxExpressions(maxExprCnt uint64) Option { + return func(p *parser) Option { + oldMaxExprCnt := p.maxExprCnt + p.maxExprCnt = maxExprCnt + return MaxExpressions(oldMaxExprCnt) + } +} + +// Entrypoint creates an Option to set the rule name to use as entrypoint. +// The rule name must have been specified in the -alternate-entrypoints +// if generating the parser with the -optimize-grammar flag, otherwise +// it may have been optimized out. Passing an empty string sets the +// entrypoint to the first rule in the grammar. +// +// The default is to start parsing at the first rule in the grammar. +func Entrypoint(ruleName string) Option { + return func(p *parser) Option { + oldEntrypoint := p.entrypoint + p.entrypoint = ruleName + if ruleName == "" { + p.entrypoint = g.rules[0].name + } + return Entrypoint(oldEntrypoint) + } +} + +// AllowInvalidUTF8 creates an Option to allow invalid UTF-8 bytes. +// Every invalid UTF-8 byte is treated as a utf8.RuneError (U+FFFD) +// by character class matchers and is matched by the any matcher. +// The returned matched value, c.text and c.offset are NOT affected. +// +// The default is false. +func AllowInvalidUTF8(b bool) Option { + return func(p *parser) Option { + old := p.allowInvalidUTF8 + p.allowInvalidUTF8 = b + return AllowInvalidUTF8(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) + } +} + +// GlobalStore creates an Option to set a key to a certain value in +// the globalStore. +func GlobalStore(key string, value any) Option { + return func(p *parser) Option { + old := p.cur.globalStore[key] + p.cur.globalStore[key] = value + return GlobalStore(key, old) + } +} + +// ParseFile parses the file identified by filename. +func ParseFile(filename string, opts ...Option) (i any, err error) { // nolint: deadcode + f, err := os.Open(filename) + if err != nil { + return nil, err + } + defer func() { + if closeErr := f.Close(); closeErr != nil { + err = closeErr + } + }() + 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) (any, error) { // nolint: deadcode + b, err := io.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) (any, 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 strconv.Itoa(p.line) + ":" + strconv.Itoa(p.col) + " [" + strconv.Itoa(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 + + // globalStore is a general store for the user to store arbitrary key-value + // pairs that they need to manage and that they do not want tied to the + // backtracking of the parser. This is only modified by the user and never + // rolled back by the parser. It is always up to the user to keep this in a + // consistent state. + globalStore storeDict +} + +type storeDict map[string]any + +// the AST types... + +// nolint: structcheck +type grammar struct { + pos position + rules []*rule +} + +// nolint: structcheck +type rule struct { + pos position + name string + displayName string + expr any +} + +// nolint: structcheck +type choiceExpr struct { + pos position + alternatives []any +} + +// nolint: structcheck +type actionExpr struct { + pos position + expr any + run func(*parser) (any, error) +} + +// nolint: structcheck +type recoveryExpr struct { + pos position + expr any + recoverExpr any + failureLabel []string +} + +// nolint: structcheck +type seqExpr struct { + pos position + exprs []any +} + +// nolint: structcheck +type throwExpr struct { + pos position + label string +} + +// nolint: structcheck +type labeledExpr struct { + pos position + label string + expr any +} + +// nolint: structcheck +type expr struct { + pos position + expr any +} + +type ( + andExpr expr // nolint: structcheck + notExpr expr // nolint: structcheck + zeroOrOneExpr expr // nolint: structcheck + zeroOrMoreExpr expr // nolint: structcheck + oneOrMoreExpr expr // nolint: structcheck +) + +// nolint: structcheck +type ruleRefExpr struct { + pos position + name string +} + +// nolint: structcheck +type andCodeExpr struct { + pos position + run func(*parser) (bool, error) +} + +// nolint: structcheck +type notCodeExpr struct { + pos position + run func(*parser) (bool, error) +} + +// nolint: structcheck +type litMatcher struct { + pos position + val string + ignoreCase bool + want string +} + +// nolint: structcheck +type charClassMatcher struct { + pos position + val string + basicLatinChars [128]bool + chars []rune + ranges []rune + classes []*unicode.RangeTable + ignoreCase bool + inverted bool +} + +type anyMatcher position // nolint: structcheck + +// 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 + expected []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 { + stats := Stats{ + ChoiceAltCnt: make(map[string]map[string]int), + } + + p := &parser{ + filename: filename, + errs: new(errList), + data: b, + pt: savepoint{position: position{line: 1}}, + recover: true, + cur: current{ + globalStore: make(storeDict), + }, + maxFailPos: position{col: 1, line: 1}, + maxFailExpected: make([]string, 0, 20), + Stats: &stats, + // start rule is rule [0] unless an alternate entrypoint is specified + entrypoint: g.rules[0].name, + } + p.setOptions(opts) + + if p.maxExprCnt == 0 { + p.maxExprCnt = math.MaxUint64 + } + + return p +} + +// setOptions applies the options to the parser. +func (p *parser) setOptions(opts []Option) { + for _, opt := range opts { + opt(p) + } +} + +// nolint: structcheck,deadcode +type resultTuple struct { + v any + b bool + end savepoint +} + +// nolint: varcheck +const choiceNoMatch = -1 + +// Stats stores some statistics, gathered during parsing +type Stats struct { + // ExprCnt counts the number of expressions processed during parsing + // This value is compared to the maximum number of expressions allowed + // (set by the MaxExpressions option). + ExprCnt uint64 + + // ChoiceAltCnt is used to count for each ordered choice expression, + // which alternative is used how may times. + // These numbers allow to optimize the order of the ordered choice expression + // to increase the performance of the parser + // + // The outer key of ChoiceAltCnt is composed of the name of the rule as well + // as the line and the column of the ordered choice. + // The inner key of ChoiceAltCnt is the number (one-based) of the matching alternative. + // For each alternative the number of matches are counted. If an ordered choice does not + // match, a special counter is incremented. The name of this counter is set with + // the parser option Statistics. + // For an alternative to be included in ChoiceAltCnt, it has to match at least once. + ChoiceAltCnt map[string]map[string]int +} + +// nolint: structcheck,maligned +type parser struct { + filename string + pt savepoint + cur current + + data []byte + errs *errList + + depth int + recover bool + + // rules table, maps the rule identifier to the rule node + rules map[string]*rule + // variables stack, map of label to value + vstack []map[string]any + // rule stack, allows identification of the current rule in errors + rstack []*rule + + // parse fail + maxFailPos position + maxFailExpected []string + maxFailInvertExpected bool + + // max number of expressions to be parsed + maxExprCnt uint64 + // entrypoint for the parser + entrypoint string + + allowInvalidUTF8 bool + + *Stats + + choiceNoMatch string + // recovery expression stack, keeps track of the currently available recovery expression, these are traversed in reverse + recoveryStack []map[string]any +} + +// 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]any) + 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] +} + +// push a recovery expression with its labels to the recoveryStack +func (p *parser) pushRecovery(labels []string, expr any) { + if cap(p.recoveryStack) == len(p.recoveryStack) { + // create new empty slot in the stack + p.recoveryStack = append(p.recoveryStack, nil) + } else { + // slice to 1 more + p.recoveryStack = p.recoveryStack[:len(p.recoveryStack)+1] + } + + m := make(map[string]any, len(labels)) + for _, fl := range labels { + m[fl] = expr + } + p.recoveryStack[len(p.recoveryStack)-1] = m +} + +// pop a recovery expression from the recoveryStack +func (p *parser) popRecovery() { + // GC that map + p.recoveryStack[len(p.recoveryStack)-1] = nil + + p.recoveryStack = p.recoveryStack[:len(p.recoveryStack)-1] +} + +func (p *parser) addErr(err error) { + p.addErrAt(err, p.pt.position, []string{}) +} + +func (p *parser) addErrAt(err error, pos position, expected []string) { + 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, pos: pos, prefix: buf.String(), expected: expected} + p.errs.add(pe) +} + +func (p *parser) failAt(fail bool, pos position, want string) { + // process fail if parsing fails and not inverted or parsing succeeds and invert is set + if fail == p.maxFailInvertExpected { + if pos.offset < p.maxFailPos.offset { + return + } + + if pos.offset > p.maxFailPos.offset { + p.maxFailPos = pos + p.maxFailExpected = p.maxFailExpected[:0] + } + + if p.maxFailInvertExpected { + want = "!" + want + } + p.maxFailExpected = append(p.maxFailExpected, want) + } +} + +// 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 && n == 1 { // see utf8.DecodeRune + if !p.allowInvalidUTF8 { + p.addErr(errInvalidEncoding) + } + } +} + +// restore parser position to the savepoint pt. +func (p *parser) restore(pt savepoint) { + 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) buildRulesTable(g *grammar) { + p.rules = make(map[string]*rule, len(g.rules)) + for _, r := range g.rules { + p.rules[r.name] = r + } +} + +// nolint: gocyclo +func (p *parser) parse(g *grammar) (val any, 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 { + val = nil + switch e := e.(type) { + case error: + p.addErr(e) + default: + p.addErr(fmt.Errorf("%v", e)) + } + err = p.errs.err() + } + }() + } + + startRule, ok := p.rules[p.entrypoint] + if !ok { + p.addErr(errInvalidEntrypoint) + return nil, p.errs.err() + } + + p.read() // advance to first rune + val, ok = p.parseRuleWrap(startRule) + if !ok { + if len(*p.errs) == 0 { + // If parsing fails, but no errors have been recorded, the expected values + // for the farthest parser position are returned as error. + maxFailExpectedMap := make(map[string]struct{}, len(p.maxFailExpected)) + for _, v := range p.maxFailExpected { + maxFailExpectedMap[v] = struct{}{} + } + expected := make([]string, 0, len(maxFailExpectedMap)) + eof := false + if _, ok := maxFailExpectedMap["!."]; ok { + delete(maxFailExpectedMap, "!.") + eof = true + } + for k := range maxFailExpectedMap { + expected = append(expected, k) + } + sort.Strings(expected) + if eof { + expected = append(expected, "EOF") + } + p.addErrAt(errors.New("no match found, expected: "+listJoin(expected, ", ", "or")), p.maxFailPos, expected) + } + + return nil, p.errs.err() + } + return val, p.errs.err() +} + +func listJoin(list []string, sep string, lastSep string) string { + switch len(list) { + case 0: + return "" + case 1: + return list[0] + default: + return strings.Join(list[:len(list)-1], sep) + " " + lastSep + " " + list[len(list)-1] + } +} + +func (p *parser) parseRuleWrap(rule *rule) (any, bool) { + var ( + val any + ok bool + ) + + val, ok = p.parseRule(rule) + + return val, ok +} + +func (p *parser) parseRule(rule *rule) (any, bool) { + p.rstack = append(p.rstack, rule) + p.pushV() + val, ok := p.parseExprWrap(rule.expr) + p.popV() + p.rstack = p.rstack[:len(p.rstack)-1] + return val, ok +} + +func (p *parser) parseExprWrap(expr any) (any, bool) { + val, ok := p.parseExpr(expr) + + return val, ok +} + +// nolint: gocyclo +func (p *parser) parseExpr(expr any) (any, bool) { + p.ExprCnt++ + if p.ExprCnt > p.maxExprCnt { + panic(errMaxExprCnt) + } + + var val any + var ok bool + 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 *recoveryExpr: + val, ok = p.parseRecoveryExpr(expr) + case *ruleRefExpr: + val, ok = p.parseRuleRefExpr(expr) + case *seqExpr: + val, ok = p.parseSeqExpr(expr) + case *throwExpr: + val, ok = p.parseThrowExpr(expr) + case *zeroOrMoreExpr: + val, ok = p.parseZeroOrMoreExpr(expr) + case *zeroOrOneExpr: + val, ok = p.parseZeroOrOneExpr(expr) + default: + panic(fmt.Sprintf("unknown expression type %T", expr)) + } + return val, ok +} + +func (p *parser) parseActionExpr(act *actionExpr) (any, bool) { + start := p.pt + val, ok := p.parseExprWrap(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, []string{}) + } + + val = actVal + } + return val, ok +} + +func (p *parser) parseAndCodeExpr(and *andCodeExpr) (any, bool) { + + ok, err := and.run(p) + if err != nil { + p.addErr(err) + } + + return nil, ok +} + +func (p *parser) parseAndExpr(and *andExpr) (any, bool) { + pt := p.pt + p.pushV() + _, ok := p.parseExprWrap(and.expr) + p.popV() + p.restore(pt) + + return nil, ok +} + +func (p *parser) parseAnyMatcher(any *anyMatcher) (any, bool) { + if p.pt.rn == utf8.RuneError && p.pt.w == 0 { + // EOF - see utf8.DecodeRune + p.failAt(false, p.pt.position, ".") + return nil, false + } + start := p.pt + p.read() + p.failAt(true, start.position, ".") + return p.sliceFrom(start), true +} + +// nolint: gocyclo +func (p *parser) parseCharClassMatcher(chr *charClassMatcher) (any, bool) { + cur := p.pt.rn + start := p.pt + + // can't match EOF + if cur == utf8.RuneError && p.pt.w == 0 { // see utf8.DecodeRune + p.failAt(false, start.position, chr.val) + return nil, false + } + + 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 { + p.failAt(false, start.position, chr.val) + return nil, false + } + p.read() + p.failAt(true, start.position, chr.val) + 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 { + p.failAt(false, start.position, chr.val) + return nil, false + } + p.read() + p.failAt(true, start.position, chr.val) + 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 { + p.failAt(false, start.position, chr.val) + return nil, false + } + p.read() + p.failAt(true, start.position, chr.val) + return p.sliceFrom(start), true + } + } + + if chr.inverted { + p.read() + p.failAt(true, start.position, chr.val) + return p.sliceFrom(start), true + } + p.failAt(false, start.position, chr.val) + return nil, false +} + +func (p *parser) parseChoiceExpr(ch *choiceExpr) (any, bool) { + + for altI, alt := range ch.alternatives { + // dummy assignment to prevent compile error if optimized + _ = altI + + p.pushV() + val, ok := p.parseExprWrap(alt) + p.popV() + if ok { + return val, ok + } + } + return nil, false +} + +func (p *parser) parseLabeledExpr(lab *labeledExpr) (any, bool) { + p.pushV() + val, ok := p.parseExprWrap(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) (any, bool) { + start := p.pt + for _, want := range lit.val { + cur := p.pt.rn + if lit.ignoreCase { + cur = unicode.ToLower(cur) + } + if cur != want { + p.failAt(false, start.position, lit.want) + p.restore(start) + return nil, false + } + p.read() + } + p.failAt(true, start.position, lit.want) + return p.sliceFrom(start), true +} + +func (p *parser) parseNotCodeExpr(not *notCodeExpr) (any, bool) { + ok, err := not.run(p) + if err != nil { + p.addErr(err) + } + + return nil, !ok +} + +func (p *parser) parseNotExpr(not *notExpr) (any, bool) { + pt := p.pt + p.pushV() + p.maxFailInvertExpected = !p.maxFailInvertExpected + _, ok := p.parseExprWrap(not.expr) + p.maxFailInvertExpected = !p.maxFailInvertExpected + p.popV() + p.restore(pt) + + return nil, !ok +} + +func (p *parser) parseOneOrMoreExpr(expr *oneOrMoreExpr) (any, bool) { + var vals []any + + for { + p.pushV() + val, ok := p.parseExprWrap(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) parseRecoveryExpr(recover *recoveryExpr) (any, bool) { + + p.pushRecovery(recover.failureLabel, recover.recoverExpr) + val, ok := p.parseExprWrap(recover.expr) + p.popRecovery() + + return val, ok +} + +func (p *parser) parseRuleRefExpr(ref *ruleRefExpr) (any, bool) { + 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.parseRuleWrap(rule) +} + +func (p *parser) parseSeqExpr(seq *seqExpr) (any, bool) { + vals := make([]any, 0, len(seq.exprs)) + + pt := p.pt + for _, expr := range seq.exprs { + val, ok := p.parseExprWrap(expr) + if !ok { + p.restore(pt) + return nil, false + } + vals = append(vals, val) + } + return vals, true +} + +func (p *parser) parseThrowExpr(expr *throwExpr) (any, bool) { + + for i := len(p.recoveryStack) - 1; i >= 0; i-- { + if recoverExpr, ok := p.recoveryStack[i][expr.label]; ok { + if val, ok := p.parseExprWrap(recoverExpr); ok { + return val, ok + } + } + } + + return nil, false +} + +func (p *parser) parseZeroOrMoreExpr(expr *zeroOrMoreExpr) (any, bool) { + var vals []any + + for { + p.pushV() + val, ok := p.parseExprWrap(expr.expr) + p.popV() + if !ok { + return vals, true + } + vals = append(vals, val) + } +} + +func (p *parser) parseZeroOrOneExpr(expr *zeroOrOneExpr) (any, bool) { + p.pushV() + val, _ := p.parseExprWrap(expr.expr) + p.popV() + // whether it matched or not, consider it a match + return val, true +} |