// Code generated by pigeon; DO NOT EDIT. package nosql import ( "bytes" "errors" "fmt" "io" "math" "os" "sort" "strconv" "strings" "sync" "unicode" "unicode/utf8" "github.com/pikami/cosmium/parsers" ) func makeSelectStmt(columns, table, whereClause interface{}, count interface{}, orderList interface{}) (parsers.SelectStmt, error) { selectStmt := parsers.SelectStmt{ SelectItems: columns.([]parsers.SelectItem), Table: table.(parsers.Table), } if filters, ok := whereClause.(parsers.ComparisonExpression); ok { selectStmt.Filters = filters } else if filters, ok := whereClause.(parsers.LogicalExpression); ok { selectStmt.Filters = filters } else if filters, ok := whereClause.(parsers.Constant); ok { selectStmt.Filters = filters } if n, ok := count.(int); ok { selectStmt.Count = n } if orderExpressions, ok := orderList.([]parsers.OrderExpression); ok { selectStmt.OrderExpressions = orderExpressions } return selectStmt, nil } func makeSelectItem(name interface{}, path interface{}, selectItemType parsers.SelectItemType) (parsers.SelectItem, error) { ps := path.([]interface{}) paths := make([]string, 1) paths[0] = name.(string) for _, p := range ps { paths = append(paths, p.(string)) } return parsers.SelectItem{Path: paths, Type: selectItemType}, nil } func makeColumnList(column interface{}, other_columns interface{}) ([]parsers.SelectItem, error) { collsAsArray := other_columns.([]interface{}) columnList := make([]parsers.SelectItem, len(collsAsArray)+1) columnList[0] = column.(parsers.SelectItem) for i, v := range collsAsArray { if col, ok := v.(parsers.SelectItem); ok { columnList[i+1] = col } } return columnList, nil } func makeSelectArray(columns interface{}) (parsers.SelectItem, error) { return parsers.SelectItem{ SelectItems: columns.([]parsers.SelectItem), Type: parsers.SelectItemTypeArray, }, nil } func makeSelectObject(field interface{}, other_fields interface{}) (parsers.SelectItem, error) { fieldsAsArray := other_fields.([]interface{}) fieldsList := make([]parsers.SelectItem, len(fieldsAsArray)+1) fieldsList[0] = field.(parsers.SelectItem) for i, v := range fieldsAsArray { if col, ok := v.(parsers.SelectItem); ok { fieldsList[i+1] = col } } return parsers.SelectItem{ SelectItems: fieldsList, Type: parsers.SelectItemTypeObject, }, nil } func makeOrderByClause(ex1 interface{}, others interface{}) ([]parsers.OrderExpression, error) { othersArray := others.([]interface{}) orderList := make([]parsers.OrderExpression, len(othersArray)+1) orderList[0] = ex1.(parsers.OrderExpression) for i, v := range othersArray { if col, ok := v.(parsers.OrderExpression); ok { orderList[i+1] = col } } return orderList, nil } func makeOrderExpression(field interface{}, order interface{}) (parsers.OrderExpression, error) { value := parsers.OrderExpression{ SelectItem: field.(parsers.SelectItem), Direction: parsers.OrderDirectionAsc, } if orderValue, ok := order.(parsers.OrderDirection); ok { value.Direction = orderValue } return value, nil } func joinStrings(array []interface{}) string { var stringsArray []string for _, elem := range array { str, ok := elem.(string) if !ok { continue } stringsArray = append(stringsArray, str) } return strings.Join(stringsArray, "") } func combineExpressions(ex1 interface{}, exs interface{}, operation parsers.LogicalExpressionType) (interface{}, error) { if exs == nil || len(exs.([]interface{})) < 1 { return ex1, nil } return parsers.LogicalExpression{ Expressions: append([]interface{}{ex1}, exs.([]interface{})...), Operation: operation, }, nil } var g = &grammar{ rules: []*rule{ { name: "Input", pos: position{line: 134, col: 1, offset: 3673}, expr: &actionExpr{ pos: position{line: 134, col: 10, offset: 3682}, run: (*parser).callonInput1, expr: &labeledExpr{ pos: position{line: 134, col: 10, offset: 3682}, label: "selectStmt", expr: &ruleRefExpr{ pos: position{line: 134, col: 21, offset: 3693}, name: "SelectStmt", }, }, }, }, { name: "SelectStmt", pos: position{line: 138, col: 1, offset: 3736}, expr: &actionExpr{ pos: position{line: 138, col: 15, offset: 3750}, run: (*parser).callonSelectStmt1, expr: &seqExpr{ pos: position{line: 138, col: 15, offset: 3750}, exprs: []any{ &ruleRefExpr{ pos: position{line: 138, col: 15, offset: 3750}, name: "Select", }, &ruleRefExpr{ pos: position{line: 138, col: 22, offset: 3757}, name: "ws", }, &labeledExpr{ pos: position{line: 138, col: 25, offset: 3760}, label: "topClause", expr: &zeroOrOneExpr{ pos: position{line: 138, col: 35, offset: 3770}, expr: &ruleRefExpr{ pos: position{line: 138, col: 35, offset: 3770}, name: "TopClause", }, }, }, &ruleRefExpr{ pos: position{line: 138, col: 46, offset: 3781}, name: "ws", }, &labeledExpr{ pos: position{line: 138, col: 49, offset: 3784}, label: "columns", expr: &ruleRefExpr{ pos: position{line: 138, col: 57, offset: 3792}, name: "Selection", }, }, &ruleRefExpr{ pos: position{line: 138, col: 67, offset: 3802}, name: "ws", }, &ruleRefExpr{ pos: position{line: 139, col: 5, offset: 3809}, name: "From", }, &ruleRefExpr{ pos: position{line: 139, col: 10, offset: 3814}, name: "ws", }, &labeledExpr{ pos: position{line: 139, col: 13, offset: 3817}, label: "table", expr: &ruleRefExpr{ pos: position{line: 139, col: 19, offset: 3823}, name: "TableName", }, }, &ruleRefExpr{ pos: position{line: 139, col: 29, offset: 3833}, name: "ws", }, &labeledExpr{ pos: position{line: 140, col: 5, offset: 3840}, label: "whereClause", expr: &zeroOrOneExpr{ pos: position{line: 140, col: 17, offset: 3852}, expr: &actionExpr{ pos: position{line: 140, col: 18, offset: 3853}, run: (*parser).callonSelectStmt19, expr: &seqExpr{ pos: position{line: 140, col: 18, offset: 3853}, exprs: []any{ &ruleRefExpr{ pos: position{line: 140, col: 18, offset: 3853}, name: "ws", }, &ruleRefExpr{ pos: position{line: 140, col: 21, offset: 3856}, name: "Where", }, &ruleRefExpr{ pos: position{line: 140, col: 27, offset: 3862}, name: "ws", }, &labeledExpr{ pos: position{line: 140, col: 30, offset: 3865}, label: "condition", expr: &ruleRefExpr{ pos: position{line: 140, col: 40, offset: 3875}, name: "Condition", }, }, }, }, }, }, }, &labeledExpr{ pos: position{line: 141, col: 5, offset: 3917}, label: "orderByClause", expr: &zeroOrOneExpr{ pos: position{line: 141, col: 19, offset: 3931}, expr: &ruleRefExpr{ pos: position{line: 141, col: 19, offset: 3931}, name: "OrderByClause", }, }, }, }, }, }, }, { name: "TopClause", pos: position{line: 145, col: 1, offset: 4032}, expr: &actionExpr{ pos: position{line: 145, col: 14, offset: 4045}, run: (*parser).callonTopClause1, expr: &seqExpr{ pos: position{line: 145, col: 14, offset: 4045}, exprs: []any{ &ruleRefExpr{ pos: position{line: 145, col: 14, offset: 4045}, name: "Top", }, &ruleRefExpr{ pos: position{line: 145, col: 18, offset: 4049}, name: "ws", }, &labeledExpr{ pos: position{line: 145, col: 21, offset: 4052}, label: "count", expr: &ruleRefExpr{ pos: position{line: 145, col: 27, offset: 4058}, name: "Integer", }, }, }, }, }, }, { name: "Selection", pos: position{line: 149, col: 1, offset: 4093}, expr: &choiceExpr{ pos: position{line: 149, col: 14, offset: 4106}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 149, col: 14, offset: 4106}, name: "SelectValueSpec", }, &ruleRefExpr{ pos: position{line: 149, col: 32, offset: 4124}, name: "ColumnList", }, &ruleRefExpr{ pos: position{line: 149, col: 44, offset: 4136}, name: "SelectAsterisk", }, }, }, }, { name: "SelectAsterisk", pos: position{line: 151, col: 1, offset: 4152}, expr: &actionExpr{ pos: position{line: 151, col: 19, offset: 4170}, run: (*parser).callonSelectAsterisk1, expr: &litMatcher{ pos: position{line: 151, col: 19, offset: 4170}, val: "*", ignoreCase: false, want: "\"*\"", }, }, }, { name: "ColumnList", pos: position{line: 157, col: 1, offset: 4365}, expr: &actionExpr{ pos: position{line: 157, col: 15, offset: 4379}, run: (*parser).callonColumnList1, expr: &seqExpr{ pos: position{line: 157, col: 15, offset: 4379}, exprs: []any{ &labeledExpr{ pos: position{line: 157, col: 15, offset: 4379}, label: "column", expr: &ruleRefExpr{ pos: position{line: 157, col: 22, offset: 4386}, name: "SelectItem", }, }, &labeledExpr{ pos: position{line: 157, col: 33, offset: 4397}, label: "other_columns", expr: &zeroOrMoreExpr{ pos: position{line: 157, col: 47, offset: 4411}, expr: &actionExpr{ pos: position{line: 157, col: 48, offset: 4412}, run: (*parser).callonColumnList7, expr: &seqExpr{ pos: position{line: 157, col: 48, offset: 4412}, exprs: []any{ &ruleRefExpr{ pos: position{line: 157, col: 48, offset: 4412}, name: "ws", }, &litMatcher{ pos: position{line: 157, col: 51, offset: 4415}, val: ",", ignoreCase: false, want: "\",\"", }, &ruleRefExpr{ pos: position{line: 157, col: 55, offset: 4419}, name: "ws", }, &labeledExpr{ pos: position{line: 157, col: 58, offset: 4422}, label: "coll", expr: &ruleRefExpr{ pos: position{line: 157, col: 63, offset: 4427}, name: "SelectItem", }, }, }, }, }, }, }, }, }, }, }, { name: "SelectValueSpec", pos: position{line: 161, col: 1, offset: 4514}, expr: &actionExpr{ pos: position{line: 161, col: 20, offset: 4533}, run: (*parser).callonSelectValueSpec1, expr: &seqExpr{ pos: position{line: 161, col: 20, offset: 4533}, exprs: []any{ &litMatcher{ pos: position{line: 161, col: 20, offset: 4533}, val: "VALUE", ignoreCase: false, want: "\"VALUE\"", }, &ruleRefExpr{ pos: position{line: 161, col: 28, offset: 4541}, name: "ws", }, &labeledExpr{ pos: position{line: 161, col: 31, offset: 4544}, label: "column", expr: &ruleRefExpr{ pos: position{line: 161, col: 38, offset: 4551}, name: "SelectItem", }, }, }, }, }, }, { name: "TableName", pos: position{line: 167, col: 1, offset: 4705}, expr: &actionExpr{ pos: position{line: 167, col: 14, offset: 4718}, run: (*parser).callonTableName1, expr: &labeledExpr{ pos: position{line: 167, col: 14, offset: 4718}, label: "key", expr: &ruleRefExpr{ pos: position{line: 167, col: 18, offset: 4722}, name: "Identifier", }, }, }, }, { name: "SelectArray", pos: position{line: 171, col: 1, offset: 4789}, expr: &actionExpr{ pos: position{line: 171, col: 16, offset: 4804}, run: (*parser).callonSelectArray1, expr: &seqExpr{ pos: position{line: 171, col: 16, offset: 4804}, exprs: []any{ &litMatcher{ pos: position{line: 171, col: 16, offset: 4804}, val: "[", ignoreCase: false, want: "\"[\"", }, &ruleRefExpr{ pos: position{line: 171, col: 20, offset: 4808}, name: "ws", }, &labeledExpr{ pos: position{line: 171, col: 23, offset: 4811}, label: "columns", expr: &ruleRefExpr{ pos: position{line: 171, col: 31, offset: 4819}, name: "ColumnList", }, }, &ruleRefExpr{ pos: position{line: 171, col: 42, offset: 4830}, name: "ws", }, &litMatcher{ pos: position{line: 171, col: 45, offset: 4833}, val: "]", ignoreCase: false, want: "\"]\"", }, }, }, }, }, { name: "SelectObject", pos: position{line: 175, col: 1, offset: 4878}, expr: &actionExpr{ pos: position{line: 175, col: 17, offset: 4894}, run: (*parser).callonSelectObject1, expr: &seqExpr{ pos: position{line: 175, col: 17, offset: 4894}, exprs: []any{ &litMatcher{ pos: position{line: 175, col: 17, offset: 4894}, val: "{", ignoreCase: false, want: "\"{\"", }, &ruleRefExpr{ pos: position{line: 175, col: 21, offset: 4898}, name: "ws", }, &labeledExpr{ pos: position{line: 175, col: 24, offset: 4901}, label: "field", expr: &ruleRefExpr{ pos: position{line: 175, col: 30, offset: 4907}, name: "SelectObjectField", }, }, &ruleRefExpr{ pos: position{line: 175, col: 48, offset: 4925}, name: "ws", }, &labeledExpr{ pos: position{line: 175, col: 51, offset: 4928}, label: "other_fields", expr: &zeroOrMoreExpr{ pos: position{line: 175, col: 64, offset: 4941}, expr: &actionExpr{ pos: position{line: 175, col: 65, offset: 4942}, run: (*parser).callonSelectObject10, expr: &seqExpr{ pos: position{line: 175, col: 65, offset: 4942}, exprs: []any{ &ruleRefExpr{ pos: position{line: 175, col: 65, offset: 4942}, name: "ws", }, &litMatcher{ pos: position{line: 175, col: 68, offset: 4945}, val: ",", ignoreCase: false, want: "\",\"", }, &ruleRefExpr{ pos: position{line: 175, col: 72, offset: 4949}, name: "ws", }, &labeledExpr{ pos: position{line: 175, col: 75, offset: 4952}, label: "coll", expr: &ruleRefExpr{ pos: position{line: 175, col: 80, offset: 4957}, name: "SelectObjectField", }, }, }, }, }, }, }, &ruleRefExpr{ pos: position{line: 175, col: 120, offset: 4997}, name: "ws", }, &litMatcher{ pos: position{line: 175, col: 123, offset: 5000}, val: "}", ignoreCase: false, want: "\"}\"", }, }, }, }, }, { name: "SelectObjectField", pos: position{line: 179, col: 1, offset: 5058}, expr: &actionExpr{ pos: position{line: 179, col: 22, offset: 5079}, run: (*parser).callonSelectObjectField1, expr: &seqExpr{ pos: position{line: 179, col: 22, offset: 5079}, exprs: []any{ &labeledExpr{ pos: position{line: 179, col: 22, offset: 5079}, label: "name", expr: &choiceExpr{ pos: position{line: 179, col: 28, offset: 5085}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 179, col: 28, offset: 5085}, name: "Identifier", }, &actionExpr{ pos: position{line: 179, col: 41, offset: 5098}, run: (*parser).callonSelectObjectField6, expr: &seqExpr{ pos: position{line: 179, col: 41, offset: 5098}, exprs: []any{ &litMatcher{ pos: position{line: 179, col: 41, offset: 5098}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, &labeledExpr{ pos: position{line: 179, col: 46, offset: 5103}, label: "key", expr: &ruleRefExpr{ pos: position{line: 179, col: 50, offset: 5107}, name: "Identifier", }, }, &litMatcher{ pos: position{line: 179, col: 61, offset: 5118}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, }, }, }, }, }, }, &ruleRefExpr{ pos: position{line: 179, col: 87, offset: 5144}, name: "ws", }, &litMatcher{ pos: position{line: 179, col: 90, offset: 5147}, val: ":", ignoreCase: false, want: "\":\"", }, &ruleRefExpr{ pos: position{line: 179, col: 94, offset: 5151}, name: "ws", }, &labeledExpr{ pos: position{line: 179, col: 97, offset: 5154}, label: "selectItem", expr: &ruleRefExpr{ pos: position{line: 179, col: 108, offset: 5165}, name: "SelectItem", }, }, }, }, }, }, { name: "SelectProperty", pos: position{line: 185, col: 1, offset: 5271}, expr: &actionExpr{ pos: position{line: 185, col: 19, offset: 5289}, run: (*parser).callonSelectProperty1, expr: &seqExpr{ pos: position{line: 185, col: 19, offset: 5289}, exprs: []any{ &labeledExpr{ pos: position{line: 185, col: 19, offset: 5289}, label: "name", expr: &ruleRefExpr{ pos: position{line: 185, col: 24, offset: 5294}, name: "Identifier", }, }, &labeledExpr{ pos: position{line: 185, col: 35, offset: 5305}, label: "path", expr: &zeroOrMoreExpr{ pos: position{line: 185, col: 40, offset: 5310}, expr: &choiceExpr{ pos: position{line: 185, col: 41, offset: 5311}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 185, col: 41, offset: 5311}, name: "DotFieldAccess", }, &ruleRefExpr{ pos: position{line: 185, col: 58, offset: 5328}, name: "ArrayFieldAccess", }, }, }, }, }, }, }, }, }, { name: "SelectItem", pos: position{line: 189, col: 1, offset: 5419}, expr: &actionExpr{ pos: position{line: 189, col: 15, offset: 5433}, run: (*parser).callonSelectItem1, expr: &seqExpr{ pos: position{line: 189, col: 15, offset: 5433}, exprs: []any{ &labeledExpr{ pos: position{line: 189, col: 15, offset: 5433}, label: "selectItem", expr: &choiceExpr{ pos: position{line: 189, col: 27, offset: 5445}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 189, col: 27, offset: 5445}, name: "SelectArray", }, &ruleRefExpr{ pos: position{line: 189, col: 41, offset: 5459}, name: "SelectObject", }, &ruleRefExpr{ pos: position{line: 189, col: 56, offset: 5474}, name: "SelectProperty", }, }, }, }, &labeledExpr{ pos: position{line: 189, col: 72, offset: 5490}, label: "asClause", expr: &zeroOrOneExpr{ pos: position{line: 189, col: 81, offset: 5499}, expr: &ruleRefExpr{ pos: position{line: 189, col: 81, offset: 5499}, name: "AsClause", }, }, }, }, }, }, }, { name: "AsClause", pos: position{line: 197, col: 1, offset: 5651}, expr: &actionExpr{ pos: position{line: 197, col: 13, offset: 5663}, run: (*parser).callonAsClause1, expr: &seqExpr{ pos: position{line: 197, col: 13, offset: 5663}, exprs: []any{ &ruleRefExpr{ pos: position{line: 197, col: 13, offset: 5663}, name: "ws", }, &ruleRefExpr{ pos: position{line: 197, col: 16, offset: 5666}, name: "As", }, &ruleRefExpr{ pos: position{line: 197, col: 19, offset: 5669}, name: "ws", }, &labeledExpr{ pos: position{line: 197, col: 22, offset: 5672}, label: "alias", expr: &ruleRefExpr{ pos: position{line: 197, col: 28, offset: 5678}, name: "Identifier", }, }, }, }, }, }, { name: "DotFieldAccess", pos: position{line: 199, col: 1, offset: 5712}, expr: &actionExpr{ pos: position{line: 199, col: 19, offset: 5730}, run: (*parser).callonDotFieldAccess1, expr: &seqExpr{ pos: position{line: 199, col: 19, offset: 5730}, exprs: []any{ &litMatcher{ pos: position{line: 199, col: 19, offset: 5730}, val: ".", ignoreCase: false, want: "\".\"", }, &labeledExpr{ pos: position{line: 199, col: 23, offset: 5734}, label: "id", expr: &ruleRefExpr{ pos: position{line: 199, col: 26, offset: 5737}, name: "Identifier", }, }, }, }, }, }, { name: "ArrayFieldAccess", pos: position{line: 203, col: 1, offset: 5772}, expr: &actionExpr{ pos: position{line: 203, col: 21, offset: 5792}, run: (*parser).callonArrayFieldAccess1, expr: &seqExpr{ pos: position{line: 203, col: 21, offset: 5792}, exprs: []any{ &litMatcher{ pos: position{line: 203, col: 21, offset: 5792}, val: "[\"", ignoreCase: false, want: "\"[\\\"\"", }, &labeledExpr{ pos: position{line: 203, col: 27, offset: 5798}, label: "id", expr: &ruleRefExpr{ pos: position{line: 203, col: 30, offset: 5801}, name: "Identifier", }, }, &litMatcher{ pos: position{line: 203, col: 41, offset: 5812}, val: "\"]", ignoreCase: false, want: "\"\\\"]\"", }, }, }, }, }, { name: "Identifier", pos: position{line: 207, col: 1, offset: 5842}, expr: &actionExpr{ pos: position{line: 207, col: 15, offset: 5856}, run: (*parser).callonIdentifier1, expr: &seqExpr{ pos: position{line: 207, col: 15, offset: 5856}, exprs: []any{ &charClassMatcher{ pos: position{line: 207, col: 15, offset: 5856}, val: "[a-zA-Z_]", chars: []rune{'_'}, ranges: []rune{'a', 'z', 'A', 'Z'}, ignoreCase: false, inverted: false, }, &zeroOrMoreExpr{ pos: position{line: 207, col: 24, offset: 5865}, expr: &charClassMatcher{ pos: position{line: 207, col: 24, offset: 5865}, val: "[a-zA-Z0-9_]", chars: []rune{'_'}, ranges: []rune{'a', 'z', 'A', 'Z', '0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, { name: "Condition", pos: position{line: 211, col: 1, offset: 5915}, expr: &actionExpr{ pos: position{line: 211, col: 14, offset: 5928}, run: (*parser).callonCondition1, expr: &labeledExpr{ pos: position{line: 211, col: 14, offset: 5928}, label: "expression", expr: &ruleRefExpr{ pos: position{line: 211, col: 25, offset: 5939}, name: "OrExpression", }, }, }, }, { name: "OrExpression", pos: position{line: 215, col: 1, offset: 5984}, expr: &actionExpr{ pos: position{line: 215, col: 17, offset: 6000}, run: (*parser).callonOrExpression1, expr: &seqExpr{ pos: position{line: 215, col: 17, offset: 6000}, exprs: []any{ &labeledExpr{ pos: position{line: 215, col: 17, offset: 6000}, label: "ex1", expr: &ruleRefExpr{ pos: position{line: 215, col: 21, offset: 6004}, name: "AndExpression", }, }, &labeledExpr{ pos: position{line: 215, col: 35, offset: 6018}, label: "ex2", expr: &zeroOrMoreExpr{ pos: position{line: 215, col: 39, offset: 6022}, expr: &actionExpr{ pos: position{line: 215, col: 40, offset: 6023}, run: (*parser).callonOrExpression7, expr: &seqExpr{ pos: position{line: 215, col: 40, offset: 6023}, exprs: []any{ &ruleRefExpr{ pos: position{line: 215, col: 40, offset: 6023}, name: "ws", }, &ruleRefExpr{ pos: position{line: 215, col: 43, offset: 6026}, name: "Or", }, &ruleRefExpr{ pos: position{line: 215, col: 46, offset: 6029}, name: "ws", }, &labeledExpr{ pos: position{line: 215, col: 49, offset: 6032}, label: "ex", expr: &ruleRefExpr{ pos: position{line: 215, col: 52, offset: 6035}, name: "AndExpression", }, }, }, }, }, }, }, }, }, }, }, { name: "AndExpression", pos: position{line: 219, col: 1, offset: 6148}, expr: &actionExpr{ pos: position{line: 219, col: 18, offset: 6165}, run: (*parser).callonAndExpression1, expr: &seqExpr{ pos: position{line: 219, col: 18, offset: 6165}, exprs: []any{ &labeledExpr{ pos: position{line: 219, col: 18, offset: 6165}, label: "ex1", expr: &ruleRefExpr{ pos: position{line: 219, col: 22, offset: 6169}, name: "ComparisonExpression", }, }, &labeledExpr{ pos: position{line: 219, col: 43, offset: 6190}, label: "ex2", expr: &zeroOrMoreExpr{ pos: position{line: 219, col: 47, offset: 6194}, expr: &actionExpr{ pos: position{line: 219, col: 48, offset: 6195}, run: (*parser).callonAndExpression7, expr: &seqExpr{ pos: position{line: 219, col: 48, offset: 6195}, exprs: []any{ &ruleRefExpr{ pos: position{line: 219, col: 48, offset: 6195}, name: "ws", }, &ruleRefExpr{ pos: position{line: 219, col: 51, offset: 6198}, name: "And", }, &ruleRefExpr{ pos: position{line: 219, col: 55, offset: 6202}, name: "ws", }, &labeledExpr{ pos: position{line: 219, col: 58, offset: 6205}, label: "ex", expr: &ruleRefExpr{ pos: position{line: 219, col: 61, offset: 6208}, name: "ComparisonExpression", }, }, }, }, }, }, }, }, }, }, }, { name: "ComparisonExpression", pos: position{line: 223, col: 1, offset: 6329}, expr: &choiceExpr{ pos: position{line: 223, col: 25, offset: 6353}, alternatives: []any{ &actionExpr{ pos: position{line: 223, col: 25, offset: 6353}, run: (*parser).callonComparisonExpression2, expr: &seqExpr{ pos: position{line: 223, col: 25, offset: 6353}, exprs: []any{ &litMatcher{ pos: position{line: 223, col: 25, offset: 6353}, val: "(", ignoreCase: false, want: "\"(\"", }, &ruleRefExpr{ pos: position{line: 223, col: 29, offset: 6357}, name: "ws", }, &labeledExpr{ pos: position{line: 223, col: 32, offset: 6360}, label: "ex", expr: &ruleRefExpr{ pos: position{line: 223, col: 35, offset: 6363}, name: "OrExpression", }, }, &ruleRefExpr{ pos: position{line: 223, col: 48, offset: 6376}, name: "ws", }, &litMatcher{ pos: position{line: 223, col: 51, offset: 6379}, val: ")", ignoreCase: false, want: "\")\"", }, }, }, }, &actionExpr{ pos: position{line: 224, col: 7, offset: 6408}, run: (*parser).callonComparisonExpression10, expr: &seqExpr{ pos: position{line: 224, col: 7, offset: 6408}, exprs: []any{ &labeledExpr{ pos: position{line: 224, col: 7, offset: 6408}, label: "left", expr: &choiceExpr{ pos: position{line: 224, col: 13, offset: 6414}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 224, col: 13, offset: 6414}, name: "Literal", }, &ruleRefExpr{ pos: position{line: 224, col: 23, offset: 6424}, name: "SelectItem", }, }, }, }, &ruleRefExpr{ pos: position{line: 224, col: 35, offset: 6436}, name: "ws", }, &labeledExpr{ pos: position{line: 224, col: 38, offset: 6439}, label: "op", expr: &ruleRefExpr{ pos: position{line: 224, col: 41, offset: 6442}, name: "ComparisonOperator", }, }, &ruleRefExpr{ pos: position{line: 224, col: 60, offset: 6461}, name: "ws", }, &labeledExpr{ pos: position{line: 224, col: 63, offset: 6464}, label: "right", expr: &choiceExpr{ pos: position{line: 224, col: 70, offset: 6471}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 224, col: 70, offset: 6471}, name: "Literal", }, &ruleRefExpr{ pos: position{line: 224, col: 80, offset: 6481}, name: "SelectItem", }, }, }, }, }, }, }, &actionExpr{ pos: position{line: 226, col: 5, offset: 6598}, run: (*parser).callonComparisonExpression24, expr: &labeledExpr{ pos: position{line: 226, col: 5, offset: 6598}, label: "ex", expr: &ruleRefExpr{ pos: position{line: 226, col: 8, offset: 6601}, name: "BooleanLiteral", }, }, }, }, }, }, { name: "OrderByClause", pos: position{line: 228, col: 1, offset: 6636}, expr: &actionExpr{ pos: position{line: 228, col: 18, offset: 6653}, run: (*parser).callonOrderByClause1, expr: &seqExpr{ pos: position{line: 228, col: 18, offset: 6653}, exprs: []any{ &ruleRefExpr{ pos: position{line: 228, col: 18, offset: 6653}, name: "OrderBy", }, &ruleRefExpr{ pos: position{line: 228, col: 26, offset: 6661}, name: "ws", }, &labeledExpr{ pos: position{line: 228, col: 29, offset: 6664}, label: "ex1", expr: &ruleRefExpr{ pos: position{line: 228, col: 33, offset: 6668}, name: "OrderExpression", }, }, &labeledExpr{ pos: position{line: 228, col: 49, offset: 6684}, label: "others", expr: &zeroOrMoreExpr{ pos: position{line: 228, col: 56, offset: 6691}, expr: &actionExpr{ pos: position{line: 228, col: 57, offset: 6692}, run: (*parser).callonOrderByClause9, expr: &seqExpr{ pos: position{line: 228, col: 57, offset: 6692}, exprs: []any{ &ruleRefExpr{ pos: position{line: 228, col: 57, offset: 6692}, name: "ws", }, &litMatcher{ pos: position{line: 228, col: 60, offset: 6695}, val: ",", ignoreCase: false, want: "\",\"", }, &ruleRefExpr{ pos: position{line: 228, col: 64, offset: 6699}, name: "ws", }, &labeledExpr{ pos: position{line: 228, col: 67, offset: 6702}, label: "ex", expr: &ruleRefExpr{ pos: position{line: 228, col: 70, offset: 6705}, name: "OrderExpression", }, }, }, }, }, }, }, }, }, }, }, { name: "OrderExpression", pos: position{line: 232, col: 1, offset: 6789}, expr: &actionExpr{ pos: position{line: 232, col: 20, offset: 6808}, run: (*parser).callonOrderExpression1, expr: &seqExpr{ pos: position{line: 232, col: 20, offset: 6808}, exprs: []any{ &labeledExpr{ pos: position{line: 232, col: 20, offset: 6808}, label: "field", expr: &ruleRefExpr{ pos: position{line: 232, col: 26, offset: 6814}, name: "SelectProperty", }, }, &ruleRefExpr{ pos: position{line: 232, col: 41, offset: 6829}, name: "ws", }, &labeledExpr{ pos: position{line: 232, col: 44, offset: 6832}, label: "order", expr: &zeroOrOneExpr{ pos: position{line: 232, col: 50, offset: 6838}, expr: &ruleRefExpr{ pos: position{line: 232, col: 50, offset: 6838}, name: "OrderDirection", }, }, }, }, }, }, }, { name: "OrderDirection", pos: position{line: 236, col: 1, offset: 6904}, expr: &actionExpr{ pos: position{line: 236, col: 19, offset: 6922}, run: (*parser).callonOrderDirection1, expr: &choiceExpr{ pos: position{line: 236, col: 20, offset: 6923}, alternatives: []any{ &litMatcher{ pos: position{line: 236, col: 20, offset: 6923}, val: "ASC", ignoreCase: false, want: "\"ASC\"", }, &litMatcher{ pos: position{line: 236, col: 28, offset: 6931}, val: "asc", ignoreCase: false, want: "\"asc\"", }, &litMatcher{ pos: position{line: 236, col: 36, offset: 6939}, val: "DESC", ignoreCase: false, want: "\"DESC\"", }, &litMatcher{ pos: position{line: 236, col: 45, offset: 6948}, val: "desc", ignoreCase: false, want: "\"desc\"", }, }, }, }, }, { name: "Select", pos: position{line: 244, col: 1, offset: 7094}, expr: &choiceExpr{ pos: position{line: 244, col: 12, offset: 7105}, alternatives: []any{ &litMatcher{ pos: position{line: 244, col: 12, offset: 7105}, val: "select", ignoreCase: false, want: "\"select\"", }, &litMatcher{ pos: position{line: 244, col: 23, offset: 7116}, val: "SELECT", ignoreCase: false, want: "\"SELECT\"", }, }, }, }, { name: "Top", pos: position{line: 246, col: 1, offset: 7127}, expr: &choiceExpr{ pos: position{line: 246, col: 9, offset: 7135}, alternatives: []any{ &litMatcher{ pos: position{line: 246, col: 9, offset: 7135}, val: "top", ignoreCase: false, want: "\"top\"", }, &litMatcher{ pos: position{line: 246, col: 17, offset: 7143}, val: "TOP", ignoreCase: false, want: "\"TOP\"", }, }, }, }, { name: "As", pos: position{line: 248, col: 1, offset: 7151}, expr: &choiceExpr{ pos: position{line: 248, col: 8, offset: 7158}, alternatives: []any{ &litMatcher{ pos: position{line: 248, col: 8, offset: 7158}, val: "as", ignoreCase: false, want: "\"as\"", }, &litMatcher{ pos: position{line: 248, col: 15, offset: 7165}, val: "AS", ignoreCase: false, want: "\"AS\"", }, }, }, }, { name: "From", pos: position{line: 250, col: 1, offset: 7172}, expr: &choiceExpr{ pos: position{line: 250, col: 10, offset: 7181}, alternatives: []any{ &litMatcher{ pos: position{line: 250, col: 10, offset: 7181}, val: "from", ignoreCase: false, want: "\"from\"", }, &litMatcher{ pos: position{line: 250, col: 19, offset: 7190}, val: "FROM", ignoreCase: false, want: "\"FROM\"", }, }, }, }, { name: "Where", pos: position{line: 252, col: 1, offset: 7199}, expr: &choiceExpr{ pos: position{line: 252, col: 11, offset: 7209}, alternatives: []any{ &litMatcher{ pos: position{line: 252, col: 11, offset: 7209}, val: "where", ignoreCase: false, want: "\"where\"", }, &litMatcher{ pos: position{line: 252, col: 21, offset: 7219}, val: "WHERE", ignoreCase: false, want: "\"WHERE\"", }, }, }, }, { name: "And", pos: position{line: 254, col: 1, offset: 7229}, expr: &choiceExpr{ pos: position{line: 254, col: 9, offset: 7237}, alternatives: []any{ &litMatcher{ pos: position{line: 254, col: 9, offset: 7237}, val: "and", ignoreCase: false, want: "\"and\"", }, &litMatcher{ pos: position{line: 254, col: 17, offset: 7245}, val: "AND", ignoreCase: false, want: "\"AND\"", }, }, }, }, { name: "Or", pos: position{line: 256, col: 1, offset: 7253}, expr: &choiceExpr{ pos: position{line: 256, col: 8, offset: 7260}, alternatives: []any{ &litMatcher{ pos: position{line: 256, col: 8, offset: 7260}, val: "or", ignoreCase: false, want: "\"or\"", }, &litMatcher{ pos: position{line: 256, col: 15, offset: 7267}, val: "OR", ignoreCase: false, want: "\"OR\"", }, }, }, }, { name: "OrderBy", pos: position{line: 258, col: 1, offset: 7274}, expr: &seqExpr{ pos: position{line: 258, col: 12, offset: 7285}, exprs: []any{ &choiceExpr{ pos: position{line: 258, col: 13, offset: 7286}, alternatives: []any{ &litMatcher{ pos: position{line: 258, col: 13, offset: 7286}, val: "order", ignoreCase: false, want: "\"order\"", }, &litMatcher{ pos: position{line: 258, col: 23, offset: 7296}, val: "ORDER", ignoreCase: false, want: "\"ORDER\"", }, }, }, &ruleRefExpr{ pos: position{line: 258, col: 32, offset: 7305}, name: "ws", }, &choiceExpr{ pos: position{line: 258, col: 36, offset: 7309}, alternatives: []any{ &litMatcher{ pos: position{line: 258, col: 36, offset: 7309}, val: "by", ignoreCase: false, want: "\"by\"", }, &litMatcher{ pos: position{line: 258, col: 43, offset: 7316}, val: "BY", ignoreCase: false, want: "\"BY\"", }, }, }, }, }, }, { name: "ComparisonOperator", pos: position{line: 260, col: 1, offset: 7323}, expr: &choiceExpr{ pos: position{line: 260, col: 23, offset: 7345}, alternatives: []any{ &litMatcher{ pos: position{line: 260, col: 23, offset: 7345}, val: "=", ignoreCase: false, want: "\"=\"", }, &litMatcher{ pos: position{line: 260, col: 29, offset: 7351}, val: "!=", ignoreCase: false, want: "\"!=\"", }, &litMatcher{ pos: position{line: 260, col: 36, offset: 7358}, val: "<", ignoreCase: false, want: "\"<\"", }, &litMatcher{ pos: position{line: 260, col: 42, offset: 7364}, val: "<=", ignoreCase: false, want: "\"<=\"", }, &litMatcher{ pos: position{line: 260, col: 49, offset: 7371}, val: ">", ignoreCase: false, want: "\">\"", }, &actionExpr{ pos: position{line: 260, col: 55, offset: 7377}, run: (*parser).callonComparisonOperator7, expr: &litMatcher{ pos: position{line: 260, col: 55, offset: 7377}, val: ">=", ignoreCase: false, want: "\">=\"", }, }, }, }, }, { name: "Literal", pos: position{line: 264, col: 1, offset: 7418}, expr: &choiceExpr{ pos: position{line: 264, col: 12, offset: 7429}, alternatives: []any{ &ruleRefExpr{ pos: position{line: 264, col: 12, offset: 7429}, name: "FloatLiteral", }, &ruleRefExpr{ pos: position{line: 264, col: 27, offset: 7444}, name: "IntegerLiteral", }, &ruleRefExpr{ pos: position{line: 264, col: 44, offset: 7461}, name: "StringLiteral", }, &ruleRefExpr{ pos: position{line: 264, col: 60, offset: 7477}, name: "BooleanLiteral", }, &ruleRefExpr{ pos: position{line: 264, col: 77, offset: 7494}, name: "ParameterConstant", }, &ruleRefExpr{ pos: position{line: 264, col: 97, offset: 7514}, name: "NullConstant", }, }, }, }, { name: "ParameterConstant", pos: position{line: 266, col: 1, offset: 7528}, expr: &actionExpr{ pos: position{line: 266, col: 22, offset: 7549}, run: (*parser).callonParameterConstant1, expr: &seqExpr{ pos: position{line: 266, col: 22, offset: 7549}, exprs: []any{ &litMatcher{ pos: position{line: 266, col: 22, offset: 7549}, val: "@", ignoreCase: false, want: "\"@\"", }, &ruleRefExpr{ pos: position{line: 266, col: 26, offset: 7553}, name: "Identifier", }, }, }, }, }, { name: "NullConstant", pos: position{line: 269, col: 1, offset: 7669}, expr: &actionExpr{ pos: position{line: 269, col: 17, offset: 7685}, run: (*parser).callonNullConstant1, expr: &litMatcher{ pos: position{line: 269, col: 17, offset: 7685}, val: "null", ignoreCase: false, want: "\"null\"", }, }, }, { name: "IntegerLiteral", pos: position{line: 273, col: 1, offset: 7742}, expr: &actionExpr{ pos: position{line: 273, col: 19, offset: 7760}, run: (*parser).callonIntegerLiteral1, expr: &labeledExpr{ pos: position{line: 273, col: 19, offset: 7760}, label: "number", expr: &ruleRefExpr{ pos: position{line: 273, col: 26, offset: 7767}, name: "Integer", }, }, }, }, { name: "StringLiteral", pos: position{line: 276, col: 1, offset: 7868}, expr: &actionExpr{ pos: position{line: 276, col: 18, offset: 7885}, run: (*parser).callonStringLiteral1, expr: &seqExpr{ pos: position{line: 276, col: 18, offset: 7885}, exprs: []any{ &litMatcher{ pos: position{line: 276, col: 18, offset: 7885}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, &labeledExpr{ pos: position{line: 276, col: 23, offset: 7890}, label: "chars", expr: &zeroOrMoreExpr{ pos: position{line: 276, col: 29, offset: 7896}, expr: &ruleRefExpr{ pos: position{line: 276, col: 29, offset: 7896}, name: "StringCharacter", }, }, }, &litMatcher{ pos: position{line: 276, col: 46, offset: 7913}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, }, }, }, }, { name: "FloatLiteral", pos: position{line: 279, col: 1, offset: 8031}, expr: &actionExpr{ pos: position{line: 279, col: 17, offset: 8047}, run: (*parser).callonFloatLiteral1, expr: &seqExpr{ pos: position{line: 279, col: 17, offset: 8047}, exprs: []any{ &oneOrMoreExpr{ pos: position{line: 279, col: 17, offset: 8047}, expr: &charClassMatcher{ pos: position{line: 279, col: 17, offset: 8047}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, &litMatcher{ pos: position{line: 279, col: 23, offset: 8053}, val: ".", ignoreCase: false, want: "\".\"", }, &oneOrMoreExpr{ pos: position{line: 279, col: 26, offset: 8056}, expr: &charClassMatcher{ pos: position{line: 279, col: 26, offset: 8056}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, }, }, { name: "BooleanLiteral", pos: position{line: 283, col: 1, offset: 8212}, expr: &actionExpr{ pos: position{line: 283, col: 19, offset: 8230}, run: (*parser).callonBooleanLiteral1, expr: &choiceExpr{ pos: position{line: 283, col: 20, offset: 8231}, alternatives: []any{ &litMatcher{ pos: position{line: 283, col: 20, offset: 8231}, val: "true", ignoreCase: false, want: "\"true\"", }, &litMatcher{ pos: position{line: 283, col: 29, offset: 8240}, val: "false", ignoreCase: false, want: "\"false\"", }, }, }, }, }, { name: "Integer", pos: position{line: 288, col: 1, offset: 8394}, expr: &actionExpr{ pos: position{line: 288, col: 12, offset: 8405}, run: (*parser).callonInteger1, expr: &oneOrMoreExpr{ pos: position{line: 288, col: 12, offset: 8405}, expr: &charClassMatcher{ pos: position{line: 288, col: 12, offset: 8405}, val: "[0-9]", ranges: []rune{'0', '9'}, ignoreCase: false, inverted: false, }, }, }, }, { name: "StringCharacter", pos: position{line: 292, col: 1, offset: 8457}, expr: &choiceExpr{ pos: position{line: 292, col: 20, offset: 8476}, alternatives: []any{ &actionExpr{ pos: position{line: 292, col: 20, offset: 8476}, run: (*parser).callonStringCharacter2, expr: &seqExpr{ pos: position{line: 292, col: 20, offset: 8476}, exprs: []any{ ¬Expr{ pos: position{line: 292, col: 20, offset: 8476}, expr: &choiceExpr{ pos: position{line: 292, col: 22, offset: 8478}, alternatives: []any{ &litMatcher{ pos: position{line: 292, col: 22, offset: 8478}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, &litMatcher{ pos: position{line: 292, col: 28, offset: 8484}, val: "\\", ignoreCase: false, want: "\"\\\\\"", }, }, }, }, &anyMatcher{ line: 292, col: 34, offset: 8490, }, }, }, }, &actionExpr{ pos: position{line: 293, col: 5, offset: 8527}, run: (*parser).callonStringCharacter9, expr: &seqExpr{ pos: position{line: 293, col: 5, offset: 8527}, exprs: []any{ &litMatcher{ pos: position{line: 293, col: 5, offset: 8527}, val: "\\", ignoreCase: false, want: "\"\\\\\"", }, &labeledExpr{ pos: position{line: 293, col: 10, offset: 8532}, label: "seq", expr: &ruleRefExpr{ pos: position{line: 293, col: 14, offset: 8536}, name: "EscapeSequenceCharacter", }, }, }, }, }, }, }, }, { name: "EscapeSequenceCharacter", pos: position{line: 295, col: 1, offset: 8581}, expr: &labeledExpr{ pos: position{line: 295, col: 28, offset: 8608}, label: "char", expr: &ruleRefExpr{ pos: position{line: 295, col: 33, offset: 8613}, name: "EscapeCharacter", }, }, }, { name: "EscapeCharacter", pos: position{line: 297, col: 1, offset: 8630}, expr: &choiceExpr{ pos: position{line: 297, col: 20, offset: 8649}, alternatives: []any{ &litMatcher{ pos: position{line: 297, col: 20, offset: 8649}, val: "'", ignoreCase: false, want: "\"'\"", }, &litMatcher{ pos: position{line: 298, col: 5, offset: 8657}, val: "\"", ignoreCase: false, want: "\"\\\"\"", }, &litMatcher{ pos: position{line: 299, col: 5, offset: 8665}, val: "\\", ignoreCase: false, want: "\"\\\\\"", }, &actionExpr{ pos: position{line: 300, col: 5, offset: 8674}, run: (*parser).callonEscapeCharacter5, expr: &litMatcher{ pos: position{line: 300, col: 5, offset: 8674}, val: "b", ignoreCase: false, want: "\"b\"", }, }, &actionExpr{ pos: position{line: 301, col: 5, offset: 8703}, run: (*parser).callonEscapeCharacter7, expr: &litMatcher{ pos: position{line: 301, col: 5, offset: 8703}, val: "f", ignoreCase: false, want: "\"f\"", }, }, &actionExpr{ pos: position{line: 302, col: 5, offset: 8732}, run: (*parser).callonEscapeCharacter9, expr: &litMatcher{ pos: position{line: 302, col: 5, offset: 8732}, val: "n", ignoreCase: false, want: "\"n\"", }, }, &actionExpr{ pos: position{line: 303, col: 5, offset: 8761}, run: (*parser).callonEscapeCharacter11, expr: &litMatcher{ pos: position{line: 303, col: 5, offset: 8761}, val: "r", ignoreCase: false, want: "\"r\"", }, }, &actionExpr{ pos: position{line: 304, col: 5, offset: 8790}, run: (*parser).callonEscapeCharacter13, expr: &litMatcher{ pos: position{line: 304, col: 5, offset: 8790}, val: "t", ignoreCase: false, want: "\"t\"", }, }, }, }, }, { name: "non_escape_character", pos: position{line: 306, col: 1, offset: 8816}, expr: &actionExpr{ pos: position{line: 306, col: 25, offset: 8840}, run: (*parser).callonnon_escape_character1, expr: &seqExpr{ pos: position{line: 306, col: 25, offset: 8840}, exprs: []any{ ¬Expr{ pos: position{line: 306, col: 25, offset: 8840}, expr: &ruleRefExpr{ pos: position{line: 306, col: 27, offset: 8842}, name: "escape_character", }, }, &labeledExpr{ pos: position{line: 306, col: 45, offset: 8860}, label: "char", expr: &anyMatcher{ line: 306, col: 50, offset: 8865, }, }, }, }, }, }, { name: "ws", pos: position{line: 309, col: 1, offset: 8904}, expr: &zeroOrMoreExpr{ pos: position{line: 309, col: 7, offset: 8910}, expr: &charClassMatcher{ pos: position{line: 309, col: 7, offset: 8910}, val: "[ \\t\\n\\r]", chars: []rune{' ', '\t', '\n', '\r'}, ignoreCase: false, inverted: false, }, }, }, { name: "EOF", pos: position{line: 311, col: 1, offset: 8922}, expr: ¬Expr{ pos: position{line: 311, col: 8, offset: 8929}, expr: &anyMatcher{ line: 311, col: 9, offset: 8930, }, }, }, }, } func (c *current) onInput1(selectStmt any) (any, error) { return selectStmt, nil } func (p *parser) callonInput1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onInput1(stack["selectStmt"]) } func (c *current) onSelectStmt19(condition any) (any, error) { return condition, nil } func (p *parser) callonSelectStmt19() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectStmt19(stack["condition"]) } func (c *current) onSelectStmt1(topClause, columns, table, whereClause, orderByClause any) (any, error) { return makeSelectStmt(columns, table, whereClause, topClause, orderByClause) } func (p *parser) callonSelectStmt1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectStmt1(stack["topClause"], stack["columns"], stack["table"], stack["whereClause"], stack["orderByClause"]) } func (c *current) onTopClause1(count any) (any, error) { return count, nil } func (p *parser) callonTopClause1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onTopClause1(stack["count"]) } func (c *current) onSelectAsterisk1() (any, error) { selectItem, _ := makeSelectItem("c", make([]interface{}, 0), parsers.SelectItemTypeField) selectItem.IsTopLevel = true return makeColumnList(selectItem, make([]interface{}, 0)) } func (p *parser) callonSelectAsterisk1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectAsterisk1() } func (c *current) onColumnList7(coll any) (any, error) { return coll, nil } func (p *parser) callonColumnList7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onColumnList7(stack["coll"]) } func (c *current) onColumnList1(column, other_columns any) (any, error) { return makeColumnList(column, other_columns) } func (p *parser) callonColumnList1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onColumnList1(stack["column"], stack["other_columns"]) } func (c *current) onSelectValueSpec1(column any) (any, error) { selectItem := column.(parsers.SelectItem) selectItem.IsTopLevel = true return makeColumnList(selectItem, make([]interface{}, 0)) } func (p *parser) callonSelectValueSpec1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectValueSpec1(stack["column"]) } func (c *current) onTableName1(key any) (any, error) { return parsers.Table{Value: key.(string)}, nil } func (p *parser) callonTableName1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onTableName1(stack["key"]) } func (c *current) onSelectArray1(columns any) (any, error) { return makeSelectArray(columns) } func (p *parser) callonSelectArray1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectArray1(stack["columns"]) } func (c *current) onSelectObject10(coll any) (any, error) { return coll, nil } func (p *parser) callonSelectObject10() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectObject10(stack["coll"]) } func (c *current) onSelectObject1(field, other_fields any) (any, error) { return makeSelectObject(field, other_fields) } func (p *parser) callonSelectObject1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectObject1(stack["field"], stack["other_fields"]) } func (c *current) onSelectObjectField6(key any) (any, error) { return key, nil } func (p *parser) callonSelectObjectField6() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectObjectField6(stack["key"]) } func (c *current) onSelectObjectField1(name, selectItem any) (any, error) { item := selectItem.(parsers.SelectItem) item.Alias = name.(string) return item, nil } func (p *parser) callonSelectObjectField1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectObjectField1(stack["name"], stack["selectItem"]) } func (c *current) onSelectProperty1(name, path any) (any, error) { return makeSelectItem(name, path, parsers.SelectItemTypeField) } func (p *parser) callonSelectProperty1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectProperty1(stack["name"], stack["path"]) } func (c *current) onSelectItem1(selectItem, asClause any) (any, error) { item := selectItem.(parsers.SelectItem) if aliasValue, ok := asClause.(string); ok { item.Alias = aliasValue } return item, nil } func (p *parser) callonSelectItem1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onSelectItem1(stack["selectItem"], stack["asClause"]) } func (c *current) onAsClause1(alias any) (any, error) { return alias, nil } func (p *parser) callonAsClause1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAsClause1(stack["alias"]) } func (c *current) onDotFieldAccess1(id any) (any, error) { return id, nil } func (p *parser) callonDotFieldAccess1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onDotFieldAccess1(stack["id"]) } func (c *current) onArrayFieldAccess1(id any) (any, error) { return id, nil } func (p *parser) callonArrayFieldAccess1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onArrayFieldAccess1(stack["id"]) } func (c *current) onIdentifier1() (any, error) { return string(c.text), nil } func (p *parser) callonIdentifier1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIdentifier1() } func (c *current) onCondition1(expression any) (any, error) { return expression, nil } func (p *parser) callonCondition1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onCondition1(stack["expression"]) } func (c *current) onOrExpression7(ex any) (any, error) { return ex, nil } func (p *parser) callonOrExpression7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrExpression7(stack["ex"]) } func (c *current) onOrExpression1(ex1, ex2 any) (any, error) { return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeOr) } func (p *parser) callonOrExpression1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrExpression1(stack["ex1"], stack["ex2"]) } func (c *current) onAndExpression7(ex any) (any, error) { return ex, nil } func (p *parser) callonAndExpression7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAndExpression7(stack["ex"]) } func (c *current) onAndExpression1(ex1, ex2 any) (any, error) { return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeAnd) } func (p *parser) callonAndExpression1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onAndExpression1(stack["ex1"], stack["ex2"]) } func (c *current) onComparisonExpression2(ex any) (any, error) { return ex, nil } func (p *parser) callonComparisonExpression2() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onComparisonExpression2(stack["ex"]) } func (c *current) onComparisonExpression10(left, op, right any) (any, error) { return parsers.ComparisonExpression{Left: left, Right: right, Operation: string(op.([]uint8))}, nil } func (p *parser) callonComparisonExpression10() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onComparisonExpression10(stack["left"], stack["op"], stack["right"]) } func (c *current) onComparisonExpression24(ex any) (any, error) { return ex, nil } func (p *parser) callonComparisonExpression24() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onComparisonExpression24(stack["ex"]) } func (c *current) onOrderByClause9(ex any) (any, error) { return ex, nil } func (p *parser) callonOrderByClause9() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrderByClause9(stack["ex"]) } func (c *current) onOrderByClause1(ex1, others any) (any, error) { return makeOrderByClause(ex1, others) } func (p *parser) callonOrderByClause1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrderByClause1(stack["ex1"], stack["others"]) } func (c *current) onOrderExpression1(field, order any) (any, error) { return makeOrderExpression(field, order) } func (p *parser) callonOrderExpression1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrderExpression1(stack["field"], stack["order"]) } func (c *current) onOrderDirection1() (any, error) { switch string(c.text) { case "DESC", "desc": return parsers.OrderDirectionDesc, nil } return parsers.OrderDirectionAsc, nil } func (p *parser) callonOrderDirection1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onOrderDirection1() } func (c *current) onComparisonOperator7() (any, error) { return string(c.text), nil } func (p *parser) callonComparisonOperator7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onComparisonOperator7() } func (c *current) onParameterConstant1() (any, error) { return parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: string(c.text)}, nil } func (p *parser) callonParameterConstant1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onParameterConstant1() } func (c *current) onNullConstant1() (any, error) { return parsers.Constant{Value: nil}, nil } func (p *parser) callonNullConstant1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onNullConstant1() } func (c *current) onIntegerLiteral1(number any) (any, error) { return parsers.Constant{Type: parsers.ConstantTypeInteger, Value: number.(int)}, nil } func (p *parser) callonIntegerLiteral1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onIntegerLiteral1(stack["number"]) } func (c *current) onStringLiteral1(chars any) (any, error) { return parsers.Constant{Type: parsers.ConstantTypeString, Value: joinStrings(chars.([]interface{}))}, nil } func (p *parser) callonStringLiteral1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onStringLiteral1(stack["chars"]) } func (c *current) onFloatLiteral1() (any, error) { floatValue, _ := strconv.ParseFloat(string(c.text), 64) return parsers.Constant{Type: parsers.ConstantTypeFloat, Value: floatValue}, nil } func (p *parser) callonFloatLiteral1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onFloatLiteral1() } func (c *current) onBooleanLiteral1() (any, error) { boolValue, _ := strconv.ParseBool(string(c.text)) return parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: boolValue}, nil } func (p *parser) callonBooleanLiteral1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onBooleanLiteral1() } func (c *current) onInteger1() (any, error) { return strconv.Atoi(string(c.text)) } func (p *parser) callonInteger1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onInteger1() } func (c *current) onStringCharacter2() (any, error) { return string(c.text), nil } func (p *parser) callonStringCharacter2() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onStringCharacter2() } func (c *current) onStringCharacter9(seq any) (any, error) { return seq, nil } func (p *parser) callonStringCharacter9() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onStringCharacter9(stack["seq"]) } func (c *current) onEscapeCharacter5() (any, error) { return "\b", nil } func (p *parser) callonEscapeCharacter5() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onEscapeCharacter5() } func (c *current) onEscapeCharacter7() (any, error) { return "\f", nil } func (p *parser) callonEscapeCharacter7() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onEscapeCharacter7() } func (c *current) onEscapeCharacter9() (any, error) { return "\n", nil } func (p *parser) callonEscapeCharacter9() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onEscapeCharacter9() } func (c *current) onEscapeCharacter11() (any, error) { return "\r", nil } func (p *parser) callonEscapeCharacter11() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onEscapeCharacter11() } func (c *current) onEscapeCharacter13() (any, error) { return "\t", nil } func (p *parser) callonEscapeCharacter13() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onEscapeCharacter13() } func (c *current) onnon_escape_character1(char any) (any, error) { return string(c.text), nil } func (p *parser) callonnon_escape_character1() (any, error) { stack := p.vstack[len(p.vstack)-1] _ = stack return p.cur.onnon_escape_character1(stack["char"]) } var ( // errNoRule is returned when the grammar to parse has no rule. errNoRule = errors.New("grammar has no rule") // errInvalidEntrypoint is returned when the specified entrypoint rule // does not exit. errInvalidEntrypoint = errors.New("invalid entrypoint") // errInvalidEncoding is returned when the source is not properly // utf8-encoded. errInvalidEncoding = errors.New("invalid encoding") // errMaxExprCnt is used to signal that the maximum number of // expressions have been parsed. errMaxExprCnt = errors.New("max number of expressions parsed") ) // Option is a function that can set an option on the parser. It returns // the previous setting as an Option. type Option func(*parser) Option // MaxExpressions creates an Option to stop parsing after the provided // number of expressions have been parsed, if the value is 0 then the parser will // parse for as many steps as needed (possibly an infinite number). // // The default for maxExprCnt is 0. func MaxExpressions(maxExprCnt uint64) Option { return func(p *parser) Option { oldMaxExprCnt := p.maxExprCnt p.maxExprCnt = maxExprCnt return MaxExpressions(oldMaxExprCnt) } } // Entrypoint creates an Option to set the rule name to use as entrypoint. // The rule name must have been specified in the -alternate-entrypoints // if generating the parser with the -optimize-grammar flag, otherwise // it may have been optimized out. Passing an empty string sets the // entrypoint to the first rule in the grammar. // // The default is to start parsing at the first rule in the grammar. func Entrypoint(ruleName string) Option { return func(p *parser) Option { oldEntrypoint := p.entrypoint p.entrypoint = ruleName if ruleName == "" { p.entrypoint = g.rules[0].name } return Entrypoint(oldEntrypoint) } } // Statistics adds a user provided Stats struct to the parser to allow // the user to process the results after the parsing has finished. // Also the key for the "no match" counter is set. // // Example usage: // // input := "input" // stats := Stats{} // _, err := Parse("input-file", []byte(input), Statistics(&stats, "no match")) // if err != nil { // log.Panicln(err) // } // b, err := json.MarshalIndent(stats.ChoiceAltCnt, "", " ") // if err != nil { // log.Panicln(err) // } // fmt.Println(string(b)) func Statistics(stats *Stats, choiceNoMatch string) Option { return func(p *parser) Option { oldStats := p.Stats p.Stats = stats oldChoiceNoMatch := p.choiceNoMatch p.choiceNoMatch = choiceNoMatch if p.Stats.ChoiceAltCnt == nil { p.Stats.ChoiceAltCnt = make(map[string]map[string]int) } return Statistics(oldStats, oldChoiceNoMatch) } } // Debug creates an Option to set the debug flag to b. When set to true, // debugging information is printed to stdout while parsing. // // The default is false. func Debug(b bool) Option { return func(p *parser) Option { old := p.debug p.debug = b return Debug(old) } } // Memoize creates an Option to set the memoize flag to b. When set to true, // the parser will cache all results so each expression is evaluated only // once. This guarantees linear parsing time even for pathological cases, // at the expense of more memory and slower times for typical cases. // // The default is false. func Memoize(b bool) Option { return func(p *parser) Option { old := p.memoize p.memoize = b return Memoize(old) } } // 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) } } // InitState creates an Option to set a key to a certain value in // the global "state" store. func InitState(key string, value any) Option { return func(p *parser) Option { old := p.cur.state[key] p.cur.state[key] = value return InitState(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 // state is a store for arbitrary key,value pairs that the user wants to be // tied to the backtracking of the parser. // This is always rolled back if a parsing rule fails. state storeDict // 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 } 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 stateCodeExpr struct { pos position run func(*parser) error } 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{ state: make(storeDict), 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 parser struct { filename string pt savepoint cur current data []byte errs *errList depth int recover bool debug bool memoize 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) print(prefix, s string) string { if !p.debug { return s } fmt.Printf("%s %d:%d:%d: %s [%#U]\n", prefix, p.pt.line, p.pt.col, p.pt.offset, s, p.pt.rn) return s } func (p *parser) printIndent(mark string, s string) string { return p.print(strings.Repeat(" ", p.depth)+mark, s) } func (p *parser) in(s string) string { res := p.printIndent(">", s) p.depth++ return res } func (p *parser) out(s string) string { p.depth-- return p.printIndent("<", s) } 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 p.debug { defer p.out(p.in("restore")) } if pt.offset == p.pt.offset { return } p.pt = pt } // Cloner is implemented by any value that has a Clone method, which returns a // copy of the value. This is mainly used for types which are not passed by // value (e.g map, slice, chan) or structs that contain such types. // // This is used in conjunction with the global state feature to create proper // copies of the state to allow the parser to properly restore the state in // the case of backtracking. type Cloner interface { Clone() any } var statePool = &sync.Pool{ New: func() any { return make(storeDict) }, } func (sd storeDict) Discard() { for k := range sd { delete(sd, k) } statePool.Put(sd) } // clone and return parser current state. func (p *parser) cloneState() storeDict { if p.debug { defer p.out(p.in("cloneState")) } state := statePool.Get().(storeDict) for k, v := range p.cur.state { if c, ok := v.(Cloner); ok { state[k] = c.Clone() } else { state[k] = v } } return state } // restore parser current state to the state storeDict. // every restoreState should applied only one time for every cloned state func (p *parser) restoreState(state storeDict) { if p.debug { defer p.out(p.in("restoreState")) } p.cur.state.Discard() p.cur.state = state } // 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 { if p.debug { defer p.out(p.in("panic handler")) } val = nil switch e := e.(type) { case error: p.addErr(e) default: p.addErr(fmt.Errorf("%v", e)) } err = p.errs.err() } }() } 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) parseRuleMemoize(rule *rule) (any, bool) { res, ok := p.getMemoized(rule) if ok { p.restore(res.end) return res.v, res.b } startMark := p.pt val, ok := p.parseRule(rule) p.setMemoized(startMark, rule, resultTuple{val, ok, p.pt}) return val, ok } func (p *parser) parseRuleWrap(rule *rule) (any, bool) { if p.debug { defer p.out(p.in("parseRule " + rule.name)) } var ( val any ok bool startMark = p.pt ) if p.memoize { val, ok = p.parseRuleMemoize(rule) } else { val, ok = p.parseRule(rule) } if ok && p.debug { p.printIndent("MATCH", string(p.sliceFrom(startMark))) } 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) { var pt savepoint if p.memoize { res, ok := p.getMemoized(expr) if ok { p.restore(res.end) return res.v, res.b } pt = p.pt } val, ok := p.parseExpr(expr) if p.memoize { p.setMemoized(pt, expr, resultTuple{val, ok, p.pt}) } 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 *stateCodeExpr: val, ok = p.parseStateCodeExpr(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) { if p.debug { defer p.out(p.in("parseActionExpr")) } start := p.pt val, ok := p.parseExprWrap(act.expr) if ok { p.cur.pos = start.position p.cur.text = p.sliceFrom(start) state := p.cloneState() actVal, err := act.run(p) if err != nil { p.addErrAt(err, start.position, []string{}) } p.restoreState(state) val = actVal } if ok && p.debug { p.printIndent("MATCH", string(p.sliceFrom(start))) } return val, ok } func (p *parser) parseAndCodeExpr(and *andCodeExpr) (any, bool) { if p.debug { defer p.out(p.in("parseAndCodeExpr")) } state := p.cloneState() ok, err := and.run(p) if err != nil { p.addErr(err) } p.restoreState(state) return nil, ok } func (p *parser) parseAndExpr(and *andExpr) (any, bool) { if p.debug { defer p.out(p.in("parseAndExpr")) } pt := p.pt state := p.cloneState() p.pushV() _, ok := p.parseExprWrap(and.expr) p.popV() p.restoreState(state) p.restore(pt) return nil, ok } func (p *parser) parseAnyMatcher(any *anyMatcher) (any, bool) { if p.debug { defer p.out(p.in("parseAnyMatcher")) } 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) { if p.debug { defer p.out(p.in("parseCharClassMatcher")) } 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) incChoiceAltCnt(ch *choiceExpr, altI int) { choiceIdent := fmt.Sprintf("%s %d:%d", p.rstack[len(p.rstack)-1].name, ch.pos.line, ch.pos.col) m := p.ChoiceAltCnt[choiceIdent] if m == nil { m = make(map[string]int) p.ChoiceAltCnt[choiceIdent] = m } // We increment altI by 1, so the keys do not start at 0 alt := strconv.Itoa(altI + 1) if altI == choiceNoMatch { alt = p.choiceNoMatch } m[alt]++ } func (p *parser) parseChoiceExpr(ch *choiceExpr) (any, bool) { if p.debug { defer p.out(p.in("parseChoiceExpr")) } for altI, alt := range ch.alternatives { // dummy assignment to prevent compile error if optimized _ = altI state := p.cloneState() p.pushV() val, ok := p.parseExprWrap(alt) p.popV() if ok { p.incChoiceAltCnt(ch, altI) return val, ok } p.restoreState(state) } p.incChoiceAltCnt(ch, choiceNoMatch) return nil, false } func (p *parser) parseLabeledExpr(lab *labeledExpr) (any, bool) { if p.debug { defer p.out(p.in("parseLabeledExpr")) } 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) { if p.debug { defer p.out(p.in("parseLitMatcher")) } start := p.pt for _, want := range lit.val { cur := p.pt.rn if lit.ignoreCase { cur = unicode.ToLower(cur) } if cur != want { p.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) { if p.debug { defer p.out(p.in("parseNotCodeExpr")) } state := p.cloneState() ok, err := not.run(p) if err != nil { p.addErr(err) } p.restoreState(state) return nil, !ok } func (p *parser) parseNotExpr(not *notExpr) (any, bool) { if p.debug { defer p.out(p.in("parseNotExpr")) } pt := p.pt state := p.cloneState() p.pushV() p.maxFailInvertExpected = !p.maxFailInvertExpected _, ok := p.parseExprWrap(not.expr) p.maxFailInvertExpected = !p.maxFailInvertExpected p.popV() p.restoreState(state) p.restore(pt) return nil, !ok } func (p *parser) parseOneOrMoreExpr(expr *oneOrMoreExpr) (any, bool) { if p.debug { defer p.out(p.in("parseOneOrMoreExpr")) } 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) { if p.debug { defer p.out(p.in("parseRecoveryExpr (" + strings.Join(recover.failureLabel, ",") + ")")) } 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 p.debug { defer p.out(p.in("parseRuleRefExpr " + ref.name)) } if ref.name == "" { panic(fmt.Sprintf("%s: invalid rule: missing name", ref.pos)) } rule := p.rules[ref.name] if rule == nil { p.addErr(fmt.Errorf("undefined rule: %s", ref.name)) return nil, false } return p.parseRuleWrap(rule) } func (p *parser) parseSeqExpr(seq *seqExpr) (any, bool) { if p.debug { defer p.out(p.in("parseSeqExpr")) } vals := make([]any, 0, len(seq.exprs)) pt := p.pt state := p.cloneState() for _, expr := range seq.exprs { val, ok := p.parseExprWrap(expr) if !ok { p.restoreState(state) p.restore(pt) return nil, false } vals = append(vals, val) } return vals, true } func (p *parser) parseStateCodeExpr(state *stateCodeExpr) (any, bool) { if p.debug { defer p.out(p.in("parseStateCodeExpr")) } err := state.run(p) if err != nil { p.addErr(err) } return nil, true } func (p *parser) parseThrowExpr(expr *throwExpr) (any, bool) { if p.debug { defer p.out(p.in("parseThrowExpr")) } 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) { if p.debug { defer p.out(p.in("parseZeroOrMoreExpr")) } 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) { if p.debug { defer p.out(p.in("parseZeroOrOneExpr")) } p.pushV() val, _ := p.parseExprWrap(expr.expr) p.popV() // whether it matched or not, consider it a match return val, true }