mirror of
https://github.com/featurebasedb/featurebase.git
synced 2026-08-28 10:54:59 +00:00
4845 lines
105 KiB
Go
4845 lines
105 KiB
Go
package pql
|
|
|
|
// Code generated by peg -inline pql.peg DO NOT EDIT.
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const endSymbol rune = 1114112
|
|
|
|
/* The rule types inferred from the grammar are below. */
|
|
type pegRule uint8
|
|
|
|
const (
|
|
ruleUnknown pegRule = iota
|
|
ruleCalls
|
|
ruleCall
|
|
ruleivyExpr
|
|
ruleivyprogram
|
|
ruleivyprogram2
|
|
ruleallargs
|
|
ruleargs
|
|
rulearg
|
|
ruleCOND
|
|
ruleconditional
|
|
rulecondintOrTime
|
|
ruletimefmtS
|
|
rulecondint
|
|
rulecondLT
|
|
rulecondfield
|
|
rulevalue
|
|
ruleitems
|
|
ruleitem
|
|
ruledoublequotedstring
|
|
rulesinglequotedstring
|
|
rulevariable
|
|
rulefieldExpr
|
|
rulefield
|
|
rulereserved
|
|
ruleposfield
|
|
rulecol
|
|
ruleopen
|
|
ruleclose
|
|
rulesp
|
|
ruleeq
|
|
rulecomma
|
|
rulelbrack
|
|
rulerbrack
|
|
ruleIDENT
|
|
ruledigits
|
|
rulesignedDigits
|
|
ruledecimal
|
|
ruletz
|
|
ruleiso8601
|
|
ruleiso8601nano
|
|
ruletimestampbasicfmt
|
|
ruletimestampfmt
|
|
ruletimebasicfmt
|
|
ruletimefmt
|
|
ruletime
|
|
ruleAction0
|
|
ruleAction1
|
|
ruleAction2
|
|
ruleAction3
|
|
ruleAction4
|
|
ruleAction5
|
|
ruleAction6
|
|
ruleAction7
|
|
ruleAction8
|
|
ruleAction9
|
|
ruleAction10
|
|
ruleAction11
|
|
ruleAction12
|
|
ruleAction13
|
|
ruleAction14
|
|
ruleAction15
|
|
ruleAction16
|
|
ruleAction17
|
|
ruleAction18
|
|
ruleAction19
|
|
ruleAction20
|
|
ruleAction21
|
|
ruleAction22
|
|
ruleAction23
|
|
ruleAction24
|
|
ruleAction25
|
|
ruleAction26
|
|
ruleAction27
|
|
ruleAction28
|
|
ruleAction29
|
|
rulePegText
|
|
ruleAction30
|
|
ruleAction31
|
|
ruleAction32
|
|
ruleAction33
|
|
ruleAction34
|
|
ruleAction35
|
|
ruleAction36
|
|
ruleAction37
|
|
ruleAction38
|
|
ruleAction39
|
|
ruleAction40
|
|
ruleAction41
|
|
ruleAction42
|
|
ruleAction43
|
|
ruleAction44
|
|
ruleAction45
|
|
ruleAction46
|
|
ruleAction47
|
|
ruleAction48
|
|
ruleAction49
|
|
ruleAction50
|
|
ruleAction51
|
|
ruleAction52
|
|
ruleAction53
|
|
ruleAction54
|
|
ruleAction55
|
|
ruleAction56
|
|
ruleAction57
|
|
ruleAction58
|
|
ruleAction59
|
|
ruleAction60
|
|
ruleAction61
|
|
ruleAction62
|
|
ruleAction63
|
|
ruleAction64
|
|
ruleAction65
|
|
ruleAction66
|
|
)
|
|
|
|
var rul3s = [...]string{
|
|
"Unknown",
|
|
"Calls",
|
|
"Call",
|
|
"ivyExpr",
|
|
"ivyprogram",
|
|
"ivyprogram2",
|
|
"allargs",
|
|
"args",
|
|
"arg",
|
|
"COND",
|
|
"conditional",
|
|
"condintOrTime",
|
|
"timefmtS",
|
|
"condint",
|
|
"condLT",
|
|
"condfield",
|
|
"value",
|
|
"items",
|
|
"item",
|
|
"doublequotedstring",
|
|
"singlequotedstring",
|
|
"variable",
|
|
"fieldExpr",
|
|
"field",
|
|
"reserved",
|
|
"posfield",
|
|
"col",
|
|
"open",
|
|
"close",
|
|
"sp",
|
|
"eq",
|
|
"comma",
|
|
"lbrack",
|
|
"rbrack",
|
|
"IDENT",
|
|
"digits",
|
|
"signedDigits",
|
|
"decimal",
|
|
"tz",
|
|
"iso8601",
|
|
"iso8601nano",
|
|
"timestampbasicfmt",
|
|
"timestampfmt",
|
|
"timebasicfmt",
|
|
"timefmt",
|
|
"time",
|
|
"Action0",
|
|
"Action1",
|
|
"Action2",
|
|
"Action3",
|
|
"Action4",
|
|
"Action5",
|
|
"Action6",
|
|
"Action7",
|
|
"Action8",
|
|
"Action9",
|
|
"Action10",
|
|
"Action11",
|
|
"Action12",
|
|
"Action13",
|
|
"Action14",
|
|
"Action15",
|
|
"Action16",
|
|
"Action17",
|
|
"Action18",
|
|
"Action19",
|
|
"Action20",
|
|
"Action21",
|
|
"Action22",
|
|
"Action23",
|
|
"Action24",
|
|
"Action25",
|
|
"Action26",
|
|
"Action27",
|
|
"Action28",
|
|
"Action29",
|
|
"PegText",
|
|
"Action30",
|
|
"Action31",
|
|
"Action32",
|
|
"Action33",
|
|
"Action34",
|
|
"Action35",
|
|
"Action36",
|
|
"Action37",
|
|
"Action38",
|
|
"Action39",
|
|
"Action40",
|
|
"Action41",
|
|
"Action42",
|
|
"Action43",
|
|
"Action44",
|
|
"Action45",
|
|
"Action46",
|
|
"Action47",
|
|
"Action48",
|
|
"Action49",
|
|
"Action50",
|
|
"Action51",
|
|
"Action52",
|
|
"Action53",
|
|
"Action54",
|
|
"Action55",
|
|
"Action56",
|
|
"Action57",
|
|
"Action58",
|
|
"Action59",
|
|
"Action60",
|
|
"Action61",
|
|
"Action62",
|
|
"Action63",
|
|
"Action64",
|
|
"Action65",
|
|
"Action66",
|
|
}
|
|
|
|
type token32 struct {
|
|
pegRule
|
|
begin, end uint32
|
|
}
|
|
|
|
func (t *token32) String() string {
|
|
return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v", rul3s[t.pegRule], t.begin, t.end)
|
|
}
|
|
|
|
type node32 struct {
|
|
token32
|
|
up, next *node32
|
|
}
|
|
|
|
func (node *node32) print(w io.Writer, pretty bool, buffer string) {
|
|
var print func(node *node32, depth int)
|
|
print = func(node *node32, depth int) {
|
|
for node != nil {
|
|
for c := 0; c < depth; c++ {
|
|
fmt.Fprintf(w, " ")
|
|
}
|
|
rule := rul3s[node.pegRule]
|
|
quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
|
|
if !pretty {
|
|
fmt.Fprintf(w, "%v %v\n", rule, quote)
|
|
} else {
|
|
fmt.Fprintf(w, "\x1B[36m%v\x1B[m %v\n", rule, quote)
|
|
}
|
|
if node.up != nil {
|
|
print(node.up, depth+1)
|
|
}
|
|
node = node.next
|
|
}
|
|
}
|
|
print(node, 0)
|
|
}
|
|
|
|
func (node *node32) Print(w io.Writer, buffer string) {
|
|
node.print(w, false, buffer)
|
|
}
|
|
|
|
func (node *node32) PrettyPrint(w io.Writer, buffer string) {
|
|
node.print(w, true, buffer)
|
|
}
|
|
|
|
type tokens32 struct {
|
|
tree []token32
|
|
}
|
|
|
|
func (t *tokens32) Trim(length uint32) {
|
|
t.tree = t.tree[:length]
|
|
}
|
|
|
|
func (t *tokens32) Print() {
|
|
for _, token := range t.tree {
|
|
fmt.Println(token.String())
|
|
}
|
|
}
|
|
|
|
func (t *tokens32) AST() *node32 {
|
|
type element struct {
|
|
node *node32
|
|
down *element
|
|
}
|
|
tokens := t.Tokens()
|
|
var stack *element
|
|
for _, token := range tokens {
|
|
if token.begin == token.end {
|
|
continue
|
|
}
|
|
node := &node32{token32: token}
|
|
for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
|
|
stack.node.next = node.up
|
|
node.up = stack.node
|
|
stack = stack.down
|
|
}
|
|
stack = &element{node: node, down: stack}
|
|
}
|
|
if stack != nil {
|
|
return stack.node
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *tokens32) PrintSyntaxTree(buffer string) {
|
|
t.AST().Print(os.Stdout, buffer)
|
|
}
|
|
|
|
func (t *tokens32) WriteSyntaxTree(w io.Writer, buffer string) {
|
|
t.AST().Print(w, buffer)
|
|
}
|
|
|
|
func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
|
|
t.AST().PrettyPrint(os.Stdout, buffer)
|
|
}
|
|
|
|
func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
|
|
tree, i := t.tree, int(index)
|
|
if i >= len(tree) {
|
|
t.tree = append(tree, token32{pegRule: rule, begin: begin, end: end})
|
|
return
|
|
}
|
|
tree[i] = token32{pegRule: rule, begin: begin, end: end}
|
|
}
|
|
|
|
func (t *tokens32) Tokens() []token32 {
|
|
return t.tree
|
|
}
|
|
|
|
type PQL struct {
|
|
Query
|
|
|
|
Buffer string
|
|
buffer []rune
|
|
rules [114]func() bool
|
|
parse func(rule ...int) error
|
|
reset func()
|
|
Pretty bool
|
|
tokens32
|
|
}
|
|
|
|
func (p *PQL) Parse(rule ...int) error {
|
|
return p.parse(rule...)
|
|
}
|
|
|
|
func (p *PQL) Reset() {
|
|
p.reset()
|
|
}
|
|
|
|
type textPosition struct {
|
|
line, symbol int
|
|
}
|
|
|
|
type textPositionMap map[int]textPosition
|
|
|
|
func translatePositions(buffer []rune, positions []int) textPositionMap {
|
|
length, translations, j, line, symbol := len(positions), make(textPositionMap, len(positions)), 0, 1, 0
|
|
sort.Ints(positions)
|
|
|
|
search:
|
|
for i, c := range buffer {
|
|
if c == '\n' {
|
|
line, symbol = line+1, 0
|
|
} else {
|
|
symbol++
|
|
}
|
|
if i == positions[j] {
|
|
translations[positions[j]] = textPosition{line, symbol}
|
|
for j++; j < length; j++ {
|
|
if i != positions[j] {
|
|
continue search
|
|
}
|
|
}
|
|
break search
|
|
}
|
|
}
|
|
|
|
return translations
|
|
}
|
|
|
|
type parseError struct {
|
|
p *PQL
|
|
max token32
|
|
}
|
|
|
|
func (e *parseError) Error() string {
|
|
tokens, err := []token32{e.max}, "\n"
|
|
positions, p := make([]int, 2*len(tokens)), 0
|
|
for _, token := range tokens {
|
|
positions[p], p = int(token.begin), p+1
|
|
positions[p], p = int(token.end), p+1
|
|
}
|
|
translations := translatePositions(e.p.buffer, positions)
|
|
format := "parse error near %v (line %v symbol %v - line %v symbol %v):\n%v\n"
|
|
if e.p.Pretty {
|
|
format = "parse error near \x1B[34m%v\x1B[m (line %v symbol %v - line %v symbol %v):\n%v\n"
|
|
}
|
|
for _, token := range tokens {
|
|
begin, end := int(token.begin), int(token.end)
|
|
err += fmt.Sprintf(format,
|
|
rul3s[token.pegRule],
|
|
translations[begin].line, translations[begin].symbol,
|
|
translations[end].line, translations[end].symbol,
|
|
strconv.Quote(string(e.p.buffer[begin:end])))
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func (p *PQL) PrintSyntaxTree() {
|
|
if p.Pretty {
|
|
p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
|
|
} else {
|
|
p.tokens32.PrintSyntaxTree(p.Buffer)
|
|
}
|
|
}
|
|
|
|
func (p *PQL) WriteSyntaxTree(w io.Writer) {
|
|
p.tokens32.WriteSyntaxTree(w, p.Buffer)
|
|
}
|
|
|
|
func (p *PQL) SprintSyntaxTree() string {
|
|
var bldr strings.Builder
|
|
p.WriteSyntaxTree(&bldr)
|
|
return bldr.String()
|
|
}
|
|
|
|
func (p *PQL) Execute() {
|
|
buffer, _buffer, text, begin, end := p.Buffer, p.buffer, "", 0, 0
|
|
for _, token := range p.Tokens() {
|
|
switch token.pegRule {
|
|
|
|
case rulePegText:
|
|
begin, end = int(token.begin), int(token.end)
|
|
text = string(_buffer[begin:end])
|
|
|
|
case ruleAction0:
|
|
p.startCall("Set")
|
|
case ruleAction1:
|
|
p.endCall()
|
|
case ruleAction2:
|
|
p.startCall("Clear")
|
|
case ruleAction3:
|
|
p.endCall()
|
|
case ruleAction4:
|
|
p.startCall("Apply")
|
|
case ruleAction5:
|
|
p.endCall()
|
|
case ruleAction6:
|
|
p.startCall("ClearRow")
|
|
case ruleAction7:
|
|
p.endCall()
|
|
case ruleAction8:
|
|
p.startCall("Store")
|
|
case ruleAction9:
|
|
p.endCall()
|
|
case ruleAction10:
|
|
p.startCall("TopN")
|
|
case ruleAction11:
|
|
p.endCall()
|
|
case ruleAction12:
|
|
p.startCall("TopK")
|
|
case ruleAction13:
|
|
p.endCall()
|
|
case ruleAction14:
|
|
p.startCall("Percentile")
|
|
case ruleAction15:
|
|
p.endCall()
|
|
case ruleAction16:
|
|
p.startCall("Rows")
|
|
case ruleAction17:
|
|
p.endCall()
|
|
case ruleAction18:
|
|
p.startCall("Min")
|
|
case ruleAction19:
|
|
p.endCall()
|
|
case ruleAction20:
|
|
p.startCall("Max")
|
|
case ruleAction21:
|
|
p.endCall()
|
|
case ruleAction22:
|
|
p.startCall("Sum")
|
|
case ruleAction23:
|
|
p.endCall()
|
|
case ruleAction24:
|
|
p.startCall("Range")
|
|
case ruleAction25:
|
|
p.addField("from")
|
|
case ruleAction26:
|
|
p.addVal(text)
|
|
case ruleAction27:
|
|
p.addField("to")
|
|
case ruleAction28:
|
|
p.addVal(text)
|
|
case ruleAction29:
|
|
p.endCall()
|
|
case ruleAction30:
|
|
p.startCall(text)
|
|
case ruleAction31:
|
|
p.endCall()
|
|
case ruleAction32:
|
|
p.addPosStr("_ivy", text)
|
|
case ruleAction33:
|
|
p.addPosStr("_ivyReduce", text)
|
|
case ruleAction34:
|
|
p.addBTWN()
|
|
case ruleAction35:
|
|
p.addLTE()
|
|
case ruleAction36:
|
|
p.addGTE()
|
|
case ruleAction37:
|
|
p.addEQ()
|
|
case ruleAction38:
|
|
p.addNEQ()
|
|
case ruleAction39:
|
|
p.addLT()
|
|
case ruleAction40:
|
|
p.addGT()
|
|
case ruleAction41:
|
|
p.startConditional()
|
|
case ruleAction42:
|
|
p.endConditional()
|
|
case ruleAction43:
|
|
p.condAddTimestamp(text)
|
|
case ruleAction44:
|
|
p.condAdd(text)
|
|
case ruleAction45:
|
|
p.condAdd(text)
|
|
case ruleAction46:
|
|
p.condAdd(text)
|
|
case ruleAction47:
|
|
p.startList()
|
|
case ruleAction48:
|
|
p.endList()
|
|
case ruleAction49:
|
|
p.addVal(nil)
|
|
case ruleAction50:
|
|
p.addVal(true)
|
|
case ruleAction51:
|
|
p.addVal(false)
|
|
case ruleAction52:
|
|
p.addVal(NewVariable(text))
|
|
case ruleAction53:
|
|
p.addVal(text)
|
|
case ruleAction54:
|
|
p.addTimestampVal(text)
|
|
case ruleAction55:
|
|
p.addNumVal(text)
|
|
case ruleAction56:
|
|
p.startCall(text)
|
|
case ruleAction57:
|
|
p.addVal(p.endCall())
|
|
case ruleAction58:
|
|
p.addVal(text)
|
|
case ruleAction59:
|
|
p.addVal(text)
|
|
case ruleAction60:
|
|
p.addVal(text)
|
|
case ruleAction61:
|
|
p.addField(text)
|
|
case ruleAction62:
|
|
p.addPosStr("_field", text)
|
|
case ruleAction63:
|
|
p.addPosNum("_col", text)
|
|
case ruleAction64:
|
|
p.addPosStr("_col", text)
|
|
case ruleAction65:
|
|
p.addPosStr("_col", text)
|
|
case ruleAction66:
|
|
p.addPosStr("_timestamp", text)
|
|
|
|
}
|
|
}
|
|
_, _, _, _, _ = buffer, _buffer, text, begin, end
|
|
}
|
|
|
|
func Pretty(pretty bool) func(*PQL) error {
|
|
return func(p *PQL) error {
|
|
p.Pretty = pretty
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func Size(size int) func(*PQL) error {
|
|
return func(p *PQL) error {
|
|
p.tokens32 = tokens32{tree: make([]token32, 0, size)}
|
|
return nil
|
|
}
|
|
}
|
|
func (p *PQL) Init(options ...func(*PQL) error) error {
|
|
var (
|
|
max token32
|
|
position, tokenIndex uint32
|
|
buffer []rune
|
|
)
|
|
for _, option := range options {
|
|
err := option(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
p.reset = func() {
|
|
max = token32{}
|
|
position, tokenIndex = 0, 0
|
|
|
|
p.buffer = []rune(p.Buffer)
|
|
if len(p.buffer) == 0 || p.buffer[len(p.buffer)-1] != endSymbol {
|
|
p.buffer = append(p.buffer, endSymbol)
|
|
}
|
|
buffer = p.buffer
|
|
}
|
|
p.reset()
|
|
|
|
_rules := p.rules
|
|
tree := p.tokens32
|
|
p.parse = func(rule ...int) error {
|
|
r := 1
|
|
if len(rule) > 0 {
|
|
r = rule[0]
|
|
}
|
|
matches := p.rules[r]()
|
|
p.tokens32 = tree
|
|
if matches {
|
|
p.Trim(tokenIndex)
|
|
return nil
|
|
}
|
|
return &parseError{p, max}
|
|
}
|
|
|
|
add := func(rule pegRule, begin uint32) {
|
|
tree.Add(rule, begin, position, tokenIndex)
|
|
tokenIndex++
|
|
if begin != position && position > max.end {
|
|
max = token32{rule, begin, position}
|
|
}
|
|
}
|
|
|
|
matchDot := func() bool {
|
|
if buffer[position] != endSymbol {
|
|
position++
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
/*matchChar := func(c byte) bool {
|
|
if buffer[position] == c {
|
|
position++
|
|
return true
|
|
}
|
|
return false
|
|
}*/
|
|
|
|
/*matchRange := func(lower byte, upper byte) bool {
|
|
if c := buffer[position]; c >= lower && c <= upper {
|
|
position++
|
|
return true
|
|
}
|
|
return false
|
|
}*/
|
|
|
|
_rules = [...]func() bool{
|
|
nil,
|
|
/* 0 Calls <- <(sp (Call sp)* !.)> */
|
|
func() bool {
|
|
position0, tokenIndex0 := position, tokenIndex
|
|
{
|
|
position1 := position
|
|
if !_rules[rulesp]() {
|
|
goto l0
|
|
}
|
|
l2:
|
|
{
|
|
position3, tokenIndex3 := position, tokenIndex
|
|
if !_rules[ruleCall]() {
|
|
goto l3
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l3
|
|
}
|
|
goto l2
|
|
l3:
|
|
position, tokenIndex = position3, tokenIndex3
|
|
}
|
|
{
|
|
position4, tokenIndex4 := position, tokenIndex
|
|
if !matchDot() {
|
|
goto l4
|
|
}
|
|
goto l0
|
|
l4:
|
|
position, tokenIndex = position4, tokenIndex4
|
|
}
|
|
add(ruleCalls, position1)
|
|
}
|
|
return true
|
|
l0:
|
|
position, tokenIndex = position0, tokenIndex0
|
|
return false
|
|
},
|
|
/* 1 Call <- <((('s' / 'S') ('e' / 'E') ('t' / 'T') Action0 open col comma args (comma time)? close Action1) / (('c' / 'C') ('l' / 'L') ('e' / 'E') ('a' / 'A') ('r' / 'R') Action2 open col comma args close Action3) / (('a' / 'A') ('p' / 'P') ('p' / 'P') ('l' / 'L') ('y' / 'Y') Action4 open (Call comma)? ivyprogram (comma ivyprogram2)? close Action5) / (('c' / 'C') ('l' / 'L') ('e' / 'E') ('a' / 'A') ('r' / 'R') ('r' / 'R') ('o' / 'O') ('w' / 'W') Action6 open arg close Action7) / (('s' / 'S') ('t' / 'T') ('o' / 'O') ('r' / 'R') ('e' / 'E') Action8 open Call comma arg close Action9) / (('t' / 'T') ('o' / 'O') ('p' / 'P') ('n' / 'N') Action10 open posfield (comma allargs)? close Action11) / (('t' / 'T') ('o' / 'O') ('p' / 'P') ('k' / 'K') Action12 open posfield (comma allargs)? close Action13) / (('p' / 'P') ('e' / 'E') ('r' / 'R') ('c' / 'C') ('e' / 'E') ('n' / 'N') ('t' / 'T') ('i' / 'I') ('l' / 'L') ('e' / 'E') Action14 open posfield (comma allargs)? close Action15) / (('r' / 'R') ('o' / 'O') ('w' / 'W') ('s' / 'S') Action16 open posfield (comma allargs)? close Action17) / (('m' / 'M') ('i' / 'I') ('n' / 'N') Action18 open posfield (comma allargs)? close Action19) / (('m' / 'M') ('a' / 'A') ('x' / 'X') Action20 open posfield (comma allargs)? close Action21) / (('s' / 'S') ('u' / 'U') ('m' / 'M') Action22 open posfield (comma allargs)? close Action23) / (('r' / 'R') ('a' / 'A') ('n' / 'N') ('g' / 'G') ('e' / 'E') Action24 open field eq value comma ('f' 'r' 'o' 'm' '=')? Action25 timefmt Action26 comma ('t' 'o' '=')? sp Action27 timefmt Action28 close Action29) / (<IDENT> Action30 open allargs comma? close Action31))> */
|
|
func() bool {
|
|
position5, tokenIndex5 := position, tokenIndex
|
|
{
|
|
position6 := position
|
|
{
|
|
position7, tokenIndex7 := position, tokenIndex
|
|
{
|
|
position9, tokenIndex9 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l10
|
|
}
|
|
position++
|
|
goto l9
|
|
l10:
|
|
position, tokenIndex = position9, tokenIndex9
|
|
if buffer[position] != rune('S') {
|
|
goto l8
|
|
}
|
|
position++
|
|
}
|
|
l9:
|
|
{
|
|
position11, tokenIndex11 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l12
|
|
}
|
|
position++
|
|
goto l11
|
|
l12:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
if buffer[position] != rune('E') {
|
|
goto l8
|
|
}
|
|
position++
|
|
}
|
|
l11:
|
|
{
|
|
position13, tokenIndex13 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l14
|
|
}
|
|
position++
|
|
goto l13
|
|
l14:
|
|
position, tokenIndex = position13, tokenIndex13
|
|
if buffer[position] != rune('T') {
|
|
goto l8
|
|
}
|
|
position++
|
|
}
|
|
l13:
|
|
{
|
|
add(ruleAction0, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l8
|
|
}
|
|
if !_rules[rulecol]() {
|
|
goto l8
|
|
}
|
|
if !_rules[rulecomma]() {
|
|
goto l8
|
|
}
|
|
if !_rules[ruleargs]() {
|
|
goto l8
|
|
}
|
|
{
|
|
position16, tokenIndex16 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l16
|
|
}
|
|
{
|
|
position18 := position
|
|
{
|
|
position19 := position
|
|
if !_rules[ruletimefmt]() {
|
|
goto l16
|
|
}
|
|
add(rulePegText, position19)
|
|
}
|
|
{
|
|
add(ruleAction66, position)
|
|
}
|
|
add(ruletime, position18)
|
|
}
|
|
goto l17
|
|
l16:
|
|
position, tokenIndex = position16, tokenIndex16
|
|
}
|
|
l17:
|
|
if !_rules[ruleclose]() {
|
|
goto l8
|
|
}
|
|
{
|
|
add(ruleAction1, position)
|
|
}
|
|
goto l7
|
|
l8:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position23, tokenIndex23 := position, tokenIndex
|
|
if buffer[position] != rune('c') {
|
|
goto l24
|
|
}
|
|
position++
|
|
goto l23
|
|
l24:
|
|
position, tokenIndex = position23, tokenIndex23
|
|
if buffer[position] != rune('C') {
|
|
goto l22
|
|
}
|
|
position++
|
|
}
|
|
l23:
|
|
{
|
|
position25, tokenIndex25 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l26
|
|
}
|
|
position++
|
|
goto l25
|
|
l26:
|
|
position, tokenIndex = position25, tokenIndex25
|
|
if buffer[position] != rune('L') {
|
|
goto l22
|
|
}
|
|
position++
|
|
}
|
|
l25:
|
|
{
|
|
position27, tokenIndex27 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l28
|
|
}
|
|
position++
|
|
goto l27
|
|
l28:
|
|
position, tokenIndex = position27, tokenIndex27
|
|
if buffer[position] != rune('E') {
|
|
goto l22
|
|
}
|
|
position++
|
|
}
|
|
l27:
|
|
{
|
|
position29, tokenIndex29 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l30
|
|
}
|
|
position++
|
|
goto l29
|
|
l30:
|
|
position, tokenIndex = position29, tokenIndex29
|
|
if buffer[position] != rune('A') {
|
|
goto l22
|
|
}
|
|
position++
|
|
}
|
|
l29:
|
|
{
|
|
position31, tokenIndex31 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l32
|
|
}
|
|
position++
|
|
goto l31
|
|
l32:
|
|
position, tokenIndex = position31, tokenIndex31
|
|
if buffer[position] != rune('R') {
|
|
goto l22
|
|
}
|
|
position++
|
|
}
|
|
l31:
|
|
{
|
|
add(ruleAction2, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l22
|
|
}
|
|
if !_rules[rulecol]() {
|
|
goto l22
|
|
}
|
|
if !_rules[rulecomma]() {
|
|
goto l22
|
|
}
|
|
if !_rules[ruleargs]() {
|
|
goto l22
|
|
}
|
|
if !_rules[ruleclose]() {
|
|
goto l22
|
|
}
|
|
{
|
|
add(ruleAction3, position)
|
|
}
|
|
goto l7
|
|
l22:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position36, tokenIndex36 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l37
|
|
}
|
|
position++
|
|
goto l36
|
|
l37:
|
|
position, tokenIndex = position36, tokenIndex36
|
|
if buffer[position] != rune('A') {
|
|
goto l35
|
|
}
|
|
position++
|
|
}
|
|
l36:
|
|
{
|
|
position38, tokenIndex38 := position, tokenIndex
|
|
if buffer[position] != rune('p') {
|
|
goto l39
|
|
}
|
|
position++
|
|
goto l38
|
|
l39:
|
|
position, tokenIndex = position38, tokenIndex38
|
|
if buffer[position] != rune('P') {
|
|
goto l35
|
|
}
|
|
position++
|
|
}
|
|
l38:
|
|
{
|
|
position40, tokenIndex40 := position, tokenIndex
|
|
if buffer[position] != rune('p') {
|
|
goto l41
|
|
}
|
|
position++
|
|
goto l40
|
|
l41:
|
|
position, tokenIndex = position40, tokenIndex40
|
|
if buffer[position] != rune('P') {
|
|
goto l35
|
|
}
|
|
position++
|
|
}
|
|
l40:
|
|
{
|
|
position42, tokenIndex42 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l43
|
|
}
|
|
position++
|
|
goto l42
|
|
l43:
|
|
position, tokenIndex = position42, tokenIndex42
|
|
if buffer[position] != rune('L') {
|
|
goto l35
|
|
}
|
|
position++
|
|
}
|
|
l42:
|
|
{
|
|
position44, tokenIndex44 := position, tokenIndex
|
|
if buffer[position] != rune('y') {
|
|
goto l45
|
|
}
|
|
position++
|
|
goto l44
|
|
l45:
|
|
position, tokenIndex = position44, tokenIndex44
|
|
if buffer[position] != rune('Y') {
|
|
goto l35
|
|
}
|
|
position++
|
|
}
|
|
l44:
|
|
{
|
|
add(ruleAction4, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l35
|
|
}
|
|
{
|
|
position47, tokenIndex47 := position, tokenIndex
|
|
if !_rules[ruleCall]() {
|
|
goto l47
|
|
}
|
|
if !_rules[rulecomma]() {
|
|
goto l47
|
|
}
|
|
goto l48
|
|
l47:
|
|
position, tokenIndex = position47, tokenIndex47
|
|
}
|
|
l48:
|
|
{
|
|
position49 := position
|
|
{
|
|
position50, tokenIndex50 := position, tokenIndex
|
|
if buffer[position] != rune('"') {
|
|
goto l50
|
|
}
|
|
position++
|
|
goto l51
|
|
l50:
|
|
position, tokenIndex = position50, tokenIndex50
|
|
}
|
|
l51:
|
|
{
|
|
position52 := position
|
|
if !_rules[ruleivyExpr]() {
|
|
goto l35
|
|
}
|
|
add(rulePegText, position52)
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l35
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction32, position)
|
|
}
|
|
add(ruleivyprogram, position49)
|
|
}
|
|
{
|
|
position54, tokenIndex54 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l54
|
|
}
|
|
{
|
|
position56 := position
|
|
{
|
|
position57, tokenIndex57 := position, tokenIndex
|
|
if buffer[position] != rune('"') {
|
|
goto l57
|
|
}
|
|
position++
|
|
goto l58
|
|
l57:
|
|
position, tokenIndex = position57, tokenIndex57
|
|
}
|
|
l58:
|
|
{
|
|
position59 := position
|
|
if !_rules[ruleivyExpr]() {
|
|
goto l54
|
|
}
|
|
add(rulePegText, position59)
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l54
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction33, position)
|
|
}
|
|
add(ruleivyprogram2, position56)
|
|
}
|
|
goto l55
|
|
l54:
|
|
position, tokenIndex = position54, tokenIndex54
|
|
}
|
|
l55:
|
|
if !_rules[ruleclose]() {
|
|
goto l35
|
|
}
|
|
{
|
|
add(ruleAction5, position)
|
|
}
|
|
goto l7
|
|
l35:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position63, tokenIndex63 := position, tokenIndex
|
|
if buffer[position] != rune('c') {
|
|
goto l64
|
|
}
|
|
position++
|
|
goto l63
|
|
l64:
|
|
position, tokenIndex = position63, tokenIndex63
|
|
if buffer[position] != rune('C') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l63:
|
|
{
|
|
position65, tokenIndex65 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l66
|
|
}
|
|
position++
|
|
goto l65
|
|
l66:
|
|
position, tokenIndex = position65, tokenIndex65
|
|
if buffer[position] != rune('L') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l65:
|
|
{
|
|
position67, tokenIndex67 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l68
|
|
}
|
|
position++
|
|
goto l67
|
|
l68:
|
|
position, tokenIndex = position67, tokenIndex67
|
|
if buffer[position] != rune('E') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l67:
|
|
{
|
|
position69, tokenIndex69 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l70
|
|
}
|
|
position++
|
|
goto l69
|
|
l70:
|
|
position, tokenIndex = position69, tokenIndex69
|
|
if buffer[position] != rune('A') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l69:
|
|
{
|
|
position71, tokenIndex71 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l72
|
|
}
|
|
position++
|
|
goto l71
|
|
l72:
|
|
position, tokenIndex = position71, tokenIndex71
|
|
if buffer[position] != rune('R') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l71:
|
|
{
|
|
position73, tokenIndex73 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l74
|
|
}
|
|
position++
|
|
goto l73
|
|
l74:
|
|
position, tokenIndex = position73, tokenIndex73
|
|
if buffer[position] != rune('R') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l73:
|
|
{
|
|
position75, tokenIndex75 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l76
|
|
}
|
|
position++
|
|
goto l75
|
|
l76:
|
|
position, tokenIndex = position75, tokenIndex75
|
|
if buffer[position] != rune('O') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l75:
|
|
{
|
|
position77, tokenIndex77 := position, tokenIndex
|
|
if buffer[position] != rune('w') {
|
|
goto l78
|
|
}
|
|
position++
|
|
goto l77
|
|
l78:
|
|
position, tokenIndex = position77, tokenIndex77
|
|
if buffer[position] != rune('W') {
|
|
goto l62
|
|
}
|
|
position++
|
|
}
|
|
l77:
|
|
{
|
|
add(ruleAction6, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l62
|
|
}
|
|
if !_rules[rulearg]() {
|
|
goto l62
|
|
}
|
|
if !_rules[ruleclose]() {
|
|
goto l62
|
|
}
|
|
{
|
|
add(ruleAction7, position)
|
|
}
|
|
goto l7
|
|
l62:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position82, tokenIndex82 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l83
|
|
}
|
|
position++
|
|
goto l82
|
|
l83:
|
|
position, tokenIndex = position82, tokenIndex82
|
|
if buffer[position] != rune('S') {
|
|
goto l81
|
|
}
|
|
position++
|
|
}
|
|
l82:
|
|
{
|
|
position84, tokenIndex84 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l85
|
|
}
|
|
position++
|
|
goto l84
|
|
l85:
|
|
position, tokenIndex = position84, tokenIndex84
|
|
if buffer[position] != rune('T') {
|
|
goto l81
|
|
}
|
|
position++
|
|
}
|
|
l84:
|
|
{
|
|
position86, tokenIndex86 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l87
|
|
}
|
|
position++
|
|
goto l86
|
|
l87:
|
|
position, tokenIndex = position86, tokenIndex86
|
|
if buffer[position] != rune('O') {
|
|
goto l81
|
|
}
|
|
position++
|
|
}
|
|
l86:
|
|
{
|
|
position88, tokenIndex88 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l89
|
|
}
|
|
position++
|
|
goto l88
|
|
l89:
|
|
position, tokenIndex = position88, tokenIndex88
|
|
if buffer[position] != rune('R') {
|
|
goto l81
|
|
}
|
|
position++
|
|
}
|
|
l88:
|
|
{
|
|
position90, tokenIndex90 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l91
|
|
}
|
|
position++
|
|
goto l90
|
|
l91:
|
|
position, tokenIndex = position90, tokenIndex90
|
|
if buffer[position] != rune('E') {
|
|
goto l81
|
|
}
|
|
position++
|
|
}
|
|
l90:
|
|
{
|
|
add(ruleAction8, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l81
|
|
}
|
|
if !_rules[ruleCall]() {
|
|
goto l81
|
|
}
|
|
if !_rules[rulecomma]() {
|
|
goto l81
|
|
}
|
|
if !_rules[rulearg]() {
|
|
goto l81
|
|
}
|
|
if !_rules[ruleclose]() {
|
|
goto l81
|
|
}
|
|
{
|
|
add(ruleAction9, position)
|
|
}
|
|
goto l7
|
|
l81:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position95, tokenIndex95 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l96
|
|
}
|
|
position++
|
|
goto l95
|
|
l96:
|
|
position, tokenIndex = position95, tokenIndex95
|
|
if buffer[position] != rune('T') {
|
|
goto l94
|
|
}
|
|
position++
|
|
}
|
|
l95:
|
|
{
|
|
position97, tokenIndex97 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l98
|
|
}
|
|
position++
|
|
goto l97
|
|
l98:
|
|
position, tokenIndex = position97, tokenIndex97
|
|
if buffer[position] != rune('O') {
|
|
goto l94
|
|
}
|
|
position++
|
|
}
|
|
l97:
|
|
{
|
|
position99, tokenIndex99 := position, tokenIndex
|
|
if buffer[position] != rune('p') {
|
|
goto l100
|
|
}
|
|
position++
|
|
goto l99
|
|
l100:
|
|
position, tokenIndex = position99, tokenIndex99
|
|
if buffer[position] != rune('P') {
|
|
goto l94
|
|
}
|
|
position++
|
|
}
|
|
l99:
|
|
{
|
|
position101, tokenIndex101 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l102
|
|
}
|
|
position++
|
|
goto l101
|
|
l102:
|
|
position, tokenIndex = position101, tokenIndex101
|
|
if buffer[position] != rune('N') {
|
|
goto l94
|
|
}
|
|
position++
|
|
}
|
|
l101:
|
|
{
|
|
add(ruleAction10, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l94
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l94
|
|
}
|
|
{
|
|
position104, tokenIndex104 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l104
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l104
|
|
}
|
|
goto l105
|
|
l104:
|
|
position, tokenIndex = position104, tokenIndex104
|
|
}
|
|
l105:
|
|
if !_rules[ruleclose]() {
|
|
goto l94
|
|
}
|
|
{
|
|
add(ruleAction11, position)
|
|
}
|
|
goto l7
|
|
l94:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position108, tokenIndex108 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l109
|
|
}
|
|
position++
|
|
goto l108
|
|
l109:
|
|
position, tokenIndex = position108, tokenIndex108
|
|
if buffer[position] != rune('T') {
|
|
goto l107
|
|
}
|
|
position++
|
|
}
|
|
l108:
|
|
{
|
|
position110, tokenIndex110 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l111
|
|
}
|
|
position++
|
|
goto l110
|
|
l111:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('O') {
|
|
goto l107
|
|
}
|
|
position++
|
|
}
|
|
l110:
|
|
{
|
|
position112, tokenIndex112 := position, tokenIndex
|
|
if buffer[position] != rune('p') {
|
|
goto l113
|
|
}
|
|
position++
|
|
goto l112
|
|
l113:
|
|
position, tokenIndex = position112, tokenIndex112
|
|
if buffer[position] != rune('P') {
|
|
goto l107
|
|
}
|
|
position++
|
|
}
|
|
l112:
|
|
{
|
|
position114, tokenIndex114 := position, tokenIndex
|
|
if buffer[position] != rune('k') {
|
|
goto l115
|
|
}
|
|
position++
|
|
goto l114
|
|
l115:
|
|
position, tokenIndex = position114, tokenIndex114
|
|
if buffer[position] != rune('K') {
|
|
goto l107
|
|
}
|
|
position++
|
|
}
|
|
l114:
|
|
{
|
|
add(ruleAction12, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l107
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l107
|
|
}
|
|
{
|
|
position117, tokenIndex117 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l117
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l117
|
|
}
|
|
goto l118
|
|
l117:
|
|
position, tokenIndex = position117, tokenIndex117
|
|
}
|
|
l118:
|
|
if !_rules[ruleclose]() {
|
|
goto l107
|
|
}
|
|
{
|
|
add(ruleAction13, position)
|
|
}
|
|
goto l7
|
|
l107:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position121, tokenIndex121 := position, tokenIndex
|
|
if buffer[position] != rune('p') {
|
|
goto l122
|
|
}
|
|
position++
|
|
goto l121
|
|
l122:
|
|
position, tokenIndex = position121, tokenIndex121
|
|
if buffer[position] != rune('P') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l121:
|
|
{
|
|
position123, tokenIndex123 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l124
|
|
}
|
|
position++
|
|
goto l123
|
|
l124:
|
|
position, tokenIndex = position123, tokenIndex123
|
|
if buffer[position] != rune('E') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l123:
|
|
{
|
|
position125, tokenIndex125 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l126
|
|
}
|
|
position++
|
|
goto l125
|
|
l126:
|
|
position, tokenIndex = position125, tokenIndex125
|
|
if buffer[position] != rune('R') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l125:
|
|
{
|
|
position127, tokenIndex127 := position, tokenIndex
|
|
if buffer[position] != rune('c') {
|
|
goto l128
|
|
}
|
|
position++
|
|
goto l127
|
|
l128:
|
|
position, tokenIndex = position127, tokenIndex127
|
|
if buffer[position] != rune('C') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l127:
|
|
{
|
|
position129, tokenIndex129 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l130
|
|
}
|
|
position++
|
|
goto l129
|
|
l130:
|
|
position, tokenIndex = position129, tokenIndex129
|
|
if buffer[position] != rune('E') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l129:
|
|
{
|
|
position131, tokenIndex131 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l132
|
|
}
|
|
position++
|
|
goto l131
|
|
l132:
|
|
position, tokenIndex = position131, tokenIndex131
|
|
if buffer[position] != rune('N') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l131:
|
|
{
|
|
position133, tokenIndex133 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l134
|
|
}
|
|
position++
|
|
goto l133
|
|
l134:
|
|
position, tokenIndex = position133, tokenIndex133
|
|
if buffer[position] != rune('T') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l133:
|
|
{
|
|
position135, tokenIndex135 := position, tokenIndex
|
|
if buffer[position] != rune('i') {
|
|
goto l136
|
|
}
|
|
position++
|
|
goto l135
|
|
l136:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('I') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l135:
|
|
{
|
|
position137, tokenIndex137 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l138
|
|
}
|
|
position++
|
|
goto l137
|
|
l138:
|
|
position, tokenIndex = position137, tokenIndex137
|
|
if buffer[position] != rune('L') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l137:
|
|
{
|
|
position139, tokenIndex139 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l140
|
|
}
|
|
position++
|
|
goto l139
|
|
l140:
|
|
position, tokenIndex = position139, tokenIndex139
|
|
if buffer[position] != rune('E') {
|
|
goto l120
|
|
}
|
|
position++
|
|
}
|
|
l139:
|
|
{
|
|
add(ruleAction14, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l120
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l120
|
|
}
|
|
{
|
|
position142, tokenIndex142 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l142
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l142
|
|
}
|
|
goto l143
|
|
l142:
|
|
position, tokenIndex = position142, tokenIndex142
|
|
}
|
|
l143:
|
|
if !_rules[ruleclose]() {
|
|
goto l120
|
|
}
|
|
{
|
|
add(ruleAction15, position)
|
|
}
|
|
goto l7
|
|
l120:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position146, tokenIndex146 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l147
|
|
}
|
|
position++
|
|
goto l146
|
|
l147:
|
|
position, tokenIndex = position146, tokenIndex146
|
|
if buffer[position] != rune('R') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l146:
|
|
{
|
|
position148, tokenIndex148 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l149
|
|
}
|
|
position++
|
|
goto l148
|
|
l149:
|
|
position, tokenIndex = position148, tokenIndex148
|
|
if buffer[position] != rune('O') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l148:
|
|
{
|
|
position150, tokenIndex150 := position, tokenIndex
|
|
if buffer[position] != rune('w') {
|
|
goto l151
|
|
}
|
|
position++
|
|
goto l150
|
|
l151:
|
|
position, tokenIndex = position150, tokenIndex150
|
|
if buffer[position] != rune('W') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l150:
|
|
{
|
|
position152, tokenIndex152 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l153
|
|
}
|
|
position++
|
|
goto l152
|
|
l153:
|
|
position, tokenIndex = position152, tokenIndex152
|
|
if buffer[position] != rune('S') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l152:
|
|
{
|
|
add(ruleAction16, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l145
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l145
|
|
}
|
|
{
|
|
position155, tokenIndex155 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l155
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l155
|
|
}
|
|
goto l156
|
|
l155:
|
|
position, tokenIndex = position155, tokenIndex155
|
|
}
|
|
l156:
|
|
if !_rules[ruleclose]() {
|
|
goto l145
|
|
}
|
|
{
|
|
add(ruleAction17, position)
|
|
}
|
|
goto l7
|
|
l145:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position159, tokenIndex159 := position, tokenIndex
|
|
if buffer[position] != rune('m') {
|
|
goto l160
|
|
}
|
|
position++
|
|
goto l159
|
|
l160:
|
|
position, tokenIndex = position159, tokenIndex159
|
|
if buffer[position] != rune('M') {
|
|
goto l158
|
|
}
|
|
position++
|
|
}
|
|
l159:
|
|
{
|
|
position161, tokenIndex161 := position, tokenIndex
|
|
if buffer[position] != rune('i') {
|
|
goto l162
|
|
}
|
|
position++
|
|
goto l161
|
|
l162:
|
|
position, tokenIndex = position161, tokenIndex161
|
|
if buffer[position] != rune('I') {
|
|
goto l158
|
|
}
|
|
position++
|
|
}
|
|
l161:
|
|
{
|
|
position163, tokenIndex163 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l164
|
|
}
|
|
position++
|
|
goto l163
|
|
l164:
|
|
position, tokenIndex = position163, tokenIndex163
|
|
if buffer[position] != rune('N') {
|
|
goto l158
|
|
}
|
|
position++
|
|
}
|
|
l163:
|
|
{
|
|
add(ruleAction18, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l158
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l158
|
|
}
|
|
{
|
|
position166, tokenIndex166 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l166
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l166
|
|
}
|
|
goto l167
|
|
l166:
|
|
position, tokenIndex = position166, tokenIndex166
|
|
}
|
|
l167:
|
|
if !_rules[ruleclose]() {
|
|
goto l158
|
|
}
|
|
{
|
|
add(ruleAction19, position)
|
|
}
|
|
goto l7
|
|
l158:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position170, tokenIndex170 := position, tokenIndex
|
|
if buffer[position] != rune('m') {
|
|
goto l171
|
|
}
|
|
position++
|
|
goto l170
|
|
l171:
|
|
position, tokenIndex = position170, tokenIndex170
|
|
if buffer[position] != rune('M') {
|
|
goto l169
|
|
}
|
|
position++
|
|
}
|
|
l170:
|
|
{
|
|
position172, tokenIndex172 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l173
|
|
}
|
|
position++
|
|
goto l172
|
|
l173:
|
|
position, tokenIndex = position172, tokenIndex172
|
|
if buffer[position] != rune('A') {
|
|
goto l169
|
|
}
|
|
position++
|
|
}
|
|
l172:
|
|
{
|
|
position174, tokenIndex174 := position, tokenIndex
|
|
if buffer[position] != rune('x') {
|
|
goto l175
|
|
}
|
|
position++
|
|
goto l174
|
|
l175:
|
|
position, tokenIndex = position174, tokenIndex174
|
|
if buffer[position] != rune('X') {
|
|
goto l169
|
|
}
|
|
position++
|
|
}
|
|
l174:
|
|
{
|
|
add(ruleAction20, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l169
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l169
|
|
}
|
|
{
|
|
position177, tokenIndex177 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l177
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l177
|
|
}
|
|
goto l178
|
|
l177:
|
|
position, tokenIndex = position177, tokenIndex177
|
|
}
|
|
l178:
|
|
if !_rules[ruleclose]() {
|
|
goto l169
|
|
}
|
|
{
|
|
add(ruleAction21, position)
|
|
}
|
|
goto l7
|
|
l169:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position181, tokenIndex181 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l182
|
|
}
|
|
position++
|
|
goto l181
|
|
l182:
|
|
position, tokenIndex = position181, tokenIndex181
|
|
if buffer[position] != rune('S') {
|
|
goto l180
|
|
}
|
|
position++
|
|
}
|
|
l181:
|
|
{
|
|
position183, tokenIndex183 := position, tokenIndex
|
|
if buffer[position] != rune('u') {
|
|
goto l184
|
|
}
|
|
position++
|
|
goto l183
|
|
l184:
|
|
position, tokenIndex = position183, tokenIndex183
|
|
if buffer[position] != rune('U') {
|
|
goto l180
|
|
}
|
|
position++
|
|
}
|
|
l183:
|
|
{
|
|
position185, tokenIndex185 := position, tokenIndex
|
|
if buffer[position] != rune('m') {
|
|
goto l186
|
|
}
|
|
position++
|
|
goto l185
|
|
l186:
|
|
position, tokenIndex = position185, tokenIndex185
|
|
if buffer[position] != rune('M') {
|
|
goto l180
|
|
}
|
|
position++
|
|
}
|
|
l185:
|
|
{
|
|
add(ruleAction22, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l180
|
|
}
|
|
if !_rules[ruleposfield]() {
|
|
goto l180
|
|
}
|
|
{
|
|
position188, tokenIndex188 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l188
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l188
|
|
}
|
|
goto l189
|
|
l188:
|
|
position, tokenIndex = position188, tokenIndex188
|
|
}
|
|
l189:
|
|
if !_rules[ruleclose]() {
|
|
goto l180
|
|
}
|
|
{
|
|
add(ruleAction23, position)
|
|
}
|
|
goto l7
|
|
l180:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position192, tokenIndex192 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l193
|
|
}
|
|
position++
|
|
goto l192
|
|
l193:
|
|
position, tokenIndex = position192, tokenIndex192
|
|
if buffer[position] != rune('R') {
|
|
goto l191
|
|
}
|
|
position++
|
|
}
|
|
l192:
|
|
{
|
|
position194, tokenIndex194 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l195
|
|
}
|
|
position++
|
|
goto l194
|
|
l195:
|
|
position, tokenIndex = position194, tokenIndex194
|
|
if buffer[position] != rune('A') {
|
|
goto l191
|
|
}
|
|
position++
|
|
}
|
|
l194:
|
|
{
|
|
position196, tokenIndex196 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l197
|
|
}
|
|
position++
|
|
goto l196
|
|
l197:
|
|
position, tokenIndex = position196, tokenIndex196
|
|
if buffer[position] != rune('N') {
|
|
goto l191
|
|
}
|
|
position++
|
|
}
|
|
l196:
|
|
{
|
|
position198, tokenIndex198 := position, tokenIndex
|
|
if buffer[position] != rune('g') {
|
|
goto l199
|
|
}
|
|
position++
|
|
goto l198
|
|
l199:
|
|
position, tokenIndex = position198, tokenIndex198
|
|
if buffer[position] != rune('G') {
|
|
goto l191
|
|
}
|
|
position++
|
|
}
|
|
l198:
|
|
{
|
|
position200, tokenIndex200 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l201
|
|
}
|
|
position++
|
|
goto l200
|
|
l201:
|
|
position, tokenIndex = position200, tokenIndex200
|
|
if buffer[position] != rune('E') {
|
|
goto l191
|
|
}
|
|
position++
|
|
}
|
|
l200:
|
|
{
|
|
add(ruleAction24, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l191
|
|
}
|
|
if !_rules[rulefield]() {
|
|
goto l191
|
|
}
|
|
if !_rules[ruleeq]() {
|
|
goto l191
|
|
}
|
|
if !_rules[rulevalue]() {
|
|
goto l191
|
|
}
|
|
if !_rules[rulecomma]() {
|
|
goto l191
|
|
}
|
|
{
|
|
position203, tokenIndex203 := position, tokenIndex
|
|
if buffer[position] != rune('f') {
|
|
goto l203
|
|
}
|
|
position++
|
|
if buffer[position] != rune('r') {
|
|
goto l203
|
|
}
|
|
position++
|
|
if buffer[position] != rune('o') {
|
|
goto l203
|
|
}
|
|
position++
|
|
if buffer[position] != rune('m') {
|
|
goto l203
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l203
|
|
}
|
|
position++
|
|
goto l204
|
|
l203:
|
|
position, tokenIndex = position203, tokenIndex203
|
|
}
|
|
l204:
|
|
{
|
|
add(ruleAction25, position)
|
|
}
|
|
if !_rules[ruletimefmt]() {
|
|
goto l191
|
|
}
|
|
{
|
|
add(ruleAction26, position)
|
|
}
|
|
if !_rules[rulecomma]() {
|
|
goto l191
|
|
}
|
|
{
|
|
position207, tokenIndex207 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l207
|
|
}
|
|
position++
|
|
if buffer[position] != rune('o') {
|
|
goto l207
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l207
|
|
}
|
|
position++
|
|
goto l208
|
|
l207:
|
|
position, tokenIndex = position207, tokenIndex207
|
|
}
|
|
l208:
|
|
if !_rules[rulesp]() {
|
|
goto l191
|
|
}
|
|
{
|
|
add(ruleAction27, position)
|
|
}
|
|
if !_rules[ruletimefmt]() {
|
|
goto l191
|
|
}
|
|
{
|
|
add(ruleAction28, position)
|
|
}
|
|
if !_rules[ruleclose]() {
|
|
goto l191
|
|
}
|
|
{
|
|
add(ruleAction29, position)
|
|
}
|
|
goto l7
|
|
l191:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
{
|
|
position212 := position
|
|
if !_rules[ruleIDENT]() {
|
|
goto l5
|
|
}
|
|
add(rulePegText, position212)
|
|
}
|
|
{
|
|
add(ruleAction30, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l5
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l5
|
|
}
|
|
{
|
|
position214, tokenIndex214 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l214
|
|
}
|
|
goto l215
|
|
l214:
|
|
position, tokenIndex = position214, tokenIndex214
|
|
}
|
|
l215:
|
|
if !_rules[ruleclose]() {
|
|
goto l5
|
|
}
|
|
{
|
|
add(ruleAction31, position)
|
|
}
|
|
}
|
|
l7:
|
|
add(ruleCall, position6)
|
|
}
|
|
return true
|
|
l5:
|
|
position, tokenIndex = position5, tokenIndex5
|
|
return false
|
|
},
|
|
/* 2 ivyExpr <- <('(' / '_' / '/' / '[' / ']' / '.' / '=' / '&' / '<' / '>' / ',' / ')' / '^' / '!' / '|' / ('*' / '+') / '-' / '?' / ([a-z] / [A-Z]) / [0-9] / '#' / (' ' / '\t' / '\n'))*> */
|
|
func() bool {
|
|
{
|
|
position218 := position
|
|
l219:
|
|
{
|
|
position220, tokenIndex220 := position, tokenIndex
|
|
{
|
|
position221, tokenIndex221 := position, tokenIndex
|
|
if buffer[position] != rune('(') {
|
|
goto l222
|
|
}
|
|
position++
|
|
goto l221
|
|
l222:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('_') {
|
|
goto l223
|
|
}
|
|
position++
|
|
goto l221
|
|
l223:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('/') {
|
|
goto l224
|
|
}
|
|
position++
|
|
goto l221
|
|
l224:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('[') {
|
|
goto l225
|
|
}
|
|
position++
|
|
goto l221
|
|
l225:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune(']') {
|
|
goto l226
|
|
}
|
|
position++
|
|
goto l221
|
|
l226:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('.') {
|
|
goto l227
|
|
}
|
|
position++
|
|
goto l221
|
|
l227:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('=') {
|
|
goto l228
|
|
}
|
|
position++
|
|
goto l221
|
|
l228:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('&') {
|
|
goto l229
|
|
}
|
|
position++
|
|
goto l221
|
|
l229:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('<') {
|
|
goto l230
|
|
}
|
|
position++
|
|
goto l221
|
|
l230:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('>') {
|
|
goto l231
|
|
}
|
|
position++
|
|
goto l221
|
|
l231:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune(',') {
|
|
goto l232
|
|
}
|
|
position++
|
|
goto l221
|
|
l232:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune(')') {
|
|
goto l233
|
|
}
|
|
position++
|
|
goto l221
|
|
l233:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('^') {
|
|
goto l234
|
|
}
|
|
position++
|
|
goto l221
|
|
l234:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('!') {
|
|
goto l235
|
|
}
|
|
position++
|
|
goto l221
|
|
l235:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('|') {
|
|
goto l236
|
|
}
|
|
position++
|
|
goto l221
|
|
l236:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
{
|
|
position238, tokenIndex238 := position, tokenIndex
|
|
if buffer[position] != rune('*') {
|
|
goto l239
|
|
}
|
|
position++
|
|
goto l238
|
|
l239:
|
|
position, tokenIndex = position238, tokenIndex238
|
|
if buffer[position] != rune('+') {
|
|
goto l237
|
|
}
|
|
position++
|
|
}
|
|
l238:
|
|
goto l221
|
|
l237:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('-') {
|
|
goto l240
|
|
}
|
|
position++
|
|
goto l221
|
|
l240:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('?') {
|
|
goto l241
|
|
}
|
|
position++
|
|
goto l221
|
|
l241:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
{
|
|
position243, tokenIndex243 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l244
|
|
}
|
|
position++
|
|
goto l243
|
|
l244:
|
|
position, tokenIndex = position243, tokenIndex243
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l242
|
|
}
|
|
position++
|
|
}
|
|
l243:
|
|
goto l221
|
|
l242:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l245
|
|
}
|
|
position++
|
|
goto l221
|
|
l245:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('#') {
|
|
goto l246
|
|
}
|
|
position++
|
|
goto l221
|
|
l246:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
{
|
|
position247, tokenIndex247 := position, tokenIndex
|
|
if buffer[position] != rune(' ') {
|
|
goto l248
|
|
}
|
|
position++
|
|
goto l247
|
|
l248:
|
|
position, tokenIndex = position247, tokenIndex247
|
|
if buffer[position] != rune('\t') {
|
|
goto l249
|
|
}
|
|
position++
|
|
goto l247
|
|
l249:
|
|
position, tokenIndex = position247, tokenIndex247
|
|
if buffer[position] != rune('\n') {
|
|
goto l220
|
|
}
|
|
position++
|
|
}
|
|
l247:
|
|
}
|
|
l221:
|
|
goto l219
|
|
l220:
|
|
position, tokenIndex = position220, tokenIndex220
|
|
}
|
|
add(ruleivyExpr, position218)
|
|
}
|
|
return true
|
|
},
|
|
/* 3 ivyprogram <- <('"'? <ivyExpr> '"' Action32)> */
|
|
nil,
|
|
/* 4 ivyprogram2 <- <('"'? <ivyExpr> '"' Action33)> */
|
|
nil,
|
|
/* 5 allargs <- <((Call (comma Call)* (comma args)?) / args / sp)> */
|
|
func() bool {
|
|
position252, tokenIndex252 := position, tokenIndex
|
|
{
|
|
position253 := position
|
|
{
|
|
position254, tokenIndex254 := position, tokenIndex
|
|
if !_rules[ruleCall]() {
|
|
goto l255
|
|
}
|
|
l256:
|
|
{
|
|
position257, tokenIndex257 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l257
|
|
}
|
|
if !_rules[ruleCall]() {
|
|
goto l257
|
|
}
|
|
goto l256
|
|
l257:
|
|
position, tokenIndex = position257, tokenIndex257
|
|
}
|
|
{
|
|
position258, tokenIndex258 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l258
|
|
}
|
|
if !_rules[ruleargs]() {
|
|
goto l258
|
|
}
|
|
goto l259
|
|
l258:
|
|
position, tokenIndex = position258, tokenIndex258
|
|
}
|
|
l259:
|
|
goto l254
|
|
l255:
|
|
position, tokenIndex = position254, tokenIndex254
|
|
if !_rules[ruleargs]() {
|
|
goto l260
|
|
}
|
|
goto l254
|
|
l260:
|
|
position, tokenIndex = position254, tokenIndex254
|
|
if !_rules[rulesp]() {
|
|
goto l252
|
|
}
|
|
}
|
|
l254:
|
|
add(ruleallargs, position253)
|
|
}
|
|
return true
|
|
l252:
|
|
position, tokenIndex = position252, tokenIndex252
|
|
return false
|
|
},
|
|
/* 6 args <- <(arg (comma args)? sp)> */
|
|
func() bool {
|
|
position261, tokenIndex261 := position, tokenIndex
|
|
{
|
|
position262 := position
|
|
if !_rules[rulearg]() {
|
|
goto l261
|
|
}
|
|
{
|
|
position263, tokenIndex263 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l263
|
|
}
|
|
if !_rules[ruleargs]() {
|
|
goto l263
|
|
}
|
|
goto l264
|
|
l263:
|
|
position, tokenIndex = position263, tokenIndex263
|
|
}
|
|
l264:
|
|
if !_rules[rulesp]() {
|
|
goto l261
|
|
}
|
|
add(ruleargs, position262)
|
|
}
|
|
return true
|
|
l261:
|
|
position, tokenIndex = position261, tokenIndex261
|
|
return false
|
|
},
|
|
/* 7 arg <- <((field eq value) / (field sp COND sp value) / conditional)> */
|
|
func() bool {
|
|
position265, tokenIndex265 := position, tokenIndex
|
|
{
|
|
position266 := position
|
|
{
|
|
position267, tokenIndex267 := position, tokenIndex
|
|
if !_rules[rulefield]() {
|
|
goto l268
|
|
}
|
|
if !_rules[ruleeq]() {
|
|
goto l268
|
|
}
|
|
if !_rules[rulevalue]() {
|
|
goto l268
|
|
}
|
|
goto l267
|
|
l268:
|
|
position, tokenIndex = position267, tokenIndex267
|
|
if !_rules[rulefield]() {
|
|
goto l269
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l269
|
|
}
|
|
{
|
|
position270 := position
|
|
{
|
|
position271, tokenIndex271 := position, tokenIndex
|
|
if buffer[position] != rune('>') {
|
|
goto l272
|
|
}
|
|
position++
|
|
if buffer[position] != rune('<') {
|
|
goto l272
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction34, position)
|
|
}
|
|
goto l271
|
|
l272:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
if buffer[position] != rune('<') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l274
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction35, position)
|
|
}
|
|
goto l271
|
|
l274:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
if buffer[position] != rune('>') {
|
|
goto l276
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l276
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction36, position)
|
|
}
|
|
goto l271
|
|
l276:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
if buffer[position] != rune('=') {
|
|
goto l278
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l278
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction37, position)
|
|
}
|
|
goto l271
|
|
l278:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
if buffer[position] != rune('!') {
|
|
goto l280
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l280
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction38, position)
|
|
}
|
|
goto l271
|
|
l280:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
if buffer[position] != rune('<') {
|
|
goto l282
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction39, position)
|
|
}
|
|
goto l271
|
|
l282:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
if buffer[position] != rune('>') {
|
|
goto l269
|
|
}
|
|
position++
|
|
{
|
|
add(ruleAction40, position)
|
|
}
|
|
}
|
|
l271:
|
|
add(ruleCOND, position270)
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l269
|
|
}
|
|
if !_rules[rulevalue]() {
|
|
goto l269
|
|
}
|
|
goto l267
|
|
l269:
|
|
position, tokenIndex = position267, tokenIndex267
|
|
{
|
|
position285 := position
|
|
{
|
|
add(ruleAction41, position)
|
|
}
|
|
if !_rules[rulecondintOrTime]() {
|
|
goto l265
|
|
}
|
|
if !_rules[rulecondLT]() {
|
|
goto l265
|
|
}
|
|
{
|
|
position287 := position
|
|
{
|
|
position288 := position
|
|
if !_rules[rulefieldExpr]() {
|
|
goto l265
|
|
}
|
|
add(rulePegText, position288)
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l265
|
|
}
|
|
{
|
|
add(ruleAction46, position)
|
|
}
|
|
add(rulecondfield, position287)
|
|
}
|
|
if !_rules[rulecondLT]() {
|
|
goto l265
|
|
}
|
|
if !_rules[rulecondintOrTime]() {
|
|
goto l265
|
|
}
|
|
{
|
|
add(ruleAction42, position)
|
|
}
|
|
add(ruleconditional, position285)
|
|
}
|
|
}
|
|
l267:
|
|
add(rulearg, position266)
|
|
}
|
|
return true
|
|
l265:
|
|
position, tokenIndex = position265, tokenIndex265
|
|
return false
|
|
},
|
|
/* 8 COND <- <(('>' '<' Action34) / ('<' '=' Action35) / ('>' '=' Action36) / ('=' '=' Action37) / ('!' '=' Action38) / ('<' Action39) / ('>' Action40))> */
|
|
nil,
|
|
/* 9 conditional <- <(Action41 condintOrTime condLT condfield condLT condintOrTime Action42)> */
|
|
nil,
|
|
/* 10 condintOrTime <- <(condint / timefmtS)> */
|
|
func() bool {
|
|
position293, tokenIndex293 := position, tokenIndex
|
|
{
|
|
position294 := position
|
|
{
|
|
position295, tokenIndex295 := position, tokenIndex
|
|
{
|
|
position297 := position
|
|
{
|
|
position298 := position
|
|
if !_rules[ruledecimal]() {
|
|
goto l296
|
|
}
|
|
add(rulePegText, position298)
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l296
|
|
}
|
|
{
|
|
add(ruleAction44, position)
|
|
}
|
|
add(rulecondint, position297)
|
|
}
|
|
goto l295
|
|
l296:
|
|
position, tokenIndex = position295, tokenIndex295
|
|
{
|
|
position300 := position
|
|
{
|
|
position301 := position
|
|
if !_rules[ruletimestampfmt]() {
|
|
goto l293
|
|
}
|
|
add(rulePegText, position301)
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l293
|
|
}
|
|
{
|
|
add(ruleAction43, position)
|
|
}
|
|
add(ruletimefmtS, position300)
|
|
}
|
|
}
|
|
l295:
|
|
add(rulecondintOrTime, position294)
|
|
}
|
|
return true
|
|
l293:
|
|
position, tokenIndex = position293, tokenIndex293
|
|
return false
|
|
},
|
|
/* 11 timefmtS <- <(<timestampfmt> sp Action43)> */
|
|
nil,
|
|
/* 12 condint <- <(<decimal> sp Action44)> */
|
|
nil,
|
|
/* 13 condLT <- <(<(('<' '=') / '<')> sp Action45)> */
|
|
func() bool {
|
|
position305, tokenIndex305 := position, tokenIndex
|
|
{
|
|
position306 := position
|
|
{
|
|
position307 := position
|
|
{
|
|
position308, tokenIndex308 := position, tokenIndex
|
|
if buffer[position] != rune('<') {
|
|
goto l309
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l309
|
|
}
|
|
position++
|
|
goto l308
|
|
l309:
|
|
position, tokenIndex = position308, tokenIndex308
|
|
if buffer[position] != rune('<') {
|
|
goto l305
|
|
}
|
|
position++
|
|
}
|
|
l308:
|
|
add(rulePegText, position307)
|
|
}
|
|
if !_rules[rulesp]() {
|
|
goto l305
|
|
}
|
|
{
|
|
add(ruleAction45, position)
|
|
}
|
|
add(rulecondLT, position306)
|
|
}
|
|
return true
|
|
l305:
|
|
position, tokenIndex = position305, tokenIndex305
|
|
return false
|
|
},
|
|
/* 14 condfield <- <(<fieldExpr> sp Action46)> */
|
|
nil,
|
|
/* 15 value <- <(item / (lbrack Action47 items rbrack Action48))> */
|
|
func() bool {
|
|
position312, tokenIndex312 := position, tokenIndex
|
|
{
|
|
position313 := position
|
|
{
|
|
position314, tokenIndex314 := position, tokenIndex
|
|
if !_rules[ruleitem]() {
|
|
goto l315
|
|
}
|
|
goto l314
|
|
l315:
|
|
position, tokenIndex = position314, tokenIndex314
|
|
{
|
|
position316 := position
|
|
if buffer[position] != rune('[') {
|
|
goto l312
|
|
}
|
|
position++
|
|
if !_rules[rulesp]() {
|
|
goto l312
|
|
}
|
|
add(rulelbrack, position316)
|
|
}
|
|
{
|
|
add(ruleAction47, position)
|
|
}
|
|
if !_rules[ruleitems]() {
|
|
goto l312
|
|
}
|
|
{
|
|
position318 := position
|
|
if !_rules[rulesp]() {
|
|
goto l312
|
|
}
|
|
if buffer[position] != rune(']') {
|
|
goto l312
|
|
}
|
|
position++
|
|
if !_rules[rulesp]() {
|
|
goto l312
|
|
}
|
|
add(rulerbrack, position318)
|
|
}
|
|
{
|
|
add(ruleAction48, position)
|
|
}
|
|
}
|
|
l314:
|
|
add(rulevalue, position313)
|
|
}
|
|
return true
|
|
l312:
|
|
position, tokenIndex = position312, tokenIndex312
|
|
return false
|
|
},
|
|
/* 16 items <- <(item (comma items)?)> */
|
|
func() bool {
|
|
position320, tokenIndex320 := position, tokenIndex
|
|
{
|
|
position321 := position
|
|
if !_rules[ruleitem]() {
|
|
goto l320
|
|
}
|
|
{
|
|
position322, tokenIndex322 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l322
|
|
}
|
|
if !_rules[ruleitems]() {
|
|
goto l322
|
|
}
|
|
goto l323
|
|
l322:
|
|
position, tokenIndex = position322, tokenIndex322
|
|
}
|
|
l323:
|
|
add(ruleitems, position321)
|
|
}
|
|
return true
|
|
l320:
|
|
position, tokenIndex = position320, tokenIndex320
|
|
return false
|
|
},
|
|
/* 17 item <- <(('n' 'u' 'l' 'l' &(comma / close) Action49) / ('t' 'r' 'u' 'e' &(comma / close) Action50) / ('f' 'a' 'l' 's' 'e' &(comma / close) Action51) / ('$' <variable> Action52) / (timefmt Action53) / (timestampfmt Action54) / (<decimal> Action55) / (<IDENT> Action56 open allargs comma? close Action57) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action58) / (<('"' doublequotedstring '"')> Action59) / (<('\'' singlequotedstring '\'')> Action60))> */
|
|
func() bool {
|
|
position324, tokenIndex324 := position, tokenIndex
|
|
{
|
|
position325 := position
|
|
{
|
|
position326, tokenIndex326 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l327
|
|
}
|
|
position++
|
|
if buffer[position] != rune('u') {
|
|
goto l327
|
|
}
|
|
position++
|
|
if buffer[position] != rune('l') {
|
|
goto l327
|
|
}
|
|
position++
|
|
if buffer[position] != rune('l') {
|
|
goto l327
|
|
}
|
|
position++
|
|
{
|
|
position328, tokenIndex328 := position, tokenIndex
|
|
{
|
|
position329, tokenIndex329 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l330
|
|
}
|
|
goto l329
|
|
l330:
|
|
position, tokenIndex = position329, tokenIndex329
|
|
if !_rules[ruleclose]() {
|
|
goto l327
|
|
}
|
|
}
|
|
l329:
|
|
position, tokenIndex = position328, tokenIndex328
|
|
}
|
|
{
|
|
add(ruleAction49, position)
|
|
}
|
|
goto l326
|
|
l327:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
if buffer[position] != rune('t') {
|
|
goto l332
|
|
}
|
|
position++
|
|
if buffer[position] != rune('r') {
|
|
goto l332
|
|
}
|
|
position++
|
|
if buffer[position] != rune('u') {
|
|
goto l332
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l332
|
|
}
|
|
position++
|
|
{
|
|
position333, tokenIndex333 := position, tokenIndex
|
|
{
|
|
position334, tokenIndex334 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l335
|
|
}
|
|
goto l334
|
|
l335:
|
|
position, tokenIndex = position334, tokenIndex334
|
|
if !_rules[ruleclose]() {
|
|
goto l332
|
|
}
|
|
}
|
|
l334:
|
|
position, tokenIndex = position333, tokenIndex333
|
|
}
|
|
{
|
|
add(ruleAction50, position)
|
|
}
|
|
goto l326
|
|
l332:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
if buffer[position] != rune('f') {
|
|
goto l337
|
|
}
|
|
position++
|
|
if buffer[position] != rune('a') {
|
|
goto l337
|
|
}
|
|
position++
|
|
if buffer[position] != rune('l') {
|
|
goto l337
|
|
}
|
|
position++
|
|
if buffer[position] != rune('s') {
|
|
goto l337
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l337
|
|
}
|
|
position++
|
|
{
|
|
position338, tokenIndex338 := position, tokenIndex
|
|
{
|
|
position339, tokenIndex339 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l340
|
|
}
|
|
goto l339
|
|
l340:
|
|
position, tokenIndex = position339, tokenIndex339
|
|
if !_rules[ruleclose]() {
|
|
goto l337
|
|
}
|
|
}
|
|
l339:
|
|
position, tokenIndex = position338, tokenIndex338
|
|
}
|
|
{
|
|
add(ruleAction51, position)
|
|
}
|
|
goto l326
|
|
l337:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
if buffer[position] != rune('$') {
|
|
goto l342
|
|
}
|
|
position++
|
|
{
|
|
position343 := position
|
|
{
|
|
position344 := position
|
|
{
|
|
position345, tokenIndex345 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l346
|
|
}
|
|
position++
|
|
goto l345
|
|
l346:
|
|
position, tokenIndex = position345, tokenIndex345
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l347
|
|
}
|
|
position++
|
|
goto l345
|
|
l347:
|
|
position, tokenIndex = position345, tokenIndex345
|
|
if buffer[position] != rune('_') {
|
|
goto l342
|
|
}
|
|
position++
|
|
}
|
|
l345:
|
|
l348:
|
|
{
|
|
position349, tokenIndex349 := position, tokenIndex
|
|
{
|
|
position350, tokenIndex350 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l351
|
|
}
|
|
position++
|
|
goto l350
|
|
l351:
|
|
position, tokenIndex = position350, tokenIndex350
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l352
|
|
}
|
|
position++
|
|
goto l350
|
|
l352:
|
|
position, tokenIndex = position350, tokenIndex350
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l353
|
|
}
|
|
position++
|
|
goto l350
|
|
l353:
|
|
position, tokenIndex = position350, tokenIndex350
|
|
if buffer[position] != rune('_') {
|
|
goto l354
|
|
}
|
|
position++
|
|
goto l350
|
|
l354:
|
|
position, tokenIndex = position350, tokenIndex350
|
|
if buffer[position] != rune('-') {
|
|
goto l349
|
|
}
|
|
position++
|
|
}
|
|
l350:
|
|
goto l348
|
|
l349:
|
|
position, tokenIndex = position349, tokenIndex349
|
|
}
|
|
add(rulevariable, position344)
|
|
}
|
|
add(rulePegText, position343)
|
|
}
|
|
{
|
|
add(ruleAction52, position)
|
|
}
|
|
goto l326
|
|
l342:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
if !_rules[ruletimefmt]() {
|
|
goto l356
|
|
}
|
|
{
|
|
add(ruleAction53, position)
|
|
}
|
|
goto l326
|
|
l356:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
if !_rules[ruletimestampfmt]() {
|
|
goto l358
|
|
}
|
|
{
|
|
add(ruleAction54, position)
|
|
}
|
|
goto l326
|
|
l358:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
{
|
|
position361 := position
|
|
if !_rules[ruledecimal]() {
|
|
goto l360
|
|
}
|
|
add(rulePegText, position361)
|
|
}
|
|
{
|
|
add(ruleAction55, position)
|
|
}
|
|
goto l326
|
|
l360:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
{
|
|
position364 := position
|
|
if !_rules[ruleIDENT]() {
|
|
goto l363
|
|
}
|
|
add(rulePegText, position364)
|
|
}
|
|
{
|
|
add(ruleAction56, position)
|
|
}
|
|
if !_rules[ruleopen]() {
|
|
goto l363
|
|
}
|
|
if !_rules[ruleallargs]() {
|
|
goto l363
|
|
}
|
|
{
|
|
position366, tokenIndex366 := position, tokenIndex
|
|
if !_rules[rulecomma]() {
|
|
goto l366
|
|
}
|
|
goto l367
|
|
l366:
|
|
position, tokenIndex = position366, tokenIndex366
|
|
}
|
|
l367:
|
|
if !_rules[ruleclose]() {
|
|
goto l363
|
|
}
|
|
{
|
|
add(ruleAction57, position)
|
|
}
|
|
goto l326
|
|
l363:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
{
|
|
position370 := position
|
|
{
|
|
position373, tokenIndex373 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l374
|
|
}
|
|
position++
|
|
goto l373
|
|
l374:
|
|
position, tokenIndex = position373, tokenIndex373
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l375
|
|
}
|
|
position++
|
|
goto l373
|
|
l375:
|
|
position, tokenIndex = position373, tokenIndex373
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l376
|
|
}
|
|
position++
|
|
goto l373
|
|
l376:
|
|
position, tokenIndex = position373, tokenIndex373
|
|
if buffer[position] != rune('-') {
|
|
goto l377
|
|
}
|
|
position++
|
|
goto l373
|
|
l377:
|
|
position, tokenIndex = position373, tokenIndex373
|
|
if buffer[position] != rune('_') {
|
|
goto l378
|
|
}
|
|
position++
|
|
goto l373
|
|
l378:
|
|
position, tokenIndex = position373, tokenIndex373
|
|
if buffer[position] != rune(':') {
|
|
goto l369
|
|
}
|
|
position++
|
|
}
|
|
l373:
|
|
l371:
|
|
{
|
|
position372, tokenIndex372 := position, tokenIndex
|
|
{
|
|
position379, tokenIndex379 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l380
|
|
}
|
|
position++
|
|
goto l379
|
|
l380:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l381
|
|
}
|
|
position++
|
|
goto l379
|
|
l381:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l382
|
|
}
|
|
position++
|
|
goto l379
|
|
l382:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if buffer[position] != rune('-') {
|
|
goto l383
|
|
}
|
|
position++
|
|
goto l379
|
|
l383:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if buffer[position] != rune('_') {
|
|
goto l384
|
|
}
|
|
position++
|
|
goto l379
|
|
l384:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if buffer[position] != rune(':') {
|
|
goto l372
|
|
}
|
|
position++
|
|
}
|
|
l379:
|
|
goto l371
|
|
l372:
|
|
position, tokenIndex = position372, tokenIndex372
|
|
}
|
|
add(rulePegText, position370)
|
|
}
|
|
{
|
|
add(ruleAction58, position)
|
|
}
|
|
goto l326
|
|
l369:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
{
|
|
position387 := position
|
|
if buffer[position] != rune('"') {
|
|
goto l386
|
|
}
|
|
position++
|
|
if !_rules[ruledoublequotedstring]() {
|
|
goto l386
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l386
|
|
}
|
|
position++
|
|
add(rulePegText, position387)
|
|
}
|
|
{
|
|
add(ruleAction59, position)
|
|
}
|
|
goto l326
|
|
l386:
|
|
position, tokenIndex = position326, tokenIndex326
|
|
{
|
|
position389 := position
|
|
if buffer[position] != rune('\'') {
|
|
goto l324
|
|
}
|
|
position++
|
|
if !_rules[rulesinglequotedstring]() {
|
|
goto l324
|
|
}
|
|
if buffer[position] != rune('\'') {
|
|
goto l324
|
|
}
|
|
position++
|
|
add(rulePegText, position389)
|
|
}
|
|
{
|
|
add(ruleAction60, position)
|
|
}
|
|
}
|
|
l326:
|
|
add(ruleitem, position325)
|
|
}
|
|
return true
|
|
l324:
|
|
position, tokenIndex = position324, tokenIndex324
|
|
return false
|
|
},
|
|
/* 18 doublequotedstring <- <(('\\' '"') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('"' / '\\') .))*> */
|
|
func() bool {
|
|
{
|
|
position392 := position
|
|
l393:
|
|
{
|
|
position394, tokenIndex394 := position, tokenIndex
|
|
{
|
|
position395, tokenIndex395 := position, tokenIndex
|
|
if buffer[position] != rune('\\') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('"') {
|
|
goto l396
|
|
}
|
|
position++
|
|
goto l395
|
|
l396:
|
|
position, tokenIndex = position395, tokenIndex395
|
|
if buffer[position] != rune('\\') {
|
|
goto l397
|
|
}
|
|
position++
|
|
if buffer[position] != rune('\\') {
|
|
goto l397
|
|
}
|
|
position++
|
|
goto l395
|
|
l397:
|
|
position, tokenIndex = position395, tokenIndex395
|
|
if buffer[position] != rune('\\') {
|
|
goto l398
|
|
}
|
|
position++
|
|
if buffer[position] != rune('n') {
|
|
goto l398
|
|
}
|
|
position++
|
|
goto l395
|
|
l398:
|
|
position, tokenIndex = position395, tokenIndex395
|
|
if buffer[position] != rune('\\') {
|
|
goto l399
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l399
|
|
}
|
|
position++
|
|
goto l395
|
|
l399:
|
|
position, tokenIndex = position395, tokenIndex395
|
|
{
|
|
position400, tokenIndex400 := position, tokenIndex
|
|
{
|
|
position401, tokenIndex401 := position, tokenIndex
|
|
if buffer[position] != rune('"') {
|
|
goto l402
|
|
}
|
|
position++
|
|
goto l401
|
|
l402:
|
|
position, tokenIndex = position401, tokenIndex401
|
|
if buffer[position] != rune('\\') {
|
|
goto l400
|
|
}
|
|
position++
|
|
}
|
|
l401:
|
|
goto l394
|
|
l400:
|
|
position, tokenIndex = position400, tokenIndex400
|
|
}
|
|
if !matchDot() {
|
|
goto l394
|
|
}
|
|
}
|
|
l395:
|
|
goto l393
|
|
l394:
|
|
position, tokenIndex = position394, tokenIndex394
|
|
}
|
|
add(ruledoublequotedstring, position392)
|
|
}
|
|
return true
|
|
},
|
|
/* 19 singlequotedstring <- <(('\\' '\'') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('\'' / '\\') .))*> */
|
|
func() bool {
|
|
{
|
|
position404 := position
|
|
l405:
|
|
{
|
|
position406, tokenIndex406 := position, tokenIndex
|
|
{
|
|
position407, tokenIndex407 := position, tokenIndex
|
|
if buffer[position] != rune('\\') {
|
|
goto l408
|
|
}
|
|
position++
|
|
if buffer[position] != rune('\'') {
|
|
goto l408
|
|
}
|
|
position++
|
|
goto l407
|
|
l408:
|
|
position, tokenIndex = position407, tokenIndex407
|
|
if buffer[position] != rune('\\') {
|
|
goto l409
|
|
}
|
|
position++
|
|
if buffer[position] != rune('\\') {
|
|
goto l409
|
|
}
|
|
position++
|
|
goto l407
|
|
l409:
|
|
position, tokenIndex = position407, tokenIndex407
|
|
if buffer[position] != rune('\\') {
|
|
goto l410
|
|
}
|
|
position++
|
|
if buffer[position] != rune('n') {
|
|
goto l410
|
|
}
|
|
position++
|
|
goto l407
|
|
l410:
|
|
position, tokenIndex = position407, tokenIndex407
|
|
if buffer[position] != rune('\\') {
|
|
goto l411
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l411
|
|
}
|
|
position++
|
|
goto l407
|
|
l411:
|
|
position, tokenIndex = position407, tokenIndex407
|
|
{
|
|
position412, tokenIndex412 := position, tokenIndex
|
|
{
|
|
position413, tokenIndex413 := position, tokenIndex
|
|
if buffer[position] != rune('\'') {
|
|
goto l414
|
|
}
|
|
position++
|
|
goto l413
|
|
l414:
|
|
position, tokenIndex = position413, tokenIndex413
|
|
if buffer[position] != rune('\\') {
|
|
goto l412
|
|
}
|
|
position++
|
|
}
|
|
l413:
|
|
goto l406
|
|
l412:
|
|
position, tokenIndex = position412, tokenIndex412
|
|
}
|
|
if !matchDot() {
|
|
goto l406
|
|
}
|
|
}
|
|
l407:
|
|
goto l405
|
|
l406:
|
|
position, tokenIndex = position406, tokenIndex406
|
|
}
|
|
add(rulesinglequotedstring, position404)
|
|
}
|
|
return true
|
|
},
|
|
/* 20 variable <- <(([a-z] / [A-Z] / '_') ([a-z] / [A-Z] / [0-9] / '_' / '-')*)> */
|
|
nil,
|
|
/* 21 fieldExpr <- <(([a-z] / [A-Z] / '_' / '$') ([a-z] / [A-Z] / [0-9] / '_' / '-')*)> */
|
|
func() bool {
|
|
position416, tokenIndex416 := position, tokenIndex
|
|
{
|
|
position417 := position
|
|
{
|
|
position418, tokenIndex418 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l419
|
|
}
|
|
position++
|
|
goto l418
|
|
l419:
|
|
position, tokenIndex = position418, tokenIndex418
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l420
|
|
}
|
|
position++
|
|
goto l418
|
|
l420:
|
|
position, tokenIndex = position418, tokenIndex418
|
|
if buffer[position] != rune('_') {
|
|
goto l421
|
|
}
|
|
position++
|
|
goto l418
|
|
l421:
|
|
position, tokenIndex = position418, tokenIndex418
|
|
if buffer[position] != rune('$') {
|
|
goto l416
|
|
}
|
|
position++
|
|
}
|
|
l418:
|
|
l422:
|
|
{
|
|
position423, tokenIndex423 := position, tokenIndex
|
|
{
|
|
position424, tokenIndex424 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l425
|
|
}
|
|
position++
|
|
goto l424
|
|
l425:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l426
|
|
}
|
|
position++
|
|
goto l424
|
|
l426:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l427
|
|
}
|
|
position++
|
|
goto l424
|
|
l427:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if buffer[position] != rune('_') {
|
|
goto l428
|
|
}
|
|
position++
|
|
goto l424
|
|
l428:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if buffer[position] != rune('-') {
|
|
goto l423
|
|
}
|
|
position++
|
|
}
|
|
l424:
|
|
goto l422
|
|
l423:
|
|
position, tokenIndex = position423, tokenIndex423
|
|
}
|
|
add(rulefieldExpr, position417)
|
|
}
|
|
return true
|
|
l416:
|
|
position, tokenIndex = position416, tokenIndex416
|
|
return false
|
|
},
|
|
/* 22 field <- <(<(fieldExpr / reserved)> Action61)> */
|
|
func() bool {
|
|
position429, tokenIndex429 := position, tokenIndex
|
|
{
|
|
position430 := position
|
|
{
|
|
position431 := position
|
|
{
|
|
position432, tokenIndex432 := position, tokenIndex
|
|
if !_rules[rulefieldExpr]() {
|
|
goto l433
|
|
}
|
|
goto l432
|
|
l433:
|
|
position, tokenIndex = position432, tokenIndex432
|
|
{
|
|
position434 := position
|
|
{
|
|
position435, tokenIndex435 := position, tokenIndex
|
|
if buffer[position] != rune('_') {
|
|
goto l436
|
|
}
|
|
position++
|
|
if buffer[position] != rune('r') {
|
|
goto l436
|
|
}
|
|
position++
|
|
if buffer[position] != rune('o') {
|
|
goto l436
|
|
}
|
|
position++
|
|
if buffer[position] != rune('w') {
|
|
goto l436
|
|
}
|
|
position++
|
|
goto l435
|
|
l436:
|
|
position, tokenIndex = position435, tokenIndex435
|
|
if buffer[position] != rune('_') {
|
|
goto l437
|
|
}
|
|
position++
|
|
if buffer[position] != rune('c') {
|
|
goto l437
|
|
}
|
|
position++
|
|
if buffer[position] != rune('o') {
|
|
goto l437
|
|
}
|
|
position++
|
|
if buffer[position] != rune('l') {
|
|
goto l437
|
|
}
|
|
position++
|
|
goto l435
|
|
l437:
|
|
position, tokenIndex = position435, tokenIndex435
|
|
if buffer[position] != rune('_') {
|
|
goto l438
|
|
}
|
|
position++
|
|
if buffer[position] != rune('s') {
|
|
goto l438
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l438
|
|
}
|
|
position++
|
|
if buffer[position] != rune('a') {
|
|
goto l438
|
|
}
|
|
position++
|
|
if buffer[position] != rune('r') {
|
|
goto l438
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l438
|
|
}
|
|
position++
|
|
goto l435
|
|
l438:
|
|
position, tokenIndex = position435, tokenIndex435
|
|
if buffer[position] != rune('_') {
|
|
goto l439
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l439
|
|
}
|
|
position++
|
|
if buffer[position] != rune('n') {
|
|
goto l439
|
|
}
|
|
position++
|
|
if buffer[position] != rune('d') {
|
|
goto l439
|
|
}
|
|
position++
|
|
goto l435
|
|
l439:
|
|
position, tokenIndex = position435, tokenIndex435
|
|
if buffer[position] != rune('_') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('i') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('m') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('s') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('a') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('m') {
|
|
goto l440
|
|
}
|
|
position++
|
|
if buffer[position] != rune('p') {
|
|
goto l440
|
|
}
|
|
position++
|
|
goto l435
|
|
l440:
|
|
position, tokenIndex = position435, tokenIndex435
|
|
if buffer[position] != rune('_') {
|
|
goto l429
|
|
}
|
|
position++
|
|
if buffer[position] != rune('f') {
|
|
goto l429
|
|
}
|
|
position++
|
|
if buffer[position] != rune('i') {
|
|
goto l429
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l429
|
|
}
|
|
position++
|
|
if buffer[position] != rune('l') {
|
|
goto l429
|
|
}
|
|
position++
|
|
if buffer[position] != rune('d') {
|
|
goto l429
|
|
}
|
|
position++
|
|
}
|
|
l435:
|
|
add(rulereserved, position434)
|
|
}
|
|
}
|
|
l432:
|
|
add(rulePegText, position431)
|
|
}
|
|
{
|
|
add(ruleAction61, position)
|
|
}
|
|
add(rulefield, position430)
|
|
}
|
|
return true
|
|
l429:
|
|
position, tokenIndex = position429, tokenIndex429
|
|
return false
|
|
},
|
|
/* 23 reserved <- <(('_' 'r' 'o' 'w') / ('_' 'c' 'o' 'l') / ('_' 's' 't' 'a' 'r' 't') / ('_' 'e' 'n' 'd') / ('_' 't' 'i' 'm' 'e' 's' 't' 'a' 'm' 'p') / ('_' 'f' 'i' 'e' 'l' 'd'))> */
|
|
nil,
|
|
/* 24 posfield <- <(('f' 'i' 'e' 'l' 'd' '=')? <fieldExpr> Action62)> */
|
|
func() bool {
|
|
position443, tokenIndex443 := position, tokenIndex
|
|
{
|
|
position444 := position
|
|
{
|
|
position445, tokenIndex445 := position, tokenIndex
|
|
if buffer[position] != rune('f') {
|
|
goto l445
|
|
}
|
|
position++
|
|
if buffer[position] != rune('i') {
|
|
goto l445
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l445
|
|
}
|
|
position++
|
|
if buffer[position] != rune('l') {
|
|
goto l445
|
|
}
|
|
position++
|
|
if buffer[position] != rune('d') {
|
|
goto l445
|
|
}
|
|
position++
|
|
if buffer[position] != rune('=') {
|
|
goto l445
|
|
}
|
|
position++
|
|
goto l446
|
|
l445:
|
|
position, tokenIndex = position445, tokenIndex445
|
|
}
|
|
l446:
|
|
{
|
|
position447 := position
|
|
if !_rules[rulefieldExpr]() {
|
|
goto l443
|
|
}
|
|
add(rulePegText, position447)
|
|
}
|
|
{
|
|
add(ruleAction62, position)
|
|
}
|
|
add(ruleposfield, position444)
|
|
}
|
|
return true
|
|
l443:
|
|
position, tokenIndex = position443, tokenIndex443
|
|
return false
|
|
},
|
|
/* 25 col <- <((<digits> Action63) / (<('\'' singlequotedstring '\'')> Action64) / (<('"' doublequotedstring '"')> Action65))> */
|
|
func() bool {
|
|
position449, tokenIndex449 := position, tokenIndex
|
|
{
|
|
position450 := position
|
|
{
|
|
position451, tokenIndex451 := position, tokenIndex
|
|
{
|
|
position453 := position
|
|
if !_rules[ruledigits]() {
|
|
goto l452
|
|
}
|
|
add(rulePegText, position453)
|
|
}
|
|
{
|
|
add(ruleAction63, position)
|
|
}
|
|
goto l451
|
|
l452:
|
|
position, tokenIndex = position451, tokenIndex451
|
|
{
|
|
position456 := position
|
|
if buffer[position] != rune('\'') {
|
|
goto l455
|
|
}
|
|
position++
|
|
if !_rules[rulesinglequotedstring]() {
|
|
goto l455
|
|
}
|
|
if buffer[position] != rune('\'') {
|
|
goto l455
|
|
}
|
|
position++
|
|
add(rulePegText, position456)
|
|
}
|
|
{
|
|
add(ruleAction64, position)
|
|
}
|
|
goto l451
|
|
l455:
|
|
position, tokenIndex = position451, tokenIndex451
|
|
{
|
|
position458 := position
|
|
if buffer[position] != rune('"') {
|
|
goto l449
|
|
}
|
|
position++
|
|
if !_rules[ruledoublequotedstring]() {
|
|
goto l449
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l449
|
|
}
|
|
position++
|
|
add(rulePegText, position458)
|
|
}
|
|
{
|
|
add(ruleAction65, position)
|
|
}
|
|
}
|
|
l451:
|
|
add(rulecol, position450)
|
|
}
|
|
return true
|
|
l449:
|
|
position, tokenIndex = position449, tokenIndex449
|
|
return false
|
|
},
|
|
/* 26 open <- <('(' sp)> */
|
|
func() bool {
|
|
position460, tokenIndex460 := position, tokenIndex
|
|
{
|
|
position461 := position
|
|
if buffer[position] != rune('(') {
|
|
goto l460
|
|
}
|
|
position++
|
|
if !_rules[rulesp]() {
|
|
goto l460
|
|
}
|
|
add(ruleopen, position461)
|
|
}
|
|
return true
|
|
l460:
|
|
position, tokenIndex = position460, tokenIndex460
|
|
return false
|
|
},
|
|
/* 27 close <- <(sp ')' sp)> */
|
|
func() bool {
|
|
position462, tokenIndex462 := position, tokenIndex
|
|
{
|
|
position463 := position
|
|
if !_rules[rulesp]() {
|
|
goto l462
|
|
}
|
|
if buffer[position] != rune(')') {
|
|
goto l462
|
|
}
|
|
position++
|
|
if !_rules[rulesp]() {
|
|
goto l462
|
|
}
|
|
add(ruleclose, position463)
|
|
}
|
|
return true
|
|
l462:
|
|
position, tokenIndex = position462, tokenIndex462
|
|
return false
|
|
},
|
|
/* 28 sp <- <(' ' / '\t' / '\n')*> */
|
|
func() bool {
|
|
{
|
|
position465 := position
|
|
l466:
|
|
{
|
|
position467, tokenIndex467 := position, tokenIndex
|
|
{
|
|
position468, tokenIndex468 := position, tokenIndex
|
|
if buffer[position] != rune(' ') {
|
|
goto l469
|
|
}
|
|
position++
|
|
goto l468
|
|
l469:
|
|
position, tokenIndex = position468, tokenIndex468
|
|
if buffer[position] != rune('\t') {
|
|
goto l470
|
|
}
|
|
position++
|
|
goto l468
|
|
l470:
|
|
position, tokenIndex = position468, tokenIndex468
|
|
if buffer[position] != rune('\n') {
|
|
goto l467
|
|
}
|
|
position++
|
|
}
|
|
l468:
|
|
goto l466
|
|
l467:
|
|
position, tokenIndex = position467, tokenIndex467
|
|
}
|
|
add(rulesp, position465)
|
|
}
|
|
return true
|
|
},
|
|
/* 29 eq <- <(sp '=' sp)> */
|
|
func() bool {
|
|
position471, tokenIndex471 := position, tokenIndex
|
|
{
|
|
position472 := position
|
|
if !_rules[rulesp]() {
|
|
goto l471
|
|
}
|
|
if buffer[position] != rune('=') {
|
|
goto l471
|
|
}
|
|
position++
|
|
if !_rules[rulesp]() {
|
|
goto l471
|
|
}
|
|
add(ruleeq, position472)
|
|
}
|
|
return true
|
|
l471:
|
|
position, tokenIndex = position471, tokenIndex471
|
|
return false
|
|
},
|
|
/* 30 comma <- <(sp ',' sp)> */
|
|
func() bool {
|
|
position473, tokenIndex473 := position, tokenIndex
|
|
{
|
|
position474 := position
|
|
if !_rules[rulesp]() {
|
|
goto l473
|
|
}
|
|
if buffer[position] != rune(',') {
|
|
goto l473
|
|
}
|
|
position++
|
|
if !_rules[rulesp]() {
|
|
goto l473
|
|
}
|
|
add(rulecomma, position474)
|
|
}
|
|
return true
|
|
l473:
|
|
position, tokenIndex = position473, tokenIndex473
|
|
return false
|
|
},
|
|
/* 31 lbrack <- <('[' sp)> */
|
|
nil,
|
|
/* 32 rbrack <- <(sp ']' sp)> */
|
|
nil,
|
|
/* 33 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
|
|
func() bool {
|
|
position477, tokenIndex477 := position, tokenIndex
|
|
{
|
|
position478 := position
|
|
{
|
|
position479, tokenIndex479 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l480
|
|
}
|
|
position++
|
|
goto l479
|
|
l480:
|
|
position, tokenIndex = position479, tokenIndex479
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l477
|
|
}
|
|
position++
|
|
}
|
|
l479:
|
|
l481:
|
|
{
|
|
position482, tokenIndex482 := position, tokenIndex
|
|
{
|
|
position483, tokenIndex483 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l484
|
|
}
|
|
position++
|
|
goto l483
|
|
l484:
|
|
position, tokenIndex = position483, tokenIndex483
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l485
|
|
}
|
|
position++
|
|
goto l483
|
|
l485:
|
|
position, tokenIndex = position483, tokenIndex483
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l482
|
|
}
|
|
position++
|
|
}
|
|
l483:
|
|
goto l481
|
|
l482:
|
|
position, tokenIndex = position482, tokenIndex482
|
|
}
|
|
add(ruleIDENT, position478)
|
|
}
|
|
return true
|
|
l477:
|
|
position, tokenIndex = position477, tokenIndex477
|
|
return false
|
|
},
|
|
/* 34 digits <- <[0-9]+> */
|
|
func() bool {
|
|
position486, tokenIndex486 := position, tokenIndex
|
|
{
|
|
position487 := position
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l486
|
|
}
|
|
position++
|
|
l488:
|
|
{
|
|
position489, tokenIndex489 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l489
|
|
}
|
|
position++
|
|
goto l488
|
|
l489:
|
|
position, tokenIndex = position489, tokenIndex489
|
|
}
|
|
add(ruledigits, position487)
|
|
}
|
|
return true
|
|
l486:
|
|
position, tokenIndex = position486, tokenIndex486
|
|
return false
|
|
},
|
|
/* 35 signedDigits <- <('-'? digits)> */
|
|
nil,
|
|
/* 36 decimal <- <((signedDigits ('.' digits?)?) / ('-'? '.' digits))> */
|
|
func() bool {
|
|
position491, tokenIndex491 := position, tokenIndex
|
|
{
|
|
position492 := position
|
|
{
|
|
position493, tokenIndex493 := position, tokenIndex
|
|
{
|
|
position495 := position
|
|
{
|
|
position496, tokenIndex496 := position, tokenIndex
|
|
if buffer[position] != rune('-') {
|
|
goto l496
|
|
}
|
|
position++
|
|
goto l497
|
|
l496:
|
|
position, tokenIndex = position496, tokenIndex496
|
|
}
|
|
l497:
|
|
if !_rules[ruledigits]() {
|
|
goto l494
|
|
}
|
|
add(rulesignedDigits, position495)
|
|
}
|
|
{
|
|
position498, tokenIndex498 := position, tokenIndex
|
|
if buffer[position] != rune('.') {
|
|
goto l498
|
|
}
|
|
position++
|
|
{
|
|
position500, tokenIndex500 := position, tokenIndex
|
|
if !_rules[ruledigits]() {
|
|
goto l500
|
|
}
|
|
goto l501
|
|
l500:
|
|
position, tokenIndex = position500, tokenIndex500
|
|
}
|
|
l501:
|
|
goto l499
|
|
l498:
|
|
position, tokenIndex = position498, tokenIndex498
|
|
}
|
|
l499:
|
|
goto l493
|
|
l494:
|
|
position, tokenIndex = position493, tokenIndex493
|
|
{
|
|
position502, tokenIndex502 := position, tokenIndex
|
|
if buffer[position] != rune('-') {
|
|
goto l502
|
|
}
|
|
position++
|
|
goto l503
|
|
l502:
|
|
position, tokenIndex = position502, tokenIndex502
|
|
}
|
|
l503:
|
|
if buffer[position] != rune('.') {
|
|
goto l491
|
|
}
|
|
position++
|
|
if !_rules[ruledigits]() {
|
|
goto l491
|
|
}
|
|
}
|
|
l493:
|
|
add(ruledecimal, position492)
|
|
}
|
|
return true
|
|
l491:
|
|
position, tokenIndex = position491, tokenIndex491
|
|
return false
|
|
},
|
|
/* 37 tz <- <('Z' / ('-' [0-9] [0-9] ':' [0-9] [0-9]) / ('+' [0-9] [0-9] ':' [0-9] [0-9]))> */
|
|
func() bool {
|
|
position504, tokenIndex504 := position, tokenIndex
|
|
{
|
|
position505 := position
|
|
{
|
|
position506, tokenIndex506 := position, tokenIndex
|
|
if buffer[position] != rune('Z') {
|
|
goto l507
|
|
}
|
|
position++
|
|
goto l506
|
|
l507:
|
|
position, tokenIndex = position506, tokenIndex506
|
|
if buffer[position] != rune('-') {
|
|
goto l508
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l508
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l508
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l508
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l508
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l508
|
|
}
|
|
position++
|
|
goto l506
|
|
l508:
|
|
position, tokenIndex = position506, tokenIndex506
|
|
if buffer[position] != rune('+') {
|
|
goto l504
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l504
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l504
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l504
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l504
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l504
|
|
}
|
|
position++
|
|
}
|
|
l506:
|
|
add(ruletz, position505)
|
|
}
|
|
return true
|
|
l504:
|
|
position, tokenIndex = position504, tokenIndex504
|
|
return false
|
|
},
|
|
/* 38 iso8601 <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9] ':' [0-9] [0-9] <tz>)> */
|
|
nil,
|
|
/* 39 iso8601nano <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9] ':' [0-9] [0-9] '.' [0-9]+ <tz>)> */
|
|
nil,
|
|
/* 40 timestampbasicfmt <- <(iso8601nano / iso8601)> */
|
|
func() bool {
|
|
position511, tokenIndex511 := position, tokenIndex
|
|
{
|
|
position512 := position
|
|
{
|
|
position513, tokenIndex513 := position, tokenIndex
|
|
{
|
|
position515 := position
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l514
|
|
}
|
|
position++
|
|
{
|
|
position516, tokenIndex516 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l517
|
|
}
|
|
position++
|
|
goto l516
|
|
l517:
|
|
position, tokenIndex = position516, tokenIndex516
|
|
if buffer[position] != rune('1') {
|
|
goto l514
|
|
}
|
|
position++
|
|
}
|
|
l516:
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('3') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if buffer[position] != rune('T') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if buffer[position] != rune('.') {
|
|
goto l514
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l514
|
|
}
|
|
position++
|
|
l518:
|
|
{
|
|
position519, tokenIndex519 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l519
|
|
}
|
|
position++
|
|
goto l518
|
|
l519:
|
|
position, tokenIndex = position519, tokenIndex519
|
|
}
|
|
{
|
|
position520 := position
|
|
if !_rules[ruletz]() {
|
|
goto l514
|
|
}
|
|
add(rulePegText, position520)
|
|
}
|
|
add(ruleiso8601nano, position515)
|
|
}
|
|
goto l513
|
|
l514:
|
|
position, tokenIndex = position513, tokenIndex513
|
|
{
|
|
position521 := position
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l511
|
|
}
|
|
position++
|
|
{
|
|
position522, tokenIndex522 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l523
|
|
}
|
|
position++
|
|
goto l522
|
|
l523:
|
|
position, tokenIndex = position522, tokenIndex522
|
|
if buffer[position] != rune('1') {
|
|
goto l511
|
|
}
|
|
position++
|
|
}
|
|
l522:
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('3') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if buffer[position] != rune('T') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l511
|
|
}
|
|
position++
|
|
{
|
|
position524 := position
|
|
if !_rules[ruletz]() {
|
|
goto l511
|
|
}
|
|
add(rulePegText, position524)
|
|
}
|
|
add(ruleiso8601, position521)
|
|
}
|
|
}
|
|
l513:
|
|
add(ruletimestampbasicfmt, position512)
|
|
}
|
|
return true
|
|
l511:
|
|
position, tokenIndex = position511, tokenIndex511
|
|
return false
|
|
},
|
|
/* 41 timestampfmt <- <(('"' <timestampbasicfmt> '"') / ('\'' <timestampbasicfmt> '\'') / <timestampbasicfmt>)> */
|
|
func() bool {
|
|
position525, tokenIndex525 := position, tokenIndex
|
|
{
|
|
position526 := position
|
|
{
|
|
position527, tokenIndex527 := position, tokenIndex
|
|
if buffer[position] != rune('"') {
|
|
goto l528
|
|
}
|
|
position++
|
|
{
|
|
position529 := position
|
|
if !_rules[ruletimestampbasicfmt]() {
|
|
goto l528
|
|
}
|
|
add(rulePegText, position529)
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l528
|
|
}
|
|
position++
|
|
goto l527
|
|
l528:
|
|
position, tokenIndex = position527, tokenIndex527
|
|
if buffer[position] != rune('\'') {
|
|
goto l530
|
|
}
|
|
position++
|
|
{
|
|
position531 := position
|
|
if !_rules[ruletimestampbasicfmt]() {
|
|
goto l530
|
|
}
|
|
add(rulePegText, position531)
|
|
}
|
|
if buffer[position] != rune('\'') {
|
|
goto l530
|
|
}
|
|
position++
|
|
goto l527
|
|
l530:
|
|
position, tokenIndex = position527, tokenIndex527
|
|
{
|
|
position532 := position
|
|
if !_rules[ruletimestampbasicfmt]() {
|
|
goto l525
|
|
}
|
|
add(rulePegText, position532)
|
|
}
|
|
}
|
|
l527:
|
|
add(ruletimestampfmt, position526)
|
|
}
|
|
return true
|
|
l525:
|
|
position, tokenIndex = position525, tokenIndex525
|
|
return false
|
|
},
|
|
/* 42 timebasicfmt <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9])> */
|
|
func() bool {
|
|
position533, tokenIndex533 := position, tokenIndex
|
|
{
|
|
position534 := position
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l533
|
|
}
|
|
position++
|
|
{
|
|
position535, tokenIndex535 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l536
|
|
}
|
|
position++
|
|
goto l535
|
|
l536:
|
|
position, tokenIndex = position535, tokenIndex535
|
|
if buffer[position] != rune('1') {
|
|
goto l533
|
|
}
|
|
position++
|
|
}
|
|
l535:
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('3') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if buffer[position] != rune('T') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
add(ruletimebasicfmt, position534)
|
|
}
|
|
return true
|
|
l533:
|
|
position, tokenIndex = position533, tokenIndex533
|
|
return false
|
|
},
|
|
/* 43 timefmt <- <(('"' <timebasicfmt> '"') / ('\'' <timebasicfmt> '\'') / <timebasicfmt>)> */
|
|
func() bool {
|
|
position537, tokenIndex537 := position, tokenIndex
|
|
{
|
|
position538 := position
|
|
{
|
|
position539, tokenIndex539 := position, tokenIndex
|
|
if buffer[position] != rune('"') {
|
|
goto l540
|
|
}
|
|
position++
|
|
{
|
|
position541 := position
|
|
if !_rules[ruletimebasicfmt]() {
|
|
goto l540
|
|
}
|
|
add(rulePegText, position541)
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l540
|
|
}
|
|
position++
|
|
goto l539
|
|
l540:
|
|
position, tokenIndex = position539, tokenIndex539
|
|
if buffer[position] != rune('\'') {
|
|
goto l542
|
|
}
|
|
position++
|
|
{
|
|
position543 := position
|
|
if !_rules[ruletimebasicfmt]() {
|
|
goto l542
|
|
}
|
|
add(rulePegText, position543)
|
|
}
|
|
if buffer[position] != rune('\'') {
|
|
goto l542
|
|
}
|
|
position++
|
|
goto l539
|
|
l542:
|
|
position, tokenIndex = position539, tokenIndex539
|
|
{
|
|
position544 := position
|
|
if !_rules[ruletimebasicfmt]() {
|
|
goto l537
|
|
}
|
|
add(rulePegText, position544)
|
|
}
|
|
}
|
|
l539:
|
|
add(ruletimefmt, position538)
|
|
}
|
|
return true
|
|
l537:
|
|
position, tokenIndex = position537, tokenIndex537
|
|
return false
|
|
},
|
|
/* 44 time <- <(<timefmt> Action66)> */
|
|
nil,
|
|
/* 46 Action0 <- <{p.startCall("Set")}> */
|
|
nil,
|
|
/* 47 Action1 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 48 Action2 <- <{p.startCall("Clear")}> */
|
|
nil,
|
|
/* 49 Action3 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 50 Action4 <- <{p.startCall("Apply")}> */
|
|
nil,
|
|
/* 51 Action5 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 52 Action6 <- <{p.startCall("ClearRow")}> */
|
|
nil,
|
|
/* 53 Action7 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 54 Action8 <- <{p.startCall("Store")}> */
|
|
nil,
|
|
/* 55 Action9 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 56 Action10 <- <{p.startCall("TopN")}> */
|
|
nil,
|
|
/* 57 Action11 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 58 Action12 <- <{p.startCall("TopK")}> */
|
|
nil,
|
|
/* 59 Action13 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 60 Action14 <- <{p.startCall("Percentile")}> */
|
|
nil,
|
|
/* 61 Action15 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 62 Action16 <- <{p.startCall("Rows")}> */
|
|
nil,
|
|
/* 63 Action17 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 64 Action18 <- <{p.startCall("Min")}> */
|
|
nil,
|
|
/* 65 Action19 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 66 Action20 <- <{p.startCall("Max")}> */
|
|
nil,
|
|
/* 67 Action21 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 68 Action22 <- <{p.startCall("Sum")}> */
|
|
nil,
|
|
/* 69 Action23 <- <{p.endCall()}> */
|
|
nil,
|
|
/* 70 Action24 <- <{p.startCall("Range")}> */
|
|
nil,
|
|
/* 71 Action25 <- <{p.addField("from")}> */
|
|
nil,
|
|
/* 72 Action26 <- <{p.addVal(text)}> */
|
|
nil,
|
|
/* 73 Action27 <- <{p.addField("to")}> */
|
|
nil,
|
|
/* 74 Action28 <- <{p.addVal(text)}> */
|
|
nil,
|
|
/* 75 Action29 <- <{p.endCall()}> */
|
|
nil,
|
|
nil,
|
|
/* 77 Action30 <- <{ p.startCall(text) }> */
|
|
nil,
|
|
/* 78 Action31 <- <{ p.endCall() }> */
|
|
nil,
|
|
/* 79 Action32 <- <{ p.addPosStr("_ivy", text) }> */
|
|
nil,
|
|
/* 80 Action33 <- <{ p.addPosStr("_ivyReduce", text) }> */
|
|
nil,
|
|
/* 81 Action34 <- <{ p.addBTWN() }> */
|
|
nil,
|
|
/* 82 Action35 <- <{ p.addLTE() }> */
|
|
nil,
|
|
/* 83 Action36 <- <{ p.addGTE() }> */
|
|
nil,
|
|
/* 84 Action37 <- <{ p.addEQ() }> */
|
|
nil,
|
|
/* 85 Action38 <- <{ p.addNEQ() }> */
|
|
nil,
|
|
/* 86 Action39 <- <{ p.addLT() }> */
|
|
nil,
|
|
/* 87 Action40 <- <{ p.addGT() }> */
|
|
nil,
|
|
/* 88 Action41 <- <{p.startConditional()}> */
|
|
nil,
|
|
/* 89 Action42 <- <{p.endConditional()}> */
|
|
nil,
|
|
/* 90 Action43 <- <{ p.condAddTimestamp(text) }> */
|
|
nil,
|
|
/* 91 Action44 <- <{p.condAdd(text)}> */
|
|
nil,
|
|
/* 92 Action45 <- <{p.condAdd(text)}> */
|
|
nil,
|
|
/* 93 Action46 <- <{p.condAdd(text)}> */
|
|
nil,
|
|
/* 94 Action47 <- <{ p.startList() }> */
|
|
nil,
|
|
/* 95 Action48 <- <{ p.endList() }> */
|
|
nil,
|
|
/* 96 Action49 <- <{ p.addVal(nil) }> */
|
|
nil,
|
|
/* 97 Action50 <- <{ p.addVal(true) }> */
|
|
nil,
|
|
/* 98 Action51 <- <{ p.addVal(false) }> */
|
|
nil,
|
|
/* 99 Action52 <- <{ p.addVal(NewVariable(text)) }> */
|
|
nil,
|
|
/* 100 Action53 <- <{ p.addVal(text) }> */
|
|
nil,
|
|
/* 101 Action54 <- <{ p.addTimestampVal(text) }> */
|
|
nil,
|
|
/* 102 Action55 <- <{ p.addNumVal(text) }> */
|
|
nil,
|
|
/* 103 Action56 <- <{ p.startCall(text) }> */
|
|
nil,
|
|
/* 104 Action57 <- <{ p.addVal(p.endCall()) }> */
|
|
nil,
|
|
/* 105 Action58 <- <{ p.addVal(text) }> */
|
|
nil,
|
|
/* 106 Action59 <- <{ p.addVal(text) }> */
|
|
nil,
|
|
/* 107 Action60 <- <{ p.addVal(text) }> */
|
|
nil,
|
|
/* 108 Action61 <- <{ p.addField(text) }> */
|
|
nil,
|
|
/* 109 Action62 <- <{ p.addPosStr("_field", text) }> */
|
|
nil,
|
|
/* 110 Action63 <- <{p.addPosNum("_col", text)}> */
|
|
nil,
|
|
/* 111 Action64 <- <{p.addPosStr("_col", text)}> */
|
|
nil,
|
|
/* 112 Action65 <- <{p.addPosStr("_col", text)}> */
|
|
nil,
|
|
/* 113 Action66 <- <{p.addPosStr("_timestamp", text)}> */
|
|
nil,
|
|
}
|
|
p.rules = _rules
|
|
return nil
|
|
}
|