// Code generated by pigeon; DO NOT EDIT. package bexpr import ( "bytes" "errors" "fmt" "io" "io/ioutil" "math" "os" "sort" "strconv" "strings" "unicode" "unicode/utf8" ) var g = &grammar{ rules: []*rule{ { name: "Input", pos: position{line: 10, col: 1, offset: 57}, expr: &choiceExpr{ pos: position{line: 10, col: 10, offset: 66}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 10, col: 10, offset: 66}, run: (*parser).callonInput2, expr: &seqExpr{ pos: position{line: 10, col: 10, offset: 66}, exprs: []interface{}{ &zeroOrOneExpr{ pos: position{line: 10, col: 10, offset: 66}, expr: &ruleRefExpr{ pos: position{line: 10, col: 10, offset: 66}, name: "_", }, }, &litMatcher{ pos: position{line: 10, col: 13, offset: 69}, val: "(", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 10, col: 17, offset: 73}, expr: &ruleRefExpr{ pos: position{line: 10, col: 17, offset: 73}, name: "_", }, }, &labeledExpr{ pos: position{line: 10, col: 20, offset: 76}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 10, col: 25, offset: 81}, name: "OrExpression", }, }, &zeroOrOneExpr{ pos: position{line: 10, col: 38, offset: 94}, expr: &ruleRefExpr{ pos: position{line: 10, col: 38, offset: 94}, name: "_", }, }, &litMatcher{ pos: position{line: 10, col: 41, offset: 97}, val: ")", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 10, col: 45, offset: 101}, expr: &ruleRefExpr{ pos: position{line: 10, col: 45, offset: 101}, name: "_", }, }, &ruleRefExpr{ pos: position{line: 10, col: 48, offset: 104}, name: "EOF", }, }, }, }, &actionExpr{ pos: position{line: 12, col: 5, offset: 134}, run: (*parser).callonInput17, expr: &seqExpr{ pos: position{line: 12, col: 5, offset: 134}, exprs: []interface{}{ &zeroOrOneExpr{ pos: position{line: 12, col: 5, offset: 134}, expr: &ruleRefExpr{ pos: position{line: 12, col: 5, offset: 134}, name: "_", }, }, &labeledExpr{ pos: position{line: 12, col: 8, offset: 137}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 12, col: 13, offset: 142}, name: "OrExpression", }, }, &zeroOrOneExpr{ pos: position{line: 12, col: 26, offset: 155}, expr: &ruleRefExpr{ pos: position{line: 12, col: 26, offset: 155}, name: "_", }, }, &ruleRefExpr{ pos: position{line: 12, col: 29, offset: 158}, name: "EOF", }, }, }, }, }, }, }, { name: "OrExpression", pos: position{line: 16, col: 1, offset: 187}, expr: &choiceExpr{ pos: position{line: 16, col: 17, offset: 203}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 16, col: 17, offset: 203}, run: (*parser).callonOrExpression2, expr: &seqExpr{ pos: position{line: 16, col: 17, offset: 203}, exprs: []interface{}{ &labeledExpr{ pos: position{line: 16, col: 17, offset: 203}, label: "left", expr: &ruleRefExpr{ pos: position{line: 16, col: 22, offset: 208}, name: "AndExpression", }, }, &ruleRefExpr{ pos: position{line: 16, col: 36, offset: 222}, name: "_", }, &litMatcher{ pos: position{line: 16, col: 38, offset: 224}, val: "or", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 16, col: 43, offset: 229}, name: "_", }, &labeledExpr{ pos: position{line: 16, col: 45, offset: 231}, label: "right", expr: &ruleRefExpr{ pos: position{line: 16, col: 51, offset: 237}, name: "OrExpression", }, }, }, }, }, &actionExpr{ pos: position{line: 22, col: 5, offset: 387}, run: (*parser).callonOrExpression11, expr: &labeledExpr{ pos: position{line: 22, col: 5, offset: 387}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 22, col: 10, offset: 392}, name: "AndExpression", }, }, }, }, }, }, { name: "AndExpression", pos: position{line: 26, col: 1, offset: 431}, expr: &choiceExpr{ pos: position{line: 26, col: 18, offset: 448}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 26, col: 18, offset: 448}, run: (*parser).callonAndExpression2, expr: &seqExpr{ pos: position{line: 26, col: 18, offset: 448}, exprs: []interface{}{ &labeledExpr{ pos: position{line: 26, col: 18, offset: 448}, label: "left", expr: &ruleRefExpr{ pos: position{line: 26, col: 23, offset: 453}, name: "NotExpression", }, }, &ruleRefExpr{ pos: position{line: 26, col: 37, offset: 467}, name: "_", }, &litMatcher{ pos: position{line: 26, col: 39, offset: 469}, val: "and", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 26, col: 45, offset: 475}, name: "_", }, &labeledExpr{ pos: position{line: 26, col: 47, offset: 477}, label: "right", expr: &ruleRefExpr{ pos: position{line: 26, col: 53, offset: 483}, name: "AndExpression", }, }, }, }, }, &actionExpr{ pos: position{line: 32, col: 5, offset: 635}, run: (*parser).callonAndExpression11, expr: &labeledExpr{ pos: position{line: 32, col: 5, offset: 635}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 32, col: 10, offset: 640}, name: "NotExpression", }, }, }, }, }, }, { name: "NotExpression", pos: position{line: 36, col: 1, offset: 679}, expr: &choiceExpr{ pos: position{line: 36, col: 18, offset: 696}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 36, col: 18, offset: 696}, run: (*parser).callonNotExpression2, expr: &seqExpr{ pos: position{line: 36, col: 18, offset: 696}, exprs: []interface{}{ &litMatcher{ pos: position{line: 36, col: 18, offset: 696}, val: "not", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 36, col: 24, offset: 702}, name: "_", }, &labeledExpr{ pos: position{line: 36, col: 26, offset: 704}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 36, col: 31, offset: 709}, name: "NotExpression", }, }, }, }, }, &actionExpr{ pos: position{line: 47, col: 5, offset: 1096}, run: (*parser).callonNotExpression8, expr: &labeledExpr{ pos: position{line: 47, col: 5, offset: 1096}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 47, col: 10, offset: 1101}, name: "ParenthesizedExpression", }, }, }, }, }, }, { name: "ParenthesizedExpression", displayName: "\"grouping\"", pos: position{line: 51, col: 1, offset: 1150}, expr: &choiceExpr{ pos: position{line: 51, col: 39, offset: 1188}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 51, col: 39, offset: 1188}, run: (*parser).callonParenthesizedExpression2, expr: &seqExpr{ pos: position{line: 51, col: 39, offset: 1188}, exprs: []interface{}{ &litMatcher{ pos: position{line: 51, col: 39, offset: 1188}, val: "(", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 51, col: 43, offset: 1192}, expr: &ruleRefExpr{ pos: position{line: 51, col: 43, offset: 1192}, name: "_", }, }, &labeledExpr{ pos: position{line: 51, col: 46, offset: 1195}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 51, col: 51, offset: 1200}, name: "OrExpression", }, }, &zeroOrOneExpr{ pos: position{line: 51, col: 64, offset: 1213}, expr: &ruleRefExpr{ pos: position{line: 51, col: 64, offset: 1213}, name: "_", }, }, &litMatcher{ pos: position{line: 51, col: 67, offset: 1216}, val: ")", ignoreCase: false, }, }, }, }, &actionExpr{ pos: position{line: 53, col: 5, offset: 1246}, run: (*parser).callonParenthesizedExpression12, expr: &labeledExpr{ pos: position{line: 53, col: 5, offset: 1246}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 53, col: 10, offset: 1251}, name: "MatchExpression", }, }, }, &seqExpr{ pos: position{line: 55, col: 5, offset: 1293}, exprs: []interface{}{ &litMatcher{ pos: position{line: 55, col: 5, offset: 1293}, val: "(", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 55, col: 9, offset: 1297}, expr: &ruleRefExpr{ pos: position{line: 55, col: 9, offset: 1297}, name: "_", }, }, &ruleRefExpr{ pos: position{line: 55, col: 12, offset: 1300}, name: "OrExpression", }, &zeroOrOneExpr{ pos: position{line: 55, col: 25, offset: 1313}, expr: &ruleRefExpr{ pos: position{line: 55, col: 25, offset: 1313}, name: "_", }, }, ¬Expr{ pos: position{line: 55, col: 28, offset: 1316}, expr: &litMatcher{ pos: position{line: 55, col: 29, offset: 1317}, val: ")", ignoreCase: false, }, }, &andCodeExpr{ pos: position{line: 55, col: 33, offset: 1321}, run: (*parser).callonParenthesizedExpression24, }, }, }, }, }, }, { name: "MatchExpression", displayName: "\"match\"", pos: position{line: 59, col: 1, offset: 1380}, expr: &choiceExpr{ pos: position{line: 59, col: 28, offset: 1407}, alternatives: []interface{}{ &ruleRefExpr{ pos: position{line: 59, col: 28, offset: 1407}, name: "MatchSelectorOpValue", }, &ruleRefExpr{ pos: position{line: 59, col: 51, offset: 1430}, name: "MatchSelectorOp", }, &ruleRefExpr{ pos: position{line: 59, col: 69, offset: 1448}, name: "MatchValueOpSelector", }, }, }, }, { name: "MatchSelectorOpValue", displayName: "\"match\"", pos: position{line: 61, col: 1, offset: 1470}, expr: &actionExpr{ pos: position{line: 61, col: 33, offset: 1502}, run: (*parser).callonMatchSelectorOpValue1, expr: &seqExpr{ pos: position{line: 61, col: 33, offset: 1502}, exprs: []interface{}{ &labeledExpr{ pos: position{line: 61, col: 33, offset: 1502}, label: "selector", expr: &ruleRefExpr{ pos: position{line: 61, col: 42, offset: 1511}, name: "Selector", }, }, &labeledExpr{ pos: position{line: 61, col: 51, offset: 1520}, label: "operator", expr: &choiceExpr{ pos: position{line: 61, col: 61, offset: 1530}, alternatives: []interface{}{ &ruleRefExpr{ pos: position{line: 61, col: 61, offset: 1530}, name: "MatchEqual", }, &ruleRefExpr{ pos: position{line: 61, col: 74, offset: 1543}, name: "MatchNotEqual", }, &ruleRefExpr{ pos: position{line: 61, col: 90, offset: 1559}, name: "MatchContains", }, &ruleRefExpr{ pos: position{line: 61, col: 106, offset: 1575}, name: "MatchNotContains", }, &ruleRefExpr{ pos: position{line: 61, col: 125, offset: 1594}, name: "MatchMatches", }, &ruleRefExpr{ pos: position{line: 61, col: 140, offset: 1609}, name: "MatchNotMatches", }, }, }, }, &labeledExpr{ pos: position{line: 61, col: 157, offset: 1626}, label: "value", expr: &ruleRefExpr{ pos: position{line: 61, col: 163, offset: 1632}, name: "Value", }, }, }, }, }, }, { name: "MatchSelectorOp", displayName: "\"match\"", pos: position{line: 65, col: 1, offset: 1770}, expr: &actionExpr{ pos: position{line: 65, col: 28, offset: 1797}, run: (*parser).callonMatchSelectorOp1, expr: &seqExpr{ pos: position{line: 65, col: 28, offset: 1797}, exprs: []interface{}{ &labeledExpr{ pos: position{line: 65, col: 28, offset: 1797}, label: "selector", expr: &ruleRefExpr{ pos: position{line: 65, col: 37, offset: 1806}, name: "Selector", }, }, &labeledExpr{ pos: position{line: 65, col: 46, offset: 1815}, label: "operator", expr: &choiceExpr{ pos: position{line: 65, col: 56, offset: 1825}, alternatives: []interface{}{ &ruleRefExpr{ pos: position{line: 65, col: 56, offset: 1825}, name: "MatchIsEmpty", }, &ruleRefExpr{ pos: position{line: 65, col: 71, offset: 1840}, name: "MatchIsNotEmpty", }, }, }, }, }, }, }, }, { name: "MatchValueOpSelector", displayName: "\"match\"", pos: position{line: 69, col: 1, offset: 1973}, expr: &choiceExpr{ pos: position{line: 69, col: 33, offset: 2005}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 69, col: 33, offset: 2005}, run: (*parser).callonMatchValueOpSelector2, expr: &seqExpr{ pos: position{line: 69, col: 33, offset: 2005}, exprs: []interface{}{ &labeledExpr{ pos: position{line: 69, col: 33, offset: 2005}, label: "value", expr: &ruleRefExpr{ pos: position{line: 69, col: 39, offset: 2011}, name: "Value", }, }, &labeledExpr{ pos: position{line: 69, col: 45, offset: 2017}, label: "operator", expr: &choiceExpr{ pos: position{line: 69, col: 55, offset: 2027}, alternatives: []interface{}{ &ruleRefExpr{ pos: position{line: 69, col: 55, offset: 2027}, name: "MatchIn", }, &ruleRefExpr{ pos: position{line: 69, col: 65, offset: 2037}, name: "MatchNotIn", }, }, }, }, &labeledExpr{ pos: position{line: 69, col: 77, offset: 2049}, label: "selector", expr: &ruleRefExpr{ pos: position{line: 69, col: 86, offset: 2058}, name: "Selector", }, }, }, }, }, &seqExpr{ pos: position{line: 71, col: 5, offset: 2200}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 71, col: 5, offset: 2200}, name: "Value", }, &labeledExpr{ pos: position{line: 71, col: 11, offset: 2206}, label: "operator", expr: &choiceExpr{ pos: position{line: 71, col: 21, offset: 2216}, alternatives: []interface{}{ &ruleRefExpr{ pos: position{line: 71, col: 21, offset: 2216}, name: "MatchIn", }, &ruleRefExpr{ pos: position{line: 71, col: 31, offset: 2226}, name: "MatchNotIn", }, }, }, }, ¬Expr{ pos: position{line: 71, col: 43, offset: 2238}, expr: &ruleRefExpr{ pos: position{line: 71, col: 44, offset: 2239}, name: "Selector", }, }, &andCodeExpr{ pos: position{line: 71, col: 53, offset: 2248}, run: (*parser).callonMatchValueOpSelector20, }, }, }, }, }, }, { name: "MatchEqual", pos: position{line: 75, col: 1, offset: 2302}, expr: &actionExpr{ pos: position{line: 75, col: 15, offset: 2316}, run: (*parser).callonMatchEqual1, expr: &seqExpr{ pos: position{line: 75, col: 15, offset: 2316}, exprs: []interface{}{ &zeroOrOneExpr{ pos: position{line: 75, col: 15, offset: 2316}, expr: &ruleRefExpr{ pos: position{line: 75, col: 15, offset: 2316}, name: "_", }, }, &litMatcher{ pos: position{line: 75, col: 18, offset: 2319}, val: "==", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 75, col: 23, offset: 2324}, expr: &ruleRefExpr{ pos: position{line: 75, col: 23, offset: 2324}, name: "_", }, }, }, }, }, }, { name: "MatchNotEqual", pos: position{line: 78, col: 1, offset: 2357}, expr: &actionExpr{ pos: position{line: 78, col: 18, offset: 2374}, run: (*parser).callonMatchNotEqual1, expr: &seqExpr{ pos: position{line: 78, col: 18, offset: 2374}, exprs: []interface{}{ &zeroOrOneExpr{ pos: position{line: 78, col: 18, offset: 2374}, expr: &ruleRefExpr{ pos: position{line: 78, col: 18, offset: 2374}, name: "_", }, }, &litMatcher{ pos: position{line: 78, col: 21, offset: 2377}, val: "!=", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 78, col: 26, offset: 2382}, expr: &ruleRefExpr{ pos: position{line: 78, col: 26, offset: 2382}, name: "_", }, }, }, }, }, }, { name: "MatchIsEmpty", pos: position{line: 81, col: 1, offset: 2418}, expr: &actionExpr{ pos: position{line: 81, col: 17, offset: 2434}, run: (*parser).callonMatchIsEmpty1, expr: &seqExpr{ pos: position{line: 81, col: 17, offset: 2434}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 81, col: 17, offset: 2434}, name: "_", }, &litMatcher{ pos: position{line: 81, col: 19, offset: 2436}, val: "is", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 81, col: 24, offset: 2441}, name: "_", }, &litMatcher{ pos: position{line: 81, col: 26, offset: 2443}, val: "empty", ignoreCase: false, }, }, }, }, }, { name: "MatchIsNotEmpty", pos: position{line: 84, col: 1, offset: 2483}, expr: &actionExpr{ pos: position{line: 84, col: 20, offset: 2502}, run: (*parser).callonMatchIsNotEmpty1, expr: &seqExpr{ pos: position{line: 84, col: 20, offset: 2502}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 84, col: 20, offset: 2502}, name: "_", }, &litMatcher{ pos: position{line: 84, col: 21, offset: 2503}, val: "is", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 84, col: 26, offset: 2508}, name: "_", }, &litMatcher{ pos: position{line: 84, col: 28, offset: 2510}, val: "not", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 84, col: 34, offset: 2516}, name: "_", }, &litMatcher{ pos: position{line: 84, col: 36, offset: 2518}, val: "empty", ignoreCase: false, }, }, }, }, }, { name: "MatchIn", pos: position{line: 87, col: 1, offset: 2561}, expr: &actionExpr{ pos: position{line: 87, col: 12, offset: 2572}, run: (*parser).callonMatchIn1, expr: &seqExpr{ pos: position{line: 87, col: 12, offset: 2572}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 87, col: 12, offset: 2572}, name: "_", }, &litMatcher{ pos: position{line: 87, col: 14, offset: 2574}, val: "in", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 87, col: 19, offset: 2579}, name: "_", }, }, }, }, }, { name: "MatchNotIn", pos: position{line: 90, col: 1, offset: 2608}, expr: &actionExpr{ pos: position{line: 90, col: 15, offset: 2622}, run: (*parser).callonMatchNotIn1, expr: &seqExpr{ pos: position{line: 90, col: 15, offset: 2622}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 90, col: 15, offset: 2622}, name: "_", }, &litMatcher{ pos: position{line: 90, col: 17, offset: 2624}, val: "not", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 90, col: 23, offset: 2630}, name: "_", }, &litMatcher{ pos: position{line: 90, col: 25, offset: 2632}, val: "in", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 90, col: 30, offset: 2637}, name: "_", }, }, }, }, }, { name: "MatchContains", pos: position{line: 93, col: 1, offset: 2669}, expr: &actionExpr{ pos: position{line: 93, col: 18, offset: 2686}, run: (*parser).callonMatchContains1, expr: &seqExpr{ pos: position{line: 93, col: 18, offset: 2686}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 93, col: 18, offset: 2686}, name: "_", }, &litMatcher{ pos: position{line: 93, col: 20, offset: 2688}, val: "contains", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 93, col: 31, offset: 2699}, name: "_", }, }, }, }, }, { name: "MatchNotContains", pos: position{line: 96, col: 1, offset: 2728}, expr: &actionExpr{ pos: position{line: 96, col: 21, offset: 2748}, run: (*parser).callonMatchNotContains1, expr: &seqExpr{ pos: position{line: 96, col: 21, offset: 2748}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 96, col: 21, offset: 2748}, name: "_", }, &litMatcher{ pos: position{line: 96, col: 23, offset: 2750}, val: "not", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 96, col: 29, offset: 2756}, name: "_", }, &litMatcher{ pos: position{line: 96, col: 31, offset: 2758}, val: "contains", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 96, col: 42, offset: 2769}, name: "_", }, }, }, }, }, { name: "MatchMatches", pos: position{line: 99, col: 1, offset: 2801}, expr: &actionExpr{ pos: position{line: 99, col: 17, offset: 2817}, run: (*parser).callonMatchMatches1, expr: &seqExpr{ pos: position{line: 99, col: 17, offset: 2817}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 99, col: 17, offset: 2817}, name: "_", }, &litMatcher{ pos: position{line: 99, col: 19, offset: 2819}, val: "matches", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 99, col: 29, offset: 2829}, name: "_", }, }, }, }, }, { name: "MatchNotMatches", pos: position{line: 102, col: 1, offset: 2863}, expr: &actionExpr{ pos: position{line: 102, col: 20, offset: 2882}, run: (*parser).callonMatchNotMatches1, expr: &seqExpr{ pos: position{line: 102, col: 20, offset: 2882}, exprs: []interface{}{ &ruleRefExpr{ pos: position{line: 102, col: 20, offset: 2882}, name: "_", }, &litMatcher{ pos: position{line: 102, col: 22, offset: 2884}, val: "not", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 102, col: 28, offset: 2890}, name: "_", }, &litMatcher{ pos: position{line: 102, col: 30, offset: 2892}, val: "matches", ignoreCase: false, }, &ruleRefExpr{ pos: position{line: 102, col: 40, offset: 2902}, name: "_", }, }, }, }, }, { name: "Selector", displayName: "\"selector\"", pos: position{line: 106, col: 1, offset: 2940}, expr: &actionExpr{ pos: position{line: 106, col: 24, offset: 2963}, run: (*parser).callonSelector1, expr: &seqExpr{ pos: position{line: 106, col: 24, offset: 2963}, exprs: []interface{}{ &labeledExpr{ pos: position{line: 106, col: 24, offset: 2963}, label: "first", expr: &ruleRefExpr{ pos: position{line: 106, col: 30, offset: 2969}, name: "Identifier", }, }, &labeledExpr{ pos: position{line: 106, col: 41, offset: 2980}, label: "rest", expr: &zeroOrMoreExpr{ pos: position{line: 106, col: 46, offset: 2985}, expr: &ruleRefExpr{ pos: position{line: 106, col: 46, offset: 2985}, name: "SelectorOrIndex", }, }, }, }, }, }, }, { name: "Identifier", pos: position{line: 119, col: 1, offset: 3192}, expr: &actionExpr{ pos: position{line: 119, col: 15, offset: 3206}, run: (*parser).callonIdentifier1, expr: &seqExpr{ pos: position{line: 119, col: 15, offset: 3206}, exprs: []interface{}{ &charClassMatcher{ pos: position{line: 119, col: 15, offset: 3206}, val: "[a-zA-Z]", ranges: []rune{'a', 'z', 'A', 'Z'}, ignoreCase: false, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 119, col: 24, offset: 3215}, expr: &charClassMatcher{ pos: position{line: 119, col: 24, offset: 3215}, val: "[a-zA-Z0-9_]", chars: []rune{'_'}, ranges: []rune{'a', 'z', 'A', 'Z', '0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, { name: "SelectorOrIndex", pos: position{line: 123, col: 1, offset: 3264}, expr: &choiceExpr{ pos: position{line: 123, col: 20, offset: 3283}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 123, col: 20, offset: 3283}, run: (*parser).callonSelectorOrIndex2, expr: &seqExpr{ pos: position{line: 123, col: 20, offset: 3283}, exprs: []interface{}{ &litMatcher{ pos: position{line: 123, col: 20, offset: 3283}, val: ".", ignoreCase: false, }, &labeledExpr{ pos: position{line: 123, col: 24, offset: 3287}, label: "ident", expr: &ruleRefExpr{ pos: position{line: 123, col: 30, offset: 3293}, name: "Identifier", }, }, }, }, }, &actionExpr{ pos: position{line: 125, col: 5, offset: 3331}, run: (*parser).callonSelectorOrIndex7, expr: &labeledExpr{ pos: position{line: 125, col: 5, offset: 3331}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 125, col: 10, offset: 3336}, name: "IndexExpression", }, }, }, }, }, }, { name: "IndexExpression", displayName: "\"index\"", pos: position{line: 129, col: 1, offset: 3377}, expr: &choiceExpr{ pos: position{line: 129, col: 28, offset: 3404}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 129, col: 28, offset: 3404}, run: (*parser).callonIndexExpression2, expr: &seqExpr{ pos: position{line: 129, col: 28, offset: 3404}, exprs: []interface{}{ &litMatcher{ pos: position{line: 129, col: 28, offset: 3404}, val: "[", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 129, col: 32, offset: 3408}, expr: &ruleRefExpr{ pos: position{line: 129, col: 32, offset: 3408}, name: "_", }, }, &labeledExpr{ pos: position{line: 129, col: 35, offset: 3411}, label: "lit", expr: &ruleRefExpr{ pos: position{line: 129, col: 39, offset: 3415}, name: "StringLiteral", }, }, &zeroOrOneExpr{ pos: position{line: 129, col: 53, offset: 3429}, expr: &ruleRefExpr{ pos: position{line: 129, col: 53, offset: 3429}, name: "_", }, }, &litMatcher{ pos: position{line: 129, col: 56, offset: 3432}, val: "]", ignoreCase: false, }, }, }, }, &seqExpr{ pos: position{line: 131, col: 5, offset: 3461}, exprs: []interface{}{ &litMatcher{ pos: position{line: 131, col: 5, offset: 3461}, val: "[", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 131, col: 9, offset: 3465}, expr: &ruleRefExpr{ pos: position{line: 131, col: 9, offset: 3465}, name: "_", }, }, ¬Expr{ pos: position{line: 131, col: 12, offset: 3468}, expr: &ruleRefExpr{ pos: position{line: 131, col: 13, offset: 3469}, name: "StringLiteral", }, }, &andCodeExpr{ pos: position{line: 131, col: 27, offset: 3483}, run: (*parser).callonIndexExpression18, }, }, }, &seqExpr{ pos: position{line: 133, col: 5, offset: 3535}, exprs: []interface{}{ &litMatcher{ pos: position{line: 133, col: 5, offset: 3535}, val: "[", ignoreCase: false, }, &zeroOrOneExpr{ pos: position{line: 133, col: 9, offset: 3539}, expr: &ruleRefExpr{ pos: position{line: 133, col: 9, offset: 3539}, name: "_", }, }, &ruleRefExpr{ pos: position{line: 133, col: 12, offset: 3542}, name: "StringLiteral", }, &zeroOrOneExpr{ pos: position{line: 133, col: 26, offset: 3556}, expr: &ruleRefExpr{ pos: position{line: 133, col: 26, offset: 3556}, name: "_", }, }, ¬Expr{ pos: position{line: 133, col: 29, offset: 3559}, expr: &litMatcher{ pos: position{line: 133, col: 30, offset: 3560}, val: "]", ignoreCase: false, }, }, &andCodeExpr{ pos: position{line: 133, col: 34, offset: 3564}, run: (*parser).callonIndexExpression28, }, }, }, }, }, }, { name: "Value", displayName: "\"value\"", pos: position{line: 137, col: 1, offset: 3627}, expr: &choiceExpr{ pos: position{line: 137, col: 18, offset: 3644}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 137, col: 18, offset: 3644}, run: (*parser).callonValue2, expr: &labeledExpr{ pos: position{line: 137, col: 18, offset: 3644}, label: "selector", expr: &ruleRefExpr{ pos: position{line: 137, col: 27, offset: 3653}, name: "Selector", }, }, }, &actionExpr{ pos: position{line: 138, col: 10, offset: 3743}, run: (*parser).callonValue5, expr: &labeledExpr{ pos: position{line: 138, col: 10, offset: 3743}, label: "n", expr: &ruleRefExpr{ pos: position{line: 138, col: 12, offset: 3745}, name: "NumberLiteral", }, }, }, &actionExpr{ pos: position{line: 139, col: 10, offset: 3813}, run: (*parser).callonValue8, expr: &labeledExpr{ pos: position{line: 139, col: 10, offset: 3813}, label: "s", expr: &ruleRefExpr{ pos: position{line: 139, col: 12, offset: 3815}, name: "StringLiteral", }, }, }, }, }, }, { name: "NumberLiteral", displayName: "\"number\"", pos: position{line: 141, col: 1, offset: 3874}, expr: &choiceExpr{ pos: position{line: 141, col: 27, offset: 3900}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 141, col: 27, offset: 3900}, run: (*parser).callonNumberLiteral2, expr: &seqExpr{ pos: position{line: 141, col: 27, offset: 3900}, exprs: []interface{}{ &zeroOrOneExpr{ pos: position{line: 141, col: 27, offset: 3900}, expr: &litMatcher{ pos: position{line: 141, col: 27, offset: 3900}, val: "-", ignoreCase: false, }, }, &ruleRefExpr{ pos: position{line: 141, col: 32, offset: 3905}, name: "IntegerOrFloat", }, &andExpr{ pos: position{line: 141, col: 47, offset: 3920}, expr: &ruleRefExpr{ pos: position{line: 141, col: 48, offset: 3921}, name: "AfterNumbers", }, }, }, }, }, &seqExpr{ pos: position{line: 143, col: 5, offset: 3970}, exprs: []interface{}{ &zeroOrOneExpr{ pos: position{line: 143, col: 5, offset: 3970}, expr: &litMatcher{ pos: position{line: 143, col: 5, offset: 3970}, val: "-", ignoreCase: false, }, }, &ruleRefExpr{ pos: position{line: 143, col: 10, offset: 3975}, name: "IntegerOrFloat", }, ¬Expr{ pos: position{line: 143, col: 25, offset: 3990}, expr: &ruleRefExpr{ pos: position{line: 143, col: 26, offset: 3991}, name: "AfterNumbers", }, }, &andCodeExpr{ pos: position{line: 143, col: 39, offset: 4004}, run: (*parser).callonNumberLiteral15, }, }, }, }, }, }, { name: "AfterNumbers", pos: position{line: 147, col: 1, offset: 4064}, expr: &andExpr{ pos: position{line: 147, col: 17, offset: 4080}, expr: &choiceExpr{ pos: position{line: 147, col: 19, offset: 4082}, alternatives: []interface{}{ &ruleRefExpr{ pos: position{line: 147, col: 19, offset: 4082}, name: "_", }, &ruleRefExpr{ pos: position{line: 147, col: 23, offset: 4086}, name: "EOF", }, &litMatcher{ pos: position{line: 147, col: 29, offset: 4092}, val: ")", ignoreCase: false, }, }, }, }, }, { name: "IntegerOrFloat", pos: position{line: 149, col: 1, offset: 4098}, expr: &seqExpr{ pos: position{line: 149, col: 19, offset: 4116}, exprs: []interface{}{ &choiceExpr{ pos: position{line: 149, col: 20, offset: 4117}, alternatives: []interface{}{ &litMatcher{ pos: position{line: 149, col: 20, offset: 4117}, val: "0", ignoreCase: false, }, &seqExpr{ pos: position{line: 149, col: 26, offset: 4123}, exprs: []interface{}{ &charClassMatcher{ pos: position{line: 149, col: 26, offset: 4123}, val: "[1-9]", ranges: []rune{'1', '9'}, ignoreCase: false, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 149, col: 31, offset: 4128}, expr: &charClassMatcher{ pos: position{line: 149, col: 31, offset: 4128}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, &zeroOrOneExpr{ pos: position{line: 149, col: 39, offset: 4136}, expr: &seqExpr{ pos: position{line: 149, col: 40, offset: 4137}, exprs: []interface{}{ &litMatcher{ pos: position{line: 149, col: 40, offset: 4137}, val: ".", ignoreCase: false, }, &oneOrMoreExpr{ pos: position{line: 149, col: 44, offset: 4141}, expr: &charClassMatcher{ pos: position{line: 149, col: 44, offset: 4141}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, }, }, { name: "StringLiteral", displayName: "\"string\"", pos: position{line: 151, col: 1, offset: 4151}, expr: &choiceExpr{ pos: position{line: 151, col: 27, offset: 4177}, alternatives: []interface{}{ &actionExpr{ pos: position{line: 151, col: 27, offset: 4177}, run: (*parser).callonStringLiteral2, expr: &choiceExpr{ pos: position{line: 151, col: 28, offset: 4178}, alternatives: []interface{}{ &seqExpr{ pos: position{line: 151, col: 28, offset: 4178}, exprs: []interface{}{ &litMatcher{ pos: position{line: 151, col: 28, offset: 4178}, val: "`", ignoreCase: false, }, &zeroOrMoreExpr{ pos: position{line: 151, col: 32, offset: 4182}, expr: &ruleRefExpr{ pos: position{line: 151, col: 32, offset: 4182}, name: "RawStringChar", }, }, &litMatcher{ pos: position{line: 151, col: 47, offset: 4197}, val: "`", ignoreCase: false, }, }, }, &seqExpr{ pos: position{line: 151, col: 53, offset: 4203}, exprs: []interface{}{ &litMatcher{ pos: position{line: 151, col: 53, offset: 4203}, val: "\"", ignoreCase: false, }, &zeroOrMoreExpr{ pos: position{line: 151, col: 57, offset: 4207}, expr: &ruleRefExpr{ pos: position{line: 151, col: 57, offset: 4207}, name: "DoubleStringChar", }, }, &litMatcher{ pos: position{line: 151, col: 75, offset: 4225}, val: "\"", ignoreCase: false, }, }, }, }, }, }, &seqExpr{ pos: position{line: 153, col: 5, offset: 4277}, exprs: []interface{}{ &choiceExpr{ pos: position{line: 153, col: 6, offset: 4278}, alternatives: []interface{}{ &seqExpr{ pos: position{line: 153, col: 6, offset: 4278}, exprs: []interface{}{ &litMatcher{ pos: position{line: 153, col: 6, offset: 4278}, val: "`", ignoreCase: false, }, &zeroOrMoreExpr{ pos: position{line: 153, col: 10, offset: 4282}, expr: &ruleRefExpr{ pos: position{line: 153, col: 10, offset: 4282}, name: "RawStringChar", }, }, }, }, &seqExpr{ pos: position{line: 153, col: 27, offset: 4299}, exprs: []interface{}{ &litMatcher{ pos: position{line: 153, col: 27, offset: 4299}, val: "\"", ignoreCase: false, }, &zeroOrMoreExpr{ pos: position{line: 153, col: 31, offset: 4303}, expr: &ruleRefExpr{ pos: position{line: 153, col: 31, offset: 4303}, name: "DoubleStringChar", }, }, }, }, }, }, &ruleRefExpr{ pos: position{line: 153, col: 50, offset: 4322}, name: "EOF", }, &andCodeExpr{ pos: position{line: 153, col: 54, offset: 4326}, run: (*parser).callonStringLiteral25, }, }, }, }, }, }, { name: "RawStringChar", pos: position{line: 157, col: 1, offset: 4390}, expr: &seqExpr{ pos: position{line: 157, col: 18, offset: 4407}, exprs: []interface{}{ ¬Expr{ pos: position{line: 157, col: 18, offset: 4407}, expr: &litMatcher{ pos: position{line: 157, col: 19, offset: 4408}, val: "`", ignoreCase: false, }, }, &anyMatcher{ line: 157, col: 23, offset: 4412, }, }, }, }, { name: "DoubleStringChar", pos: position{line: 158, col: 1, offset: 4414}, expr: &seqExpr{ pos: position{line: 158, col: 21, offset: 4434}, exprs: []interface{}{ ¬Expr{ pos: position{line: 158, col: 21, offset: 4434}, expr: &litMatcher{ pos: position{line: 158, col: 22, offset: 4435}, val: "\"", ignoreCase: false, }, }, &anyMatcher{ line: 158, col: 26, offset: 4439, }, }, }, }, { name: "_", displayName: "\"whitespace\"", pos: position{line: 160, col: 1, offset: 4442}, expr: &oneOrMoreExpr{ pos: position{line: 160, col: 19, offset: 4460}, expr: &charClassMatcher{ pos: position{line: 160, col: 19, offset: 4460}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, }, { name: "EOF", pos: position{line: 162, col: 1, offset: 4472}, expr: ¬Expr{ pos: position{line: 162, col: 8, offset: 4479}, expr: &anyMatcher{ line: 162, col: 9, offset: 4480, }, }, }, }, } func (c *current) onInput2(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonInput2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onInput2(stack["expr"]) } func (c *current) onInput17(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonInput17() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onInput17(stack["expr"]) } func (c *current) onOrExpression2(left, right interface{}) (interface{}, error) { return &BinaryExpression{ Operator: BinaryOpOr, Left: left.(Expression), Right: right.(Expression), }, nil } func (p *parser) callonOrExpression2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrExpression2(stack["left"], stack["right"]) } func (c *current) onOrExpression11(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonOrExpression11() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrExpression11(stack["expr"]) } func (c *current) onAndExpression2(left, right interface{}) (interface{}, error) { return &BinaryExpression{ Operator: BinaryOpAnd, Left: left.(Expression), Right: right.(Expression), }, nil } func (p *parser) callonAndExpression2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAndExpression2(stack["left"], stack["right"]) } func (c *current) onAndExpression11(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonAndExpression11() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAndExpression11(stack["expr"]) } func (c *current) onNotExpression2(expr interface{}) (interface{}, error) { if unary, ok := expr.(*UnaryExpression); ok && unary.Operator == UnaryOpNot { // small optimization to get rid unnecessary levels of AST nodes // for things like: not not foo == 3 which is equivalent to foo == 3 return unary.Operand, nil } return &UnaryExpression{ Operator: UnaryOpNot, Operand: expr.(Expression), }, nil } func (p *parser) callonNotExpression2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onNotExpression2(stack["expr"]) } func (c *current) onNotExpression8(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonNotExpression8() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onNotExpression8(stack["expr"]) } func (c *current) onParenthesizedExpression2(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonParenthesizedExpression2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onParenthesizedExpression2(stack["expr"]) } func (c *current) onParenthesizedExpression12(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonParenthesizedExpression12() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onParenthesizedExpression12(stack["expr"]) } func (c *current) onParenthesizedExpression24() (bool, error) { return false, errors.New("Unmatched parentheses") } func (p *parser) callonParenthesizedExpression24() (bool, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onParenthesizedExpression24() } func (c *current) onMatchSelectorOpValue1(selector, operator, value interface{}) (interface{}, error) { return &MatchExpression{Selector: selector.(Selector), Operator: operator.(MatchOperator), Value: value.(*MatchValue)}, nil } func (p *parser) callonMatchSelectorOpValue1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchSelectorOpValue1(stack["selector"], stack["operator"], stack["value"]) } func (c *current) onMatchSelectorOp1(selector, operator interface{}) (interface{}, error) { return &MatchExpression{Selector: selector.(Selector), Operator: operator.(MatchOperator), Value: nil}, nil } func (p *parser) callonMatchSelectorOp1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchSelectorOp1(stack["selector"], stack["operator"]) } func (c *current) onMatchValueOpSelector2(value, operator, selector interface{}) (interface{}, error) { return &MatchExpression{Selector: selector.(Selector), Operator: operator.(MatchOperator), Value: value.(*MatchValue)}, nil } func (p *parser) callonMatchValueOpSelector2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchValueOpSelector2(stack["value"], stack["operator"], stack["selector"]) } func (c *current) onMatchValueOpSelector20(operator interface{}) (bool, error) { return false, errors.New("Invalid selector") } func (p *parser) callonMatchValueOpSelector20() (bool, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchValueOpSelector20(stack["operator"]) } func (c *current) onMatchEqual1() (interface{}, error) { return MatchEqual, nil } func (p *parser) callonMatchEqual1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchEqual1() } func (c *current) onMatchNotEqual1() (interface{}, error) { return MatchNotEqual, nil } func (p *parser) callonMatchNotEqual1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchNotEqual1() } func (c *current) onMatchIsEmpty1() (interface{}, error) { return MatchIsEmpty, nil } func (p *parser) callonMatchIsEmpty1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchIsEmpty1() } func (c *current) onMatchIsNotEmpty1() (interface{}, error) { return MatchIsNotEmpty, nil } func (p *parser) callonMatchIsNotEmpty1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchIsNotEmpty1() } func (c *current) onMatchIn1() (interface{}, error) { return MatchIn, nil } func (p *parser) callonMatchIn1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchIn1() } func (c *current) onMatchNotIn1() (interface{}, error) { return MatchNotIn, nil } func (p *parser) callonMatchNotIn1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchNotIn1() } func (c *current) onMatchContains1() (interface{}, error) { return MatchIn, nil } func (p *parser) callonMatchContains1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchContains1() } func (c *current) onMatchNotContains1() (interface{}, error) { return MatchNotIn, nil } func (p *parser) callonMatchNotContains1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchNotContains1() } func (c *current) onMatchMatches1() (interface{}, error) { return MatchMatches, nil } func (p *parser) callonMatchMatches1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchMatches1() } func (c *current) onMatchNotMatches1() (interface{}, error) { return MatchNotMatches, nil } func (p *parser) callonMatchNotMatches1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMatchNotMatches1() } func (c *current) onSelector1(first, rest interface{}) (interface{}, error) { sel := Selector{ first.(string), } if rest != nil { for _, v := range rest.([]interface{}) { sel = append(sel, v.(string)) } } return sel, nil } func (p *parser) callonSelector1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelector1(stack["first"], stack["rest"]) } func (c *current) onIdentifier1() (interface{}, error) { return string(c.text), nil } func (p *parser) callonIdentifier1() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIdentifier1() } func (c *current) onSelectorOrIndex2(ident interface{}) (interface{}, error) { return ident, nil } func (p *parser) callonSelectorOrIndex2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectorOrIndex2(stack["ident"]) } func (c *current) onSelectorOrIndex7(expr interface{}) (interface{}, error) { return expr, nil } func (p *parser) callonSelectorOrIndex7() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectorOrIndex7(stack["expr"]) } func (c *current) onIndexExpression2(lit interface{}) (interface{}, error) { return lit, nil } func (p *parser) callonIndexExpression2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIndexExpression2(stack["lit"]) } func (c *current) onIndexExpression18() (bool, error) { return false, errors.New("Invalid index") } func (p *parser) callonIndexExpression18() (bool, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIndexExpression18() } func (c *current) onIndexExpression28() (bool, error) { return false, errors.New("Unclosed index expression") } func (p *parser) callonIndexExpression28() (bool, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIndexExpression28() } func (c *current) onValue2(selector interface{}) (interface{}, error) { return &MatchValue{Raw: strings.Join(selector.(Selector), ".")}, nil } func (p *parser) callonValue2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue2(stack["selector"]) } func (c *current) onValue5(n interface{}) (interface{}, error) { return &MatchValue{Raw: n.(string)}, nil } func (p *parser) callonValue5() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue5(stack["n"]) } func (c *current) onValue8(s interface{}) (interface{}, error) { return &MatchValue{Raw: s.(string)}, nil } func (p *parser) callonValue8() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue8(stack["s"]) } func (c *current) onNumberLiteral2() (interface{}, error) { return string(c.text), nil } func (p *parser) callonNumberLiteral2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onNumberLiteral2() } func (c *current) onNumberLiteral15() (bool, error) { return false, errors.New("Invalid number literal") } func (p *parser) callonNumberLiteral15() (bool, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onNumberLiteral15() } func (c *current) onStringLiteral2() (interface{}, error) { return strconv.Unquote(string(c.text)) } func (p *parser) callonStringLiteral2() (interface{}, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onStringLiteral2() } func (c *current) onStringLiteral25() (bool, error) { return false, errors.New("Unterminated string literal") } func (p *parser) callonStringLiteral25() (bool, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onStringLiteral25() } 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 expresssions 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 interface{}) 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 interface{}, err error) { 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) (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 // 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]interface{} // 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 recoveryExpr struct { pos position expr interface{} recoverExpr interface{} failureLabel []string } type seqExpr struct { pos position exprs []interface{} } type throwExpr struct { pos position label string } 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 basicLatinChars [128]bool 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 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) } } type resultTuple struct { v interface{} b bool end savepoint } 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 } 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]interface{} // 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]interface{} } // 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] } // push a recovery expression with its labels to the recoveryStack func (p *parser) pushRecovery(labels []string, expr interface{}) { 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]interface{}, 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 } } 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 { 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.parseRule(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 fmt.Sprintf("%s %s %s", strings.Join(list[:len(list)-1], sep), lastSep, list[len(list)-1]) } } func (p *parser) parseRule(rule *rule) (interface{}, bool) { p.rstack = append(p.rstack, rule) p.pushV() val, ok := p.parseExpr(rule.expr) p.popV() p.rstack = p.rstack[:len(p.rstack)-1] return val, ok } func (p *parser) parseExpr(expr interface{}) (interface{}, bool) { p.ExprCnt++ if p.ExprCnt > p.maxExprCnt { panic(errMaxExprCnt) } var val interface{} 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) (interface{}, bool) { 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, []string{}) } val = actVal } return val, ok } func (p *parser) parseAndCodeExpr(and *andCodeExpr) (interface{}, bool) { ok, err := and.run(p) if err != nil { p.addErr(err) } return nil, ok } func (p *parser) parseAndExpr(and *andExpr) (interface{}, bool) { 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.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 } func (p *parser) parseCharClassMatcher(chr *charClassMatcher) (interface{}, 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) (interface{}, bool) { for altI, alt := range ch.alternatives { // dummy assignment to prevent compile error if optimized _ = altI 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) { 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) { ignoreCase := "" if lit.ignoreCase { ignoreCase = "i" } val := fmt.Sprintf("%q%s", lit.val, ignoreCase) 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, val) p.restore(start) return nil, false } p.read() } p.failAt(true, start.position, val) return p.sliceFrom(start), true } func (p *parser) parseNotCodeExpr(not *notCodeExpr) (interface{}, bool) { ok, err := not.run(p) if err != nil { p.addErr(err) } return nil, !ok } func (p *parser) parseNotExpr(not *notExpr) (interface{}, bool) { pt := p.pt p.pushV() p.maxFailInvertExpected = !p.maxFailInvertExpected _, ok := p.parseExpr(not.expr) p.maxFailInvertExpected = !p.maxFailInvertExpected p.popV() p.restore(pt) return nil, !ok } func (p *parser) parseOneOrMoreExpr(expr *oneOrMoreExpr) (interface{}, bool) { 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) parseRecoveryExpr(recover *recoveryExpr) (interface{}, bool) { p.pushRecovery(recover.failureLabel, recover.recoverExpr) val, ok := p.parseExpr(recover.expr) p.popRecovery() return val, ok } func (p *parser) parseRuleRefExpr(ref *ruleRefExpr) (interface{}, 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.parseRule(rule) } func (p *parser) parseSeqExpr(seq *seqExpr) (interface{}, bool) { vals := make([]interface{}, 0, len(seq.exprs)) 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) parseThrowExpr(expr *throwExpr) (interface{}, bool) { for i := len(p.recoveryStack) - 1; i >= 0; i-- { if recoverExpr, ok := p.recoveryStack[i][expr.label]; ok { if val, ok := p.parseExpr(recoverExpr); ok { return val, ok } } } return nil, false } func (p *parser) parseZeroOrMoreExpr(expr *zeroOrMoreExpr) (interface{}, bool) { 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) { p.pushV() val, _ := p.parseExpr(expr.expr) p.popV() // whether it matched or not, consider it a match return val, true }