// Code generated by pigeon; DO NOT EDIT. package parser import ( "bytes" "errors" "fmt" "io" "math" "os" "sort" "strconv" "strings" "unicode" "unicode/utf8" "go.elara.ws/salix/ast" ) func toAnySlice(v any) []any { if v == nil { return nil } return v.([]any) } func toNodeSlice(v any) []ast.Node { if v == nil { return nil } return v.([]ast.Node) } func getPos(c *current) ast.Position { return ast.Position{ Name: c.globalStore["name"].(string), Line: c.pos.line, Col: c.pos.col, } } func toExpr(c *current, first, rest any) ast.Node { restSlice := toAnySlice(rest) if len(restSlice) == 0 { return first.(ast.Node) } out := ast.Expr{First: first.(ast.Node), Position: getPos(c)} for _, restValue := range restSlice { valueSlice := toAnySlice(restValue) out.Rest = append(out.Rest, ast.Expr{ Operator: valueSlice[1].(ast.Operator), First: valueSlice[3].(ast.Node), Position: valueSlice[3].(ast.Node).Pos(), }) } return out } var g = &grammar{ rules: []*rule{ { name: "Root", pos: position{line: 71, col: 1, offset: 1729}, expr: &actionExpr{ pos: position{line: 71, col: 8, offset: 1736}, run: (*parser).callonRoot1, expr: &labeledExpr{ pos: position{line: 71, col: 8, offset: 1736}, label: "items", expr: &zeroOrMoreExpr{ pos: position{line: 71, col: 14, offset: 1742}, expr: &choiceExpr{ pos: position{line: 71, col: 15, offset: 1743}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 71, col: 15, offset: 1743}, name: "Tag", }, &ruleRefExpr{ pos: position{line: 71, col: 21, offset: 1749}, name: "ExprTag", }, &actionExpr{ pos: position{line: 89, col: 10, offset: 2183}, run: (*parser).callonRoot7, expr: &seqExpr{ pos: position{line: 89, col: 10, offset: 2183}, exprs: []any{ &litMatcher{ pos: position{line: 89, col: 10, offset: 2183}, val: "#!", ignoreCase: false, want: "\"#!\"", }, &labeledExpr{ pos: position{line: 89, col: 15, offset: 2188}, label: "name", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonRoot11, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, }, }, }, &actionExpr{ pos: position{line: 267, col: 8, offset: 6408}, run: (*parser).callonRoot16, expr: &seqExpr{ pos: position{line: 267, col: 8, offset: 6408}, exprs: []any{ &anyMatcher{ line: 267, col: 8, offset: 6408, }, &zeroOrMoreExpr{ pos: position{line: 267, col: 10, offset: 6410}, expr: &charClassMatcher{ pos: position{line: 267, col: 10, offset: 6410}, val: "[^#]", chars: []rune{'#'}, ignoreCase: false, inverted: true, }, }, }, }, }, }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "Tag", pos: position{line: 80, col: 1, offset: 1954}, expr: &actionExpr{ pos: position{line: 80, col: 7, offset: 1960}, run: (*parser).callonTag1, expr: &seqExpr{ pos: position{line: 80, col: 7, offset: 1960}, exprs: []any{ &litMatcher{ pos: position{line: 80, col: 7, offset: 1960}, val: "#", ignoreCase: false, want: "\"#\"", }, &labeledExpr{ pos: position{line: 80, col: 11, offset: 1964}, label: "name", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonTag5, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, &labeledExpr{ pos: position{line: 80, col: 22, offset: 1975}, label: "params", expr: &zeroOrOneExpr{ pos: position{line: 80, col: 29, offset: 1982}, expr: &ruleRefExpr{ pos: position{line: 80, col: 29, offset: 1982}, name: "ParamList", }, }, }, &labeledExpr{ pos: position{line: 80, col: 40, offset: 1993}, label: "body", expr: &zeroOrOneExpr{ pos: position{line: 80, col: 45, offset: 1998}, expr: &litMatcher{ pos: position{line: 80, col: 45, offset: 1998}, val: ":", ignoreCase: false, want: "\":\"", }, }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "ExprTag", pos: position{line: 96, col: 1, offset: 2303}, expr: &actionExpr{ pos: position{line: 96, col: 11, offset: 2313}, run: (*parser).callonExprTag1, expr: &seqExpr{ pos: position{line: 96, col: 11, offset: 2313}, exprs: []any{ &litMatcher{ pos: position{line: 96, col: 11, offset: 2313}, val: "#(", ignoreCase: false, want: "\"#(\"", }, &labeledExpr{ pos: position{line: 96, col: 16, offset: 2318}, label: "item", expr: &ruleRefExpr{ pos: position{line: 96, col: 21, offset: 2323}, name: "Expr", }, }, &litMatcher{ pos: position{line: 96, col: 26, offset: 2328}, val: ")", ignoreCase: false, want: "\")\"", }, }, }, }, leader: false, leftRecursive: false, }, { name: "Expr", pos: position{line: 103, col: 1, offset: 2436}, expr: &choiceExpr{ pos: position{line: 103, col: 8, offset: 2443}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 103, col: 8, offset: 2443}, name: "Ternary", }, &ruleRefExpr{ pos: position{line: 103, col: 18, offset: 2453}, name: "Assignment", }, &ruleRefExpr{ pos: position{line: 103, col: 31, offset: 2466}, name: "LogicalExpr", }, }, }, leader: false, leftRecursive: false, }, { name: "Assignable", pos: position{line: 104, col: 1, offset: 2478}, expr: &choiceExpr{ pos: position{line: 104, col: 14, offset: 2491}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 104, col: 14, offset: 2491}, name: "Ternary", }, &ruleRefExpr{ pos: position{line: 104, col: 24, offset: 2501}, name: "LogicalExpr", }, }, }, leader: true, leftRecursive: true, }, { name: "LogicalExpr", pos: position{line: 106, col: 1, offset: 2514}, expr: &actionExpr{ pos: position{line: 106, col: 15, offset: 2528}, run: (*parser).callonLogicalExpr1, expr: &seqExpr{ pos: position{line: 106, col: 15, offset: 2528}, exprs: []any{ &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 106, col: 17, offset: 2530}, label: "first", expr: &ruleRefExpr{ pos: position{line: 106, col: 23, offset: 2536}, name: "ComparisonExpr", }, }, &labeledExpr{ pos: position{line: 106, col: 38, offset: 2551}, label: "rest", expr: &zeroOrMoreExpr{ pos: position{line: 106, col: 43, offset: 2556}, expr: &seqExpr{ pos: position{line: 106, col: 44, offset: 2557}, exprs: []any{ &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &actionExpr{ pos: position{line: 246, col: 13, offset: 5974}, run: (*parser).callonLogicalExpr12, expr: &choiceExpr{ pos: position{line: 246, col: 14, offset: 5975}, alternatives: []any{ &litMatcher{ pos: position{line: 246, col: 14, offset: 5975}, val: "||", ignoreCase: false, want: "\"||\"", }, &litMatcher{ pos: position{line: 246, col: 21, offset: 5982}, val: "&&", ignoreCase: false, want: "\"&&\"", }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &ruleRefExpr{ pos: position{line: 106, col: 58, offset: 2571}, name: "ComparisonExpr", }, }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "ComparisonExpr", pos: position{line: 110, col: 1, offset: 2634}, expr: &actionExpr{ pos: position{line: 110, col: 18, offset: 2651}, run: (*parser).callonComparisonExpr1, expr: &seqExpr{ pos: position{line: 110, col: 18, offset: 2651}, exprs: []any{ &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 110, col: 20, offset: 2653}, label: "first", expr: &ruleRefExpr{ pos: position{line: 110, col: 26, offset: 2659}, name: "ArithmeticExpr", }, }, &labeledExpr{ pos: position{line: 110, col: 41, offset: 2674}, label: "rest", expr: &zeroOrMoreExpr{ pos: position{line: 110, col: 46, offset: 2679}, expr: &seqExpr{ pos: position{line: 110, col: 47, offset: 2680}, exprs: []any{ &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &actionExpr{ pos: position{line: 253, col: 16, offset: 6107}, run: (*parser).callonComparisonExpr12, expr: &choiceExpr{ pos: position{line: 253, col: 17, offset: 6108}, alternatives: []any{ &litMatcher{ pos: position{line: 253, col: 17, offset: 6108}, val: "==", ignoreCase: false, want: "\"==\"", }, &litMatcher{ pos: position{line: 253, col: 24, offset: 6115}, val: "<=", ignoreCase: false, want: "\"<=\"", }, &litMatcher{ pos: position{line: 253, col: 31, offset: 6122}, val: ">=", ignoreCase: false, want: "\">=\"", }, &charClassMatcher{ pos: position{line: 253, col: 38, offset: 6129}, val: "[<>]", chars: []rune{'<', '>'}, ignoreCase: false, inverted: false, }, &litMatcher{ pos: position{line: 253, col: 50, offset: 6141}, val: "in", ignoreCase: true, want: "\"in\"i", }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &ruleRefExpr{ pos: position{line: 110, col: 64, offset: 2697}, name: "ArithmeticExpr", }, }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "ArithmeticExpr", pos: position{line: 114, col: 1, offset: 2760}, expr: &actionExpr{ pos: position{line: 114, col: 18, offset: 2777}, run: (*parser).callonArithmeticExpr1, expr: &seqExpr{ pos: position{line: 114, col: 18, offset: 2777}, exprs: []any{ &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 114, col: 20, offset: 2779}, label: "first", expr: &ruleRefExpr{ pos: position{line: 114, col: 26, offset: 2785}, name: "Value", }, }, &labeledExpr{ pos: position{line: 114, col: 32, offset: 2791}, label: "rest", expr: &zeroOrMoreExpr{ pos: position{line: 114, col: 37, offset: 2796}, expr: &seqExpr{ pos: position{line: 114, col: 38, offset: 2797}, exprs: []any{ &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &actionExpr{ pos: position{line: 260, col: 16, offset: 6267}, run: (*parser).callonArithmeticExpr12, expr: &charClassMatcher{ pos: position{line: 260, col: 17, offset: 6268}, val: "[+-/*%]", chars: []rune{'+', '-', '/', '*', '%'}, ignoreCase: false, inverted: false, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &ruleRefExpr{ pos: position{line: 114, col: 55, offset: 2814}, name: "Value", }, }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "ParenExpr", pos: position{line: 118, col: 1, offset: 2868}, expr: &actionExpr{ pos: position{line: 118, col: 13, offset: 2880}, run: (*parser).callonParenExpr1, expr: &seqExpr{ pos: position{line: 118, col: 13, offset: 2880}, exprs: []any{ &litMatcher{ pos: position{line: 118, col: 13, offset: 2880}, val: "(", ignoreCase: false, want: "\"(\"", }, &labeledExpr{ pos: position{line: 118, col: 17, offset: 2884}, label: "expr", expr: &ruleRefExpr{ pos: position{line: 118, col: 22, offset: 2889}, name: "Expr", }, }, &litMatcher{ pos: position{line: 118, col: 27, offset: 2894}, val: ")", ignoreCase: false, want: "\")\"", }, }, }, }, leader: false, leftRecursive: false, }, { name: "ParamList", pos: position{line: 122, col: 1, offset: 2924}, expr: &actionExpr{ pos: position{line: 122, col: 13, offset: 2936}, run: (*parser).callonParamList1, expr: &seqExpr{ pos: position{line: 122, col: 13, offset: 2936}, exprs: []any{ &litMatcher{ pos: position{line: 122, col: 13, offset: 2936}, val: "(", ignoreCase: false, want: "\"(\"", }, &labeledExpr{ pos: position{line: 122, col: 17, offset: 2940}, label: "params", expr: &zeroOrOneExpr{ pos: position{line: 122, col: 24, offset: 2947}, expr: &seqExpr{ pos: position{line: 122, col: 25, offset: 2948}, exprs: []any{ &ruleRefExpr{ pos: position{line: 122, col: 25, offset: 2948}, name: "Expr", }, &zeroOrMoreExpr{ pos: position{line: 122, col: 30, offset: 2953}, expr: &seqExpr{ pos: position{line: 122, col: 32, offset: 2955}, exprs: []any{ &litMatcher{ pos: position{line: 122, col: 32, offset: 2955}, val: ",", ignoreCase: false, want: "\",\"", }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &ruleRefExpr{ pos: position{line: 122, col: 38, offset: 2961}, name: "Expr", }, }, }, }, }, }, }, }, &litMatcher{ pos: position{line: 122, col: 49, offset: 2972}, val: ")", ignoreCase: false, want: "\")\"", }, }, }, }, leader: false, leftRecursive: false, }, { name: "Value", pos: position{line: 136, col: 1, offset: 3334}, expr: &actionExpr{ pos: position{line: 136, col: 9, offset: 3342}, run: (*parser).callonValue1, expr: &seqExpr{ pos: position{line: 136, col: 9, offset: 3342}, exprs: []any{ &labeledExpr{ pos: position{line: 136, col: 9, offset: 3342}, label: "not", expr: &zeroOrOneExpr{ pos: position{line: 136, col: 13, offset: 3346}, expr: &litMatcher{ pos: position{line: 136, col: 13, offset: 3346}, val: "!", ignoreCase: false, want: "\"!\"", }, }, }, &labeledExpr{ pos: position{line: 136, col: 18, offset: 3351}, label: "node", expr: &choiceExpr{ pos: position{line: 136, col: 24, offset: 3357}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 136, col: 24, offset: 3357}, name: "MethodCall", }, &ruleRefExpr{ pos: position{line: 136, col: 37, offset: 3370}, name: "FieldAccess", }, &ruleRefExpr{ pos: position{line: 136, col: 51, offset: 3384}, name: "Index", }, &actionExpr{ pos: position{line: 222, col: 10, offset: 5477}, run: (*parser).callonValue11, expr: &seqExpr{ pos: position{line: 222, col: 10, offset: 5477}, exprs: []any{ &litMatcher{ pos: position{line: 222, col: 10, offset: 5477}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, &labeledExpr{ pos: position{line: 222, col: 14, offset: 5481}, label: "value", expr: &zeroOrMoreExpr{ pos: position{line: 222, col: 20, offset: 5487}, expr: &charClassMatcher{ pos: position{line: 222, col: 20, offset: 5487}, val: "[^\"]", chars: []rune{'"'}, ignoreCase: false, inverted: true, }, }, }, &litMatcher{ pos: position{line: 222, col: 26, offset: 5493}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, }, }, }, &actionExpr{ pos: position{line: 230, col: 13, offset: 5644}, run: (*parser).callonValue18, expr: &seqExpr{ pos: position{line: 230, col: 13, offset: 5644}, exprs: []any{ &litMatcher{ pos: position{line: 230, col: 13, offset: 5644}, val: "`", ignoreCase: false, want: "\"`\"", }, &labeledExpr{ pos: position{line: 230, col: 17, offset: 5648}, label: "value", expr: &zeroOrMoreExpr{ pos: position{line: 230, col: 23, offset: 5654}, expr: &charClassMatcher{ pos: position{line: 230, col: 23, offset: 5654}, val: "[^`]", chars: []rune{'`'}, ignoreCase: false, inverted: true, }, }, }, &litMatcher{ pos: position{line: 230, col: 29, offset: 5660}, val: "`", ignoreCase: false, want: "\"`\"", }, }, }, }, &actionExpr{ pos: position{line: 214, col: 9, offset: 5296}, run: (*parser).callonValue25, expr: &seqExpr{ pos: position{line: 214, col: 9, offset: 5296}, exprs: []any{ &zeroOrOneExpr{ pos: position{line: 214, col: 9, offset: 5296}, expr: &litMatcher{ pos: position{line: 214, col: 9, offset: 5296}, val: "-", ignoreCase: false, want: "\"-\"", }, }, &labeledExpr{ pos: position{line: 214, col: 14, offset: 5301}, label: "value", expr: &seqExpr{ pos: position{line: 214, col: 21, offset: 5308}, exprs: []any{ &oneOrMoreExpr{ pos: position{line: 214, col: 21, offset: 5308}, expr: &charClassMatcher{ pos: position{line: 214, col: 21, offset: 5308}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, &litMatcher{ pos: position{line: 214, col: 28, offset: 5315}, val: ".", ignoreCase: false, want: "\".\"", }, &oneOrMoreExpr{ pos: position{line: 214, col: 32, offset: 5319}, expr: &charClassMatcher{ pos: position{line: 214, col: 32, offset: 5319}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, }, }, &actionExpr{ pos: position{line: 206, col: 11, offset: 5085}, run: (*parser).callonValue36, expr: &seqExpr{ pos: position{line: 206, col: 11, offset: 5085}, exprs: []any{ &zeroOrOneExpr{ pos: position{line: 206, col: 11, offset: 5085}, expr: &litMatcher{ pos: position{line: 206, col: 11, offset: 5085}, val: "-", ignoreCase: false, want: "\"-\"", }, }, &choiceExpr{ pos: position{line: 206, col: 17, offset: 5091}, alternatives: []any{ &seqExpr{ pos: position{line: 206, col: 17, offset: 5091}, exprs: []any{ &litMatcher{ pos: position{line: 206, col: 17, offset: 5091}, val: "0x", ignoreCase: false, want: "\"0x\"", }, &oneOrMoreExpr{ pos: position{line: 206, col: 22, offset: 5096}, expr: &charClassMatcher{ pos: position{line: 206, col: 22, offset: 5096}, val: "[0-9a-f]i", ranges: []rune{'0', '9', 'a', 'f'}, ignoreCase: true, inverted: false, }, }, }, }, &seqExpr{ pos: position{line: 206, col: 35, offset: 5109}, exprs: []any{ &litMatcher{ pos: position{line: 206, col: 35, offset: 5109}, val: "0o", ignoreCase: false, want: "\"0o\"", }, &oneOrMoreExpr{ pos: position{line: 206, col: 40, offset: 5114}, expr: &charClassMatcher{ pos: position{line: 206, col: 40, offset: 5114}, val: "[0-7]", ranges: []rune{'0', '7'}, ignoreCase: false, inverted: false, }, }, }, }, &seqExpr{ pos: position{line: 206, col: 49, offset: 5123}, exprs: []any{ &litMatcher{ pos: position{line: 206, col: 49, offset: 5123}, val: "0b", ignoreCase: false, want: "\"0b\"", }, &oneOrMoreExpr{ pos: position{line: 206, col: 54, offset: 5128}, expr: &charClassMatcher{ pos: position{line: 206, col: 54, offset: 5128}, val: "[01]", chars: []rune{'0', '1'}, ignoreCase: false, inverted: false, }, }, }, }, &oneOrMoreExpr{ pos: position{line: 206, col: 62, offset: 5136}, expr: &charClassMatcher{ pos: position{line: 206, col: 62, offset: 5136}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, }, &actionExpr{ pos: position{line: 238, col: 8, offset: 5806}, run: (*parser).callonValue55, expr: &choiceExpr{ pos: position{line: 238, col: 9, offset: 5807}, alternatives: []any{ &litMatcher{ pos: position{line: 238, col: 9, offset: 5807}, val: "true", ignoreCase: true, want: "\"true\"i", }, &litMatcher{ pos: position{line: 238, col: 19, offset: 5817}, val: "false", ignoreCase: true, want: "\"false\"i", }, }, }, }, &ruleRefExpr{ pos: position{line: 136, col: 105, offset: 3438}, name: "FuncCall", }, &ruleRefExpr{ pos: position{line: 136, col: 116, offset: 3449}, name: "VariableOr", }, &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonValue61, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, &ruleRefExpr{ pos: position{line: 136, col: 137, offset: 3470}, name: "ParenExpr", }, }, }, }, }, }, }, leader: true, leftRecursive: true, }, { name: "VariableOr", pos: position{line: 143, col: 1, offset: 3576}, expr: &actionExpr{ pos: position{line: 143, col: 14, offset: 3589}, run: (*parser).callonVariableOr1, expr: &seqExpr{ pos: position{line: 143, col: 14, offset: 3589}, exprs: []any{ &labeledExpr{ pos: position{line: 143, col: 14, offset: 3589}, label: "variable", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonVariableOr4, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &litMatcher{ pos: position{line: 143, col: 31, offset: 3606}, val: "|", ignoreCase: false, want: "\"|\"", }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 143, col: 37, offset: 3612}, label: "or", expr: &ruleRefExpr{ pos: position{line: 143, col: 40, offset: 3615}, name: "Assignable", }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "Assignment", pos: position{line: 150, col: 1, offset: 3742}, expr: &actionExpr{ pos: position{line: 150, col: 14, offset: 3755}, run: (*parser).callonAssignment1, expr: &seqExpr{ pos: position{line: 150, col: 14, offset: 3755}, exprs: []any{ &labeledExpr{ pos: position{line: 150, col: 14, offset: 3755}, label: "name", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonAssignment4, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &litMatcher{ pos: position{line: 150, col: 27, offset: 3768}, val: "=", ignoreCase: false, want: "\"=\"", }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 150, col: 33, offset: 3774}, label: "value", expr: &ruleRefExpr{ pos: position{line: 150, col: 39, offset: 3780}, name: "Assignable", }, }, }, }, }, leader: false, leftRecursive: false, }, { name: "Ternary", pos: position{line: 158, col: 1, offset: 3935}, expr: &actionExpr{ pos: position{line: 158, col: 11, offset: 3945}, run: (*parser).callonTernary1, expr: &seqExpr{ pos: position{line: 158, col: 11, offset: 3945}, exprs: []any{ &labeledExpr{ pos: position{line: 158, col: 11, offset: 3945}, label: "cond", expr: &ruleRefExpr{ pos: position{line: 158, col: 16, offset: 3950}, name: "Assignable", }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &litMatcher{ pos: position{line: 158, col: 29, offset: 3963}, val: "?", ignoreCase: false, want: "\"?\"", }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 158, col: 35, offset: 3969}, label: "ifTrue", expr: &ruleRefExpr{ pos: position{line: 158, col: 42, offset: 3976}, name: "Value", }, }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &litMatcher{ pos: position{line: 158, col: 50, offset: 3984}, val: ":", ignoreCase: false, want: "\":\"", }, &zeroOrMoreExpr{ pos: position{line: 269, col: 18, offset: 6496}, expr: &charClassMatcher{ pos: position{line: 269, col: 18, offset: 6496}, val: "[ \\t\\r\\n]", chars: []rune{' ', '\t', '\r', '\n'}, ignoreCase: false, inverted: false, }, }, &labeledExpr{ pos: position{line: 158, col: 56, offset: 3990}, label: "elseVal", expr: &ruleRefExpr{ pos: position{line: 158, col: 64, offset: 3998}, name: "Value", }, }, }, }, }, leader: false, leftRecursive: true, }, { name: "MethodCall", pos: position{line: 166, col: 1, offset: 4157}, expr: &actionExpr{ pos: position{line: 166, col: 14, offset: 4170}, run: (*parser).callonMethodCall1, expr: &seqExpr{ pos: position{line: 166, col: 14, offset: 4170}, exprs: []any{ &labeledExpr{ pos: position{line: 166, col: 14, offset: 4170}, label: "value", expr: &ruleRefExpr{ pos: position{line: 166, col: 20, offset: 4176}, name: "Value", }, }, &litMatcher{ pos: position{line: 166, col: 26, offset: 4182}, val: ".", ignoreCase: false, want: "\".\"", }, &labeledExpr{ pos: position{line: 166, col: 30, offset: 4186}, label: "name", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonMethodCall7, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, &labeledExpr{ pos: position{line: 166, col: 41, offset: 4197}, label: "params", expr: &ruleRefExpr{ pos: position{line: 166, col: 48, offset: 4204}, name: "ParamList", }, }, }, }, }, leader: false, leftRecursive: true, }, { name: "Index", pos: position{line: 175, col: 1, offset: 4397}, expr: &actionExpr{ pos: position{line: 175, col: 9, offset: 4405}, run: (*parser).callonIndex1, expr: &seqExpr{ pos: position{line: 175, col: 9, offset: 4405}, exprs: []any{ &labeledExpr{ pos: position{line: 175, col: 9, offset: 4405}, label: "value", expr: &ruleRefExpr{ pos: position{line: 175, col: 15, offset: 4411}, name: "Value", }, }, &litMatcher{ pos: position{line: 175, col: 21, offset: 4417}, val: "[", ignoreCase: false, want: "\"[\"", }, &labeledExpr{ pos: position{line: 175, col: 25, offset: 4421}, label: "index", expr: &ruleRefExpr{ pos: position{line: 175, col: 31, offset: 4427}, name: "Value", }, }, &litMatcher{ pos: position{line: 175, col: 37, offset: 4433}, val: "]", ignoreCase: false, want: "\"]\"", }, }, }, }, leader: false, leftRecursive: true, }, { name: "FieldAccess", pos: position{line: 183, col: 1, offset: 4576}, expr: &actionExpr{ pos: position{line: 183, col: 15, offset: 4590}, run: (*parser).callonFieldAccess1, expr: &seqExpr{ pos: position{line: 183, col: 15, offset: 4590}, exprs: []any{ &labeledExpr{ pos: position{line: 183, col: 15, offset: 4590}, label: "value", expr: &ruleRefExpr{ pos: position{line: 183, col: 21, offset: 4596}, name: "Value", }, }, &litMatcher{ pos: position{line: 183, col: 27, offset: 4602}, val: ".", ignoreCase: false, want: "\".\"", }, &labeledExpr{ pos: position{line: 183, col: 31, offset: 4606}, label: "name", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonFieldAccess7, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, }, }, }, leader: false, leftRecursive: true, }, { name: "FuncCall", pos: position{line: 198, col: 1, offset: 4891}, expr: &actionExpr{ pos: position{line: 198, col: 12, offset: 4902}, run: (*parser).callonFuncCall1, expr: &seqExpr{ pos: position{line: 198, col: 12, offset: 4902}, exprs: []any{ &labeledExpr{ pos: position{line: 198, col: 12, offset: 4902}, label: "name", expr: &actionExpr{ pos: position{line: 191, col: 9, offset: 4770}, run: (*parser).callonFuncCall4, expr: &seqExpr{ pos: position{line: 191, col: 9, offset: 4770}, exprs: []any{ &charClassMatcher{ pos: position{line: 191, col: 9, offset: 4770}, val: "[a-z]i", ranges: []rune{'a', 'z'}, ignoreCase: true, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 191, col: 16, offset: 4777}, expr: &charClassMatcher{ pos: position{line: 191, col: 16, offset: 4777}, val: "[_a-z0-9]i", chars: []rune{'_'}, ranges: []rune{'a', 'z', '0', '9'}, ignoreCase: true, inverted: false, }, }, }, }, }, }, &labeledExpr{ pos: position{line: 198, col: 23, offset: 4913}, label: "params", expr: &ruleRefExpr{ pos: position{line: 198, col: 30, offset: 4920}, name: "ParamList", }, }, }, }, }, leader: false, leftRecursive: false, }, }, } func (c *current) onRoot11() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonRoot11() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onRoot11() } func (c *current) onRoot7(name any) (any, error) { return ast.EndTag{ Name: name.(ast.Ident), Position: getPos(c), }, nil } func (p *parser) callonRoot7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onRoot7(stack["name"]) } func (c *current) onRoot16() (any, error) { return ast.Text{Data: c.text, Position: getPos(c)}, nil } func (p *parser) callonRoot16() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onRoot16() } func (c *current) onRoot1(items any) (any, error) { itemSlice := toAnySlice(items) out := make([]ast.Node, len(itemSlice)) for i, item := range itemSlice { out[i] = item.(ast.Node) } return out, nil } func (p *parser) callonRoot1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onRoot1(stack["items"]) } func (c *current) onTag5() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonTag5() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onTag5() } func (c *current) onTag1(name, params, body any) (any, error) { return ast.Tag{ Name: name.(ast.Ident), Params: toNodeSlice(params), HasBody: body != nil, Position: getPos(c), }, nil } func (p *parser) callonTag1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onTag1(stack["name"], stack["params"], stack["body"]) } func (c *current) onExprTag1(item any) (any, error) { return ast.ExprTag{ Value: item.(ast.Node), Position: getPos(c), }, nil } func (p *parser) callonExprTag1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onExprTag1(stack["item"]) } func (c *current) onLogicalExpr12() (any, error) { return ast.Operator{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonLogicalExpr12() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onLogicalExpr12() } func (c *current) onLogicalExpr1(first, rest any) (any, error) { return toExpr(c, first, rest), nil } func (p *parser) callonLogicalExpr1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onLogicalExpr1(stack["first"], stack["rest"]) } func (c *current) onComparisonExpr12() (any, error) { return ast.Operator{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonComparisonExpr12() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onComparisonExpr12() } func (c *current) onComparisonExpr1(first, rest any) (any, error) { return toExpr(c, first, rest), nil } func (p *parser) callonComparisonExpr1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onComparisonExpr1(stack["first"], stack["rest"]) } func (c *current) onArithmeticExpr12() (any, error) { return ast.Operator{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonArithmeticExpr12() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onArithmeticExpr12() } func (c *current) onArithmeticExpr1(first, rest any) (any, error) { return toExpr(c, first, rest), nil } func (p *parser) callonArithmeticExpr1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onArithmeticExpr1(stack["first"], stack["rest"]) } func (c *current) onParenExpr1(expr any) (any, error) { return expr, nil } func (p *parser) callonParenExpr1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onParenExpr1(stack["expr"]) } func (c *current) onParamList1(params any) (any, error) { paramSlice := toAnySlice(params) if len(paramSlice) == 0 { return []ast.Node{}, nil } out := []ast.Node{paramSlice[0].(ast.Node)} restSlice := toAnySlice(paramSlice[1]) for _, value := range restSlice { valueSlice := toAnySlice(value) out = append(out, valueSlice[2].(ast.Node)) } return out, nil } func (p *parser) callonParamList1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onParamList1(stack["params"]) } func (c *current) onValue11(value any) (any, error) { s, err := strconv.Unquote(string(c.text)) return ast.String{ Value: s, Position: getPos(c), }, err } func (p *parser) callonValue11() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue11(stack["value"]) } func (c *current) onValue18(value any) (any, error) { s, err := strconv.Unquote(string(c.text)) return ast.String{ Value: s, Position: getPos(c), }, err } func (p *parser) callonValue18() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue18(stack["value"]) } func (c *current) onValue25(value any) (any, error) { f, err := strconv.ParseFloat(string(c.text), 64) return ast.Float{ Value: f, Position: getPos(c), }, err } func (p *parser) callonValue25() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue25(stack["value"]) } func (c *current) onValue36() (any, error) { i, err := strconv.ParseInt(string(c.text), 0, 64) return ast.Integer{ Value: i, Position: getPos(c), }, err } func (p *parser) callonValue36() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue36() } func (c *current) onValue55() (any, error) { b, err := strconv.ParseBool(string(c.text)) return ast.Bool{ Value: b, Position: getPos(c), }, err } func (p *parser) callonValue55() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue55() } func (c *current) onValue61() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonValue61() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue61() } func (c *current) onValue1(not, node any) (any, error) { return ast.Value{ Node: node.(ast.Node), Not: not != nil, }, nil } func (p *parser) callonValue1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onValue1(stack["not"], stack["node"]) } func (c *current) onVariableOr4() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonVariableOr4() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onVariableOr4() } func (c *current) onVariableOr1(variable, or any) (any, error) { return ast.VariableOr{ Variable: variable.(ast.Ident), Or: or.(ast.Node), }, nil } func (p *parser) callonVariableOr1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onVariableOr1(stack["variable"], stack["or"]) } func (c *current) onAssignment4() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonAssignment4() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAssignment4() } func (c *current) onAssignment1(name, value any) (any, error) { return ast.Assignment{ Name: name.(ast.Ident), Value: value.(ast.Node), Position: getPos(c), }, nil } func (p *parser) callonAssignment1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAssignment1(stack["name"], stack["value"]) } func (c *current) onTernary1(cond, ifTrue, elseVal any) (any, error) { return ast.Ternary{ Condition: cond.(ast.Node), IfTrue: ifTrue.(ast.Node), Else: elseVal.(ast.Node), }, nil } func (p *parser) callonTernary1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onTernary1(stack["cond"], stack["ifTrue"], stack["elseVal"]) } func (c *current) onMethodCall7() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonMethodCall7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMethodCall7() } func (c *current) onMethodCall1(value, name, params any) (any, error) { return ast.MethodCall{ Value: value.(ast.Node), Name: name.(ast.Ident), Params: toNodeSlice(params), Position: getPos(c), }, nil } func (p *parser) callonMethodCall1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onMethodCall1(stack["value"], stack["name"], stack["params"]) } func (c *current) onIndex1(value, index any) (any, error) { return ast.Index{ Value: value.(ast.Node), Index: index.(ast.Node), Position: getPos(c), }, nil } func (p *parser) callonIndex1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIndex1(stack["value"], stack["index"]) } func (c *current) onFieldAccess7() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonFieldAccess7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onFieldAccess7() } func (c *current) onFieldAccess1(value, name any) (any, error) { return ast.FieldAccess{ Value: value.(ast.Node), Name: name.(ast.Ident), Position: getPos(c), }, nil } func (p *parser) callonFieldAccess1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onFieldAccess1(stack["value"], stack["name"]) } func (c *current) onFuncCall4() (any, error) { return ast.Ident{ Value: string(c.text), Position: getPos(c), }, nil } func (p *parser) callonFuncCall4() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onFuncCall4() } func (c *current) onFuncCall1(name, params any) (any, error) { return ast.FuncCall{ Name: name.(ast.Ident), Params: toNodeSlice(params), Position: getPos(c), }, nil } func (p *parser) callonFuncCall1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onFuncCall1(stack["name"], stack["params"]) } 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 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) { 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) { 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... type grammar struct { pos position rules []*rule } type rule struct { pos position name string displayName string expr any leader bool leftRecursive bool } type choiceExpr struct { pos position alternatives []any } type actionExpr struct { pos position expr any run func(*parser) (any, error) } type recoveryExpr struct { pos position expr any recoverExpr any failureLabel []string } type seqExpr struct { pos position exprs []any } type throwExpr struct { pos position label string } type labeledExpr struct { pos position label string expr any } type expr struct { pos position expr any } type ( andExpr expr notExpr expr zeroOrOneExpr expr zeroOrMoreExpr expr 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 want string } 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 any 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 ruleWithExpsStack struct { rule *rule estack []any } type parser struct { filename string pt savepoint cur current data []byte errs *errList depth int recover bool // memoization table for the packrat algorithm: // map[offset in source] map[expression or rule] {value, match} memo map[int]map[any]resultTuple // rules table, maps the rule identifier to the rule node rules map[string]*rule // variables stack, map of label to value vstack []map[string]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) getMemoized(node any) (resultTuple, bool) { if len(p.memo) == 0 { return resultTuple{}, false } m := p.memo[p.pt.offset] if len(m) == 0 { return resultTuple{}, false } res, ok := m[node] return res, ok } func (p *parser) setMemoized(pt savepoint, node any, tuple resultTuple) { if p.memo == nil { p.memo = make(map[int]map[any]resultTuple) } m := p.memo[pt.offset] if m == nil { m = make(map[any]resultTuple) p.memo[pt.offset] = m } m[node] = tuple } func (p *parser) buildRulesTable(g *grammar) { p.rules = make(map[string]*rule, len(g.rules)) for _, r := range g.rules { p.rules[r.name] = r } } func (p *parser) parse(g *grammar) (val 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) parseRuleRecursiveLeader(rule *rule) (any, bool) { result, ok := p.getMemoized(rule) if ok { p.restore(result.end) return result.v, result.b } var ( depth = 0 startMark = p.pt lastResult = resultTuple{nil, false, startMark} lastErrors = *p.errs ) for { p.setMemoized(startMark, rule, lastResult) val, ok := p.parseRule(rule) endMark := p.pt if (!ok) || (endMark.offset <= lastResult.end.offset && depth != 0) { *p.errs = lastErrors break } lastResult = resultTuple{val, ok, endMark} lastErrors = *p.errs p.restore(startMark) depth++ } p.restore(lastResult.end) p.setMemoized(startMark, rule, lastResult) return lastResult.v, lastResult.b } func (p *parser) parseRuleRecursiveNoLeader(rule *rule) (any, bool) { return p.parseRule(rule) } func (p *parser) parseRuleWrap(rule *rule) (any, bool) { var ( val any ok bool ) if rule.leftRecursive { if rule.leader { val, ok = p.parseRuleRecursiveLeader(rule) } else { val, ok = p.parseRuleRecursiveNoLeader(rule) } } else { 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 } 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 } 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 }