featurebase/pql/pql.peg.go

package pql

// Code generated by peg -inline pql.peg DO NOT EDIT.

import (
	"fmt"
	"io"
	"os"
	"sort"
	"strconv"
)

const endSymbol rune = 1114112

/* The rule types inferred from the grammar are below. */
type pegRule uint8

const (
	ruleUnknown pegRule = iota
	ruleCalls
	ruleCall
	ruleallargs
	rulefargs
	rulefarg
	ruledargs
	ruledarg
	ruleCOND
	ruleconditional
	rulecondint
	rulecondLT
	rulecondfield
	ruledvalue
	rulefvalue
	ruledlist
	ruleflist
	ruleditem
	rulefitem
	ruleitema
	ruleitemb
	rulefloat
	ruledecimal
	ruledoublequotedstring
	rulesinglequotedstring
	rulefieldExpr
	rulefield
	rulereserved
	ruleposfield
	ruleuint
	rulecol
	rulerow
	ruleopen
	ruleclose
	rulesp
	rulecomma
	rulelbrack
	rulerbrack
	ruleIDENT
	ruletimestampbasicfmt
	ruletimestampfmt
	ruletimestamp
	ruleAction0
	ruleAction1
	ruleAction2
	ruleAction3
	ruleAction4
	ruleAction5
	ruleAction6
	ruleAction7
	ruleAction8
	ruleAction9
	ruleAction10
	ruleAction11
	ruleAction12
	ruleAction13
	ruleAction14
	ruleAction15
	ruleAction16
	ruleAction17
	ruleAction18
	ruleAction19
	ruleAction20
	ruleAction21
	rulePegText
	ruleAction22
	ruleAction23
	ruleAction24
	ruleAction25
	ruleAction26
	ruleAction27
	ruleAction28
	ruleAction29
	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
)

var rul3s = [...]string{
	"Unknown",
	"Calls",
	"Call",
	"allargs",
	"fargs",
	"farg",
	"dargs",
	"darg",
	"COND",
	"conditional",
	"condint",
	"condLT",
	"condfield",
	"dvalue",
	"fvalue",
	"dlist",
	"flist",
	"ditem",
	"fitem",
	"itema",
	"itemb",
	"float",
	"decimal",
	"doublequotedstring",
	"singlequotedstring",
	"fieldExpr",
	"field",
	"reserved",
	"posfield",
	"uint",
	"col",
	"row",
	"open",
	"close",
	"sp",
	"comma",
	"lbrack",
	"rbrack",
	"IDENT",
	"timestampbasicfmt",
	"timestampfmt",
	"timestamp",
	"Action0",
	"Action1",
	"Action2",
	"Action3",
	"Action4",
	"Action5",
	"Action6",
	"Action7",
	"Action8",
	"Action9",
	"Action10",
	"Action11",
	"Action12",
	"Action13",
	"Action14",
	"Action15",
	"Action16",
	"Action17",
	"Action18",
	"Action19",
	"Action20",
	"Action21",
	"PegText",
	"Action22",
	"Action23",
	"Action24",
	"Action25",
	"Action26",
	"Action27",
	"Action28",
	"Action29",
	"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",
}

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[34m%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  [105]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) 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("SetRowAttrs")
		case ruleAction3:
			p.endCall()
		case ruleAction4:
			p.startCall("SetColumnAttrs")
		case ruleAction5:
			p.endCall()
		case ruleAction6:
			p.startCall("Clear")
		case ruleAction7:
			p.endCall()
		case ruleAction8:
			p.startCall("ClearRow")
		case ruleAction9:
			p.endCall()
		case ruleAction10:
			p.startCall("Store")
		case ruleAction11:
			p.endCall()
		case ruleAction12:
			p.startCall("TopN")
		case ruleAction13:
			p.endCall()
		case ruleAction14:
			p.startCall("Rows")
		case ruleAction15:
			p.endCall()
		case ruleAction16:
			p.startCall("Range")
		case ruleAction17:
			p.addField("from")
		case ruleAction18:
			p.addVal(buffer[begin:end])
		case ruleAction19:
			p.addField("to")
		case ruleAction20:
			p.addVal(buffer[begin:end])
		case ruleAction21:
			p.endCall()
		case ruleAction22:
			p.startCall(buffer[begin:end])
		case ruleAction23:
			p.endCall()
		case ruleAction24:
			p.addBTWN()
		case ruleAction25:
			p.addLTE()
		case ruleAction26:
			p.addGTE()
		case ruleAction27:
			p.addEQ()
		case ruleAction28:
			p.addNEQ()
		case ruleAction29:
			p.addLT()
		case ruleAction30:
			p.addGT()
		case ruleAction31:
			p.startConditional()
		case ruleAction32:
			p.endConditional()
		case ruleAction33:
			p.condAdd(buffer[begin:end])
		case ruleAction34:
			p.condAdd(buffer[begin:end])
		case ruleAction35:
			p.condAdd(buffer[begin:end])
		case ruleAction36:
			p.startList()
		case ruleAction37:
			p.endList()
		case ruleAction38:
			p.startList()
		case ruleAction39:
			p.endList()
		case ruleAction40:
			p.addVal(nil)
		case ruleAction41:
			p.addVal(true)
		case ruleAction42:
			p.addVal(false)
		case ruleAction43:
			p.addVal(buffer[begin:end])
		case ruleAction44:
			p.startCall(buffer[begin:end])
		case ruleAction45:
			p.addVal(p.endCall())
		case ruleAction46:
			p.addVal(buffer[begin:end])
		case ruleAction47:
			s, _ := strconv.Unquote(buffer[begin:end])
			p.addVal(s)
		case ruleAction48:
			p.addVal(buffer[begin:end])
		case ruleAction49:
			p.addNumVal(buffer[begin:end], true)
		case ruleAction50:
			p.addNumVal(buffer[begin:end], true)
		case ruleAction51:
			p.addNumVal(buffer[begin:end], false)
		case ruleAction52:
			p.addNumVal(buffer[begin:end], false)
		case ruleAction53:
			p.addField(buffer[begin:end])
		case ruleAction54:
			p.addPosStr("_field", buffer[begin:end])
		case ruleAction55:
			p.addPosNum("_col", buffer[begin:end])
		case ruleAction56:
			p.addPosStr("_col", buffer[begin:end])
		case ruleAction57:
			p.addPosStr("_col", buffer[begin:end])
		case ruleAction58:
			p.addPosNum("_row", buffer[begin:end])
		case ruleAction59:
			p.addPosStr("_row", buffer[begin:end])
		case ruleAction60:
			p.addPosStr("_row", buffer[begin:end])
		case ruleAction61:
			p.addPosStr("_timestamp", buffer[begin:end])

		}
	}
	_, _, _, _, _ = 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' 'e' 't' Action0 open col comma dargs (comma timestamp)? close Action1) / ('S' 'e' 't' 'R' 'o' 'w' 'A' 't' 't' 'r' 's' Action2 open posfield comma row comma fargs close Action3) / ('S' 'e' 't' 'C' 'o' 'l' 'u' 'm' 'n' 'A' 't' 't' 'r' 's' Action4 open col comma fargs close Action5) / ('C' 'l' 'e' 'a' 'r' Action6 open col comma dargs close Action7) / ('C' 'l' 'e' 'a' 'r' 'R' 'o' 'w' Action8 open darg close Action9) / ('S' 't' 'o' 'r' 'e' Action10 open Call comma darg close Action11) / ('T' 'o' 'p' 'N' Action12 open posfield (comma allargs)? close Action13) / ('R' 'o' 'w' 's' Action14 open posfield (comma allargs)? close Action15) / ('R' 'a' 'n' 'g' 'e' Action16 open field sp '=' sp fvalue comma ('f' 'r' 'o' 'm' '=')? Action17 timestampfmt Action18 comma ('t' 'o' '=')? sp Action19 timestampfmt Action20 close Action21) / (<IDENT> Action22 open allargs comma? close Action23))> */
		func() bool {
			position5, tokenIndex5 := position, tokenIndex
			{
				position6 := position
				{
					position7, tokenIndex7 := position, tokenIndex
					if buffer[position] != rune('S') {
						goto l8
					}
					position++
					if buffer[position] != rune('e') {
						goto l8
					}
					position++
					if buffer[position] != rune('t') {
						goto l8
					}
					position++
					{
						add(ruleAction0, position)
					}
					if !_rules[ruleopen]() {
						goto l8
					}
					if !_rules[rulecol]() {
						goto l8
					}
					if !_rules[rulecomma]() {
						goto l8
					}
					if !_rules[ruledargs]() {
						goto l8
					}
					{
						position10, tokenIndex10 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l10
						}
						{
							position12 := position
							{
								position13 := position
								if !_rules[ruletimestampfmt]() {
									goto l10
								}
								add(rulePegText, position13)
							}
							{
								add(ruleAction61, position)
							}
							add(ruletimestamp, position12)
						}
						goto l11
					l10:
						position, tokenIndex = position10, tokenIndex10
					}
				l11:
					if !_rules[ruleclose]() {
						goto l8
					}
					{
						add(ruleAction1, position)
					}
					goto l7
				l8:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('S') {
						goto l16
					}
					position++
					if buffer[position] != rune('e') {
						goto l16
					}
					position++
					if buffer[position] != rune('t') {
						goto l16
					}
					position++
					if buffer[position] != rune('R') {
						goto l16
					}
					position++
					if buffer[position] != rune('o') {
						goto l16
					}
					position++
					if buffer[position] != rune('w') {
						goto l16
					}
					position++
					if buffer[position] != rune('A') {
						goto l16
					}
					position++
					if buffer[position] != rune('t') {
						goto l16
					}
					position++
					if buffer[position] != rune('t') {
						goto l16
					}
					position++
					if buffer[position] != rune('r') {
						goto l16
					}
					position++
					if buffer[position] != rune('s') {
						goto l16
					}
					position++
					{
						add(ruleAction2, position)
					}
					if !_rules[ruleopen]() {
						goto l16
					}
					if !_rules[ruleposfield]() {
						goto l16
					}
					if !_rules[rulecomma]() {
						goto l16
					}
					{
						position18 := position
						{
							position19, tokenIndex19 := position, tokenIndex
							{
								position21 := position
								if !_rules[ruleuint]() {
									goto l20
								}
								add(rulePegText, position21)
							}
							{
								add(ruleAction58, position)
							}
							goto l19
						l20:
							position, tokenIndex = position19, tokenIndex19
							if buffer[position] != rune('\'') {
								goto l23
							}
							position++
							{
								position24 := position
								if !_rules[rulesinglequotedstring]() {
									goto l23
								}
								add(rulePegText, position24)
							}
							if buffer[position] != rune('\'') {
								goto l23
							}
							position++
							{
								add(ruleAction59, position)
							}
							goto l19
						l23:
							position, tokenIndex = position19, tokenIndex19
							if buffer[position] != rune('"') {
								goto l16
							}
							position++
							{
								position26 := position
								if !_rules[ruledoublequotedstring]() {
									goto l16
								}
								add(rulePegText, position26)
							}
							if buffer[position] != rune('"') {
								goto l16
							}
							position++
							{
								add(ruleAction60, position)
							}
						}
					l19:
						add(rulerow, position18)
					}
					if !_rules[rulecomma]() {
						goto l16
					}
					if !_rules[rulefargs]() {
						goto l16
					}
					if !_rules[ruleclose]() {
						goto l16
					}
					{
						add(ruleAction3, position)
					}
					goto l7
				l16:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('S') {
						goto l29
					}
					position++
					if buffer[position] != rune('e') {
						goto l29
					}
					position++
					if buffer[position] != rune('t') {
						goto l29
					}
					position++
					if buffer[position] != rune('C') {
						goto l29
					}
					position++
					if buffer[position] != rune('o') {
						goto l29
					}
					position++
					if buffer[position] != rune('l') {
						goto l29
					}
					position++
					if buffer[position] != rune('u') {
						goto l29
					}
					position++
					if buffer[position] != rune('m') {
						goto l29
					}
					position++
					if buffer[position] != rune('n') {
						goto l29
					}
					position++
					if buffer[position] != rune('A') {
						goto l29
					}
					position++
					if buffer[position] != rune('t') {
						goto l29
					}
					position++
					if buffer[position] != rune('t') {
						goto l29
					}
					position++
					if buffer[position] != rune('r') {
						goto l29
					}
					position++
					if buffer[position] != rune('s') {
						goto l29
					}
					position++
					{
						add(ruleAction4, position)
					}
					if !_rules[ruleopen]() {
						goto l29
					}
					if !_rules[rulecol]() {
						goto l29
					}
					if !_rules[rulecomma]() {
						goto l29
					}
					if !_rules[rulefargs]() {
						goto l29
					}
					if !_rules[ruleclose]() {
						goto l29
					}
					{
						add(ruleAction5, position)
					}
					goto l7
				l29:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('C') {
						goto l32
					}
					position++
					if buffer[position] != rune('l') {
						goto l32
					}
					position++
					if buffer[position] != rune('e') {
						goto l32
					}
					position++
					if buffer[position] != rune('a') {
						goto l32
					}
					position++
					if buffer[position] != rune('r') {
						goto l32
					}
					position++
					{
						add(ruleAction6, position)
					}
					if !_rules[ruleopen]() {
						goto l32
					}
					if !_rules[rulecol]() {
						goto l32
					}
					if !_rules[rulecomma]() {
						goto l32
					}
					if !_rules[ruledargs]() {
						goto l32
					}
					if !_rules[ruleclose]() {
						goto l32
					}
					{
						add(ruleAction7, position)
					}
					goto l7
				l32:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('C') {
						goto l35
					}
					position++
					if buffer[position] != rune('l') {
						goto l35
					}
					position++
					if buffer[position] != rune('e') {
						goto l35
					}
					position++
					if buffer[position] != rune('a') {
						goto l35
					}
					position++
					if buffer[position] != rune('r') {
						goto l35
					}
					position++
					if buffer[position] != rune('R') {
						goto l35
					}
					position++
					if buffer[position] != rune('o') {
						goto l35
					}
					position++
					if buffer[position] != rune('w') {
						goto l35
					}
					position++
					{
						add(ruleAction8, position)
					}
					if !_rules[ruleopen]() {
						goto l35
					}
					if !_rules[ruledarg]() {
						goto l35
					}
					if !_rules[ruleclose]() {
						goto l35
					}
					{
						add(ruleAction9, position)
					}
					goto l7
				l35:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('S') {
						goto l38
					}
					position++
					if buffer[position] != rune('t') {
						goto l38
					}
					position++
					if buffer[position] != rune('o') {
						goto l38
					}
					position++
					if buffer[position] != rune('r') {
						goto l38
					}
					position++
					if buffer[position] != rune('e') {
						goto l38
					}
					position++
					{
						add(ruleAction10, position)
					}
					if !_rules[ruleopen]() {
						goto l38
					}
					if !_rules[ruleCall]() {
						goto l38
					}
					if !_rules[rulecomma]() {
						goto l38
					}
					if !_rules[ruledarg]() {
						goto l38
					}
					if !_rules[ruleclose]() {
						goto l38
					}
					{
						add(ruleAction11, position)
					}
					goto l7
				l38:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('T') {
						goto l41
					}
					position++
					if buffer[position] != rune('o') {
						goto l41
					}
					position++
					if buffer[position] != rune('p') {
						goto l41
					}
					position++
					if buffer[position] != rune('N') {
						goto l41
					}
					position++
					{
						add(ruleAction12, position)
					}
					if !_rules[ruleopen]() {
						goto l41
					}
					if !_rules[ruleposfield]() {
						goto l41
					}
					{
						position43, tokenIndex43 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l43
						}
						if !_rules[ruleallargs]() {
							goto l43
						}
						goto l44
					l43:
						position, tokenIndex = position43, tokenIndex43
					}
				l44:
					if !_rules[ruleclose]() {
						goto l41
					}
					{
						add(ruleAction13, position)
					}
					goto l7
				l41:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('R') {
						goto l46
					}
					position++
					if buffer[position] != rune('o') {
						goto l46
					}
					position++
					if buffer[position] != rune('w') {
						goto l46
					}
					position++
					if buffer[position] != rune('s') {
						goto l46
					}
					position++
					{
						add(ruleAction14, position)
					}
					if !_rules[ruleopen]() {
						goto l46
					}
					if !_rules[ruleposfield]() {
						goto l46
					}
					{
						position48, tokenIndex48 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l48
						}
						if !_rules[ruleallargs]() {
							goto l48
						}
						goto l49
					l48:
						position, tokenIndex = position48, tokenIndex48
					}
				l49:
					if !_rules[ruleclose]() {
						goto l46
					}
					{
						add(ruleAction15, position)
					}
					goto l7
				l46:
					position, tokenIndex = position7, tokenIndex7
					if buffer[position] != rune('R') {
						goto l51
					}
					position++
					if buffer[position] != rune('a') {
						goto l51
					}
					position++
					if buffer[position] != rune('n') {
						goto l51
					}
					position++
					if buffer[position] != rune('g') {
						goto l51
					}
					position++
					if buffer[position] != rune('e') {
						goto l51
					}
					position++
					{
						add(ruleAction16, position)
					}
					if !_rules[ruleopen]() {
						goto l51
					}
					if !_rules[rulefield]() {
						goto l51
					}
					if !_rules[rulesp]() {
						goto l51
					}
					if buffer[position] != rune('=') {
						goto l51
					}
					position++
					if !_rules[rulesp]() {
						goto l51
					}
					if !_rules[rulefvalue]() {
						goto l51
					}
					if !_rules[rulecomma]() {
						goto l51
					}
					{
						position53, tokenIndex53 := position, tokenIndex
						if buffer[position] != rune('f') {
							goto l53
						}
						position++
						if buffer[position] != rune('r') {
							goto l53
						}
						position++
						if buffer[position] != rune('o') {
							goto l53
						}
						position++
						if buffer[position] != rune('m') {
							goto l53
						}
						position++
						if buffer[position] != rune('=') {
							goto l53
						}
						position++
						goto l54
					l53:
						position, tokenIndex = position53, tokenIndex53
					}
				l54:
					{
						add(ruleAction17, position)
					}
					if !_rules[ruletimestampfmt]() {
						goto l51
					}
					{
						add(ruleAction18, position)
					}
					if !_rules[rulecomma]() {
						goto l51
					}
					{
						position57, tokenIndex57 := position, tokenIndex
						if buffer[position] != rune('t') {
							goto l57
						}
						position++
						if buffer[position] != rune('o') {
							goto l57
						}
						position++
						if buffer[position] != rune('=') {
							goto l57
						}
						position++
						goto l58
					l57:
						position, tokenIndex = position57, tokenIndex57
					}
				l58:
					if !_rules[rulesp]() {
						goto l51
					}
					{
						add(ruleAction19, position)
					}
					if !_rules[ruletimestampfmt]() {
						goto l51
					}
					{
						add(ruleAction20, position)
					}
					if !_rules[ruleclose]() {
						goto l51
					}
					{
						add(ruleAction21, position)
					}
					goto l7
				l51:
					position, tokenIndex = position7, tokenIndex7
					{
						position62 := position
						if !_rules[ruleIDENT]() {
							goto l5
						}
						add(rulePegText, position62)
					}
					{
						add(ruleAction22, position)
					}
					if !_rules[ruleopen]() {
						goto l5
					}
					if !_rules[ruleallargs]() {
						goto l5
					}
					{
						position64, tokenIndex64 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l64
						}
						goto l65
					l64:
						position, tokenIndex = position64, tokenIndex64
					}
				l65:
					if !_rules[ruleclose]() {
						goto l5
					}
					{
						add(ruleAction23, position)
					}
				}
			l7:
				add(ruleCall, position6)
			}
			return true
		l5:
			position, tokenIndex = position5, tokenIndex5
			return false
		},
		/* 2 allargs <- <((Call (comma Call)* (comma dargs)?) / dargs / sp)> */
		func() bool {
			position67, tokenIndex67 := position, tokenIndex
			{
				position68 := position
				{
					position69, tokenIndex69 := position, tokenIndex
					if !_rules[ruleCall]() {
						goto l70
					}
				l71:
					{
						position72, tokenIndex72 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l72
						}
						if !_rules[ruleCall]() {
							goto l72
						}
						goto l71
					l72:
						position, tokenIndex = position72, tokenIndex72
					}
					{
						position73, tokenIndex73 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l73
						}
						if !_rules[ruledargs]() {
							goto l73
						}
						goto l74
					l73:
						position, tokenIndex = position73, tokenIndex73
					}
				l74:
					goto l69
				l70:
					position, tokenIndex = position69, tokenIndex69
					if !_rules[ruledargs]() {
						goto l75
					}
					goto l69
				l75:
					position, tokenIndex = position69, tokenIndex69
					if !_rules[rulesp]() {
						goto l67
					}
				}
			l69:
				add(ruleallargs, position68)
			}
			return true
		l67:
			position, tokenIndex = position67, tokenIndex67
			return false
		},
		/* 3 fargs <- <(farg (comma fargs)? sp)> */
		func() bool {
			position76, tokenIndex76 := position, tokenIndex
			{
				position77 := position
				{
					position78 := position
					{
						position79, tokenIndex79 := position, tokenIndex
						if !_rules[rulefield]() {
							goto l80
						}
						if !_rules[rulesp]() {
							goto l80
						}
						if buffer[position] != rune('=') {
							goto l80
						}
						position++
						if !_rules[rulesp]() {
							goto l80
						}
						if !_rules[rulefvalue]() {
							goto l80
						}
						goto l79
					l80:
						position, tokenIndex = position79, tokenIndex79
						if !_rules[rulefield]() {
							goto l81
						}
						if !_rules[rulesp]() {
							goto l81
						}
						if !_rules[ruleCOND]() {
							goto l81
						}
						if !_rules[rulesp]() {
							goto l81
						}
						if !_rules[rulefvalue]() {
							goto l81
						}
						goto l79
					l81:
						position, tokenIndex = position79, tokenIndex79
						if !_rules[ruleconditional]() {
							goto l76
						}
					}
				l79:
					add(rulefarg, position78)
				}
				{
					position82, tokenIndex82 := position, tokenIndex
					if !_rules[rulecomma]() {
						goto l82
					}
					if !_rules[rulefargs]() {
						goto l82
					}
					goto l83
				l82:
					position, tokenIndex = position82, tokenIndex82
				}
			l83:
				if !_rules[rulesp]() {
					goto l76
				}
				add(rulefargs, position77)
			}
			return true
		l76:
			position, tokenIndex = position76, tokenIndex76
			return false
		},
		/* 4 farg <- <((field sp '=' sp fvalue) / (field sp COND sp fvalue) / conditional)> */
		nil,
		/* 5 dargs <- <(darg (comma dargs)? sp)> */
		func() bool {
			position85, tokenIndex85 := position, tokenIndex
			{
				position86 := position
				if !_rules[ruledarg]() {
					goto l85
				}
				{
					position87, tokenIndex87 := position, tokenIndex
					if !_rules[rulecomma]() {
						goto l87
					}
					if !_rules[ruledargs]() {
						goto l87
					}
					goto l88
				l87:
					position, tokenIndex = position87, tokenIndex87
				}
			l88:
				if !_rules[rulesp]() {
					goto l85
				}
				add(ruledargs, position86)
			}
			return true
		l85:
			position, tokenIndex = position85, tokenIndex85
			return false
		},
		/* 6 darg <- <((field sp '=' sp dvalue) / (field sp COND sp dvalue) / conditional)> */
		func() bool {
			position89, tokenIndex89 := position, tokenIndex
			{
				position90 := position
				{
					position91, tokenIndex91 := position, tokenIndex
					if !_rules[rulefield]() {
						goto l92
					}
					if !_rules[rulesp]() {
						goto l92
					}
					if buffer[position] != rune('=') {
						goto l92
					}
					position++
					if !_rules[rulesp]() {
						goto l92
					}
					if !_rules[ruledvalue]() {
						goto l92
					}
					goto l91
				l92:
					position, tokenIndex = position91, tokenIndex91
					if !_rules[rulefield]() {
						goto l93
					}
					if !_rules[rulesp]() {
						goto l93
					}
					if !_rules[ruleCOND]() {
						goto l93
					}
					if !_rules[rulesp]() {
						goto l93
					}
					if !_rules[ruledvalue]() {
						goto l93
					}
					goto l91
				l93:
					position, tokenIndex = position91, tokenIndex91
					if !_rules[ruleconditional]() {
						goto l89
					}
				}
			l91:
				add(ruledarg, position90)
			}
			return true
		l89:
			position, tokenIndex = position89, tokenIndex89
			return false
		},
		/* 7 COND <- <(('>' '<' Action24) / ('<' '=' Action25) / ('>' '=' Action26) / ('=' '=' Action27) / ('!' '=' Action28) / ('<' Action29) / ('>' Action30))> */
		func() bool {
			position94, tokenIndex94 := position, tokenIndex
			{
				position95 := position
				{
					position96, tokenIndex96 := position, tokenIndex
					if buffer[position] != rune('>') {
						goto l97
					}
					position++
					if buffer[position] != rune('<') {
						goto l97
					}
					position++
					{
						add(ruleAction24, position)
					}
					goto l96
				l97:
					position, tokenIndex = position96, tokenIndex96
					if buffer[position] != rune('<') {
						goto l99
					}
					position++
					if buffer[position] != rune('=') {
						goto l99
					}
					position++
					{
						add(ruleAction25, position)
					}
					goto l96
				l99:
					position, tokenIndex = position96, tokenIndex96
					if buffer[position] != rune('>') {
						goto l101
					}
					position++
					if buffer[position] != rune('=') {
						goto l101
					}
					position++
					{
						add(ruleAction26, position)
					}
					goto l96
				l101:
					position, tokenIndex = position96, tokenIndex96
					if buffer[position] != rune('=') {
						goto l103
					}
					position++
					if buffer[position] != rune('=') {
						goto l103
					}
					position++
					{
						add(ruleAction27, position)
					}
					goto l96
				l103:
					position, tokenIndex = position96, tokenIndex96
					if buffer[position] != rune('!') {
						goto l105
					}
					position++
					if buffer[position] != rune('=') {
						goto l105
					}
					position++
					{
						add(ruleAction28, position)
					}
					goto l96
				l105:
					position, tokenIndex = position96, tokenIndex96
					if buffer[position] != rune('<') {
						goto l107
					}
					position++
					{
						add(ruleAction29, position)
					}
					goto l96
				l107:
					position, tokenIndex = position96, tokenIndex96
					if buffer[position] != rune('>') {
						goto l94
					}
					position++
					{
						add(ruleAction30, position)
					}
				}
			l96:
				add(ruleCOND, position95)
			}
			return true
		l94:
			position, tokenIndex = position94, tokenIndex94
			return false
		},
		/* 8 conditional <- <(Action31 condint condLT condfield condLT condint Action32)> */
		func() bool {
			position110, tokenIndex110 := position, tokenIndex
			{
				position111 := position
				{
					add(ruleAction31, position)
				}
				if !_rules[rulecondint]() {
					goto l110
				}
				if !_rules[rulecondLT]() {
					goto l110
				}
				{
					position113 := position
					{
						position114 := position
						if !_rules[rulefieldExpr]() {
							goto l110
						}
						add(rulePegText, position114)
					}
					if !_rules[rulesp]() {
						goto l110
					}
					{
						add(ruleAction35, position)
					}
					add(rulecondfield, position113)
				}
				if !_rules[rulecondLT]() {
					goto l110
				}
				if !_rules[rulecondint]() {
					goto l110
				}
				{
					add(ruleAction32, position)
				}
				add(ruleconditional, position111)
			}
			return true
		l110:
			position, tokenIndex = position110, tokenIndex110
			return false
		},
		/* 9 condint <- <(<(('-'? [0-9]* '.' [0-9]+) / '0' / ('-'? [1-9] [0-9]*))> sp Action33)> */
		func() bool {
			position117, tokenIndex117 := position, tokenIndex
			{
				position118 := position
				{
					position119 := position
					{
						position120, tokenIndex120 := position, tokenIndex
						{
							position122, tokenIndex122 := position, tokenIndex
							if buffer[position] != rune('-') {
								goto l122
							}
							position++
							goto l123
						l122:
							position, tokenIndex = position122, tokenIndex122
						}
					l123:
					l124:
						{
							position125, tokenIndex125 := position, tokenIndex
							if c := buffer[position]; c < rune('0') || c > rune('9') {
								goto l125
							}
							position++
							goto l124
						l125:
							position, tokenIndex = position125, tokenIndex125
						}
						if buffer[position] != rune('.') {
							goto l121
						}
						position++
						if c := buffer[position]; c < rune('0') || c > rune('9') {
							goto l121
						}
						position++
					l126:
						{
							position127, tokenIndex127 := position, tokenIndex
							if c := buffer[position]; c < rune('0') || c > rune('9') {
								goto l127
							}
							position++
							goto l126
						l127:
							position, tokenIndex = position127, tokenIndex127
						}
						goto l120
					l121:
						position, tokenIndex = position120, tokenIndex120
						if buffer[position] != rune('0') {
							goto l128
						}
						position++
						goto l120
					l128:
						position, tokenIndex = position120, tokenIndex120
						{
							position129, tokenIndex129 := position, tokenIndex
							if buffer[position] != rune('-') {
								goto l129
							}
							position++
							goto l130
						l129:
							position, tokenIndex = position129, tokenIndex129
						}
					l130:
						if c := buffer[position]; c < rune('1') || c > rune('9') {
							goto l117
						}
						position++
					l131:
						{
							position132, tokenIndex132 := position, tokenIndex
							if c := buffer[position]; c < rune('0') || c > rune('9') {
								goto l132
							}
							position++
							goto l131
						l132:
							position, tokenIndex = position132, tokenIndex132
						}
					}
				l120:
					add(rulePegText, position119)
				}
				if !_rules[rulesp]() {
					goto l117
				}
				{
					add(ruleAction33, position)
				}
				add(rulecondint, position118)
			}
			return true
		l117:
			position, tokenIndex = position117, tokenIndex117
			return false
		},
		/* 10 condLT <- <(<(('<' '=') / '<')> sp Action34)> */
		func() bool {
			position134, tokenIndex134 := position, tokenIndex
			{
				position135 := position
				{
					position136 := position
					{
						position137, tokenIndex137 := position, tokenIndex
						if buffer[position] != rune('<') {
							goto l138
						}
						position++
						if buffer[position] != rune('=') {
							goto l138
						}
						position++
						goto l137
					l138:
						position, tokenIndex = position137, tokenIndex137
						if buffer[position] != rune('<') {
							goto l134
						}
						position++
					}
				l137:
					add(rulePegText, position136)
				}
				if !_rules[rulesp]() {
					goto l134
				}
				{
					add(ruleAction34, position)
				}
				add(rulecondLT, position135)
			}
			return true
		l134:
			position, tokenIndex = position134, tokenIndex134
			return false
		},
		/* 11 condfield <- <(<fieldExpr> sp Action35)> */
		nil,
		/* 12 dvalue <- <(ditem / (lbrack Action36 dlist rbrack Action37))> */
		func() bool {
			position141, tokenIndex141 := position, tokenIndex
			{
				position142 := position
				{
					position143, tokenIndex143 := position, tokenIndex
					if !_rules[ruleditem]() {
						goto l144
					}
					goto l143
				l144:
					position, tokenIndex = position143, tokenIndex143
					if !_rules[rulelbrack]() {
						goto l141
					}
					{
						add(ruleAction36, position)
					}
					if !_rules[ruledlist]() {
						goto l141
					}
					if !_rules[rulerbrack]() {
						goto l141
					}
					{
						add(ruleAction37, position)
					}
				}
			l143:
				add(ruledvalue, position142)
			}
			return true
		l141:
			position, tokenIndex = position141, tokenIndex141
			return false
		},
		/* 13 fvalue <- <(fitem / (lbrack Action38 flist rbrack Action39))> */
		func() bool {
			position147, tokenIndex147 := position, tokenIndex
			{
				position148 := position
				{
					position149, tokenIndex149 := position, tokenIndex
					if !_rules[rulefitem]() {
						goto l150
					}
					goto l149
				l150:
					position, tokenIndex = position149, tokenIndex149
					if !_rules[rulelbrack]() {
						goto l147
					}
					{
						add(ruleAction38, position)
					}
					if !_rules[ruleflist]() {
						goto l147
					}
					if !_rules[rulerbrack]() {
						goto l147
					}
					{
						add(ruleAction39, position)
					}
				}
			l149:
				add(rulefvalue, position148)
			}
			return true
		l147:
			position, tokenIndex = position147, tokenIndex147
			return false
		},
		/* 14 dlist <- <(ditem (comma dlist)?)> */
		func() bool {
			position153, tokenIndex153 := position, tokenIndex
			{
				position154 := position
				if !_rules[ruleditem]() {
					goto l153
				}
				{
					position155, tokenIndex155 := position, tokenIndex
					if !_rules[rulecomma]() {
						goto l155
					}
					if !_rules[ruledlist]() {
						goto l155
					}
					goto l156
				l155:
					position, tokenIndex = position155, tokenIndex155
				}
			l156:
				add(ruledlist, position154)
			}
			return true
		l153:
			position, tokenIndex = position153, tokenIndex153
			return false
		},
		/* 15 flist <- <(fitem (comma flist)?)> */
		func() bool {
			position157, tokenIndex157 := position, tokenIndex
			{
				position158 := position
				if !_rules[rulefitem]() {
					goto l157
				}
				{
					position159, tokenIndex159 := position, tokenIndex
					if !_rules[rulecomma]() {
						goto l159
					}
					if !_rules[ruleflist]() {
						goto l159
					}
					goto l160
				l159:
					position, tokenIndex = position159, tokenIndex159
				}
			l160:
				add(ruleflist, position158)
			}
			return true
		l157:
			position, tokenIndex = position157, tokenIndex157
			return false
		},
		/* 16 ditem <- <(itema / decimal / itemb)> */
		func() bool {
			position161, tokenIndex161 := position, tokenIndex
			{
				position162 := position
				{
					position163, tokenIndex163 := position, tokenIndex
					if !_rules[ruleitema]() {
						goto l164
					}
					goto l163
				l164:
					position, tokenIndex = position163, tokenIndex163
					{
						position166 := position
						{
							position167, tokenIndex167 := position, tokenIndex
							{
								position169 := position
								{
									position170, tokenIndex170 := position, tokenIndex
									if buffer[position] != rune('-') {
										goto l170
									}
									position++
									goto l171
								l170:
									position, tokenIndex = position170, tokenIndex170
								}
							l171:
								if c := buffer[position]; c < rune('0') || c > rune('9') {
									goto l168
								}
								position++
							l172:
								{
									position173, tokenIndex173 := position, tokenIndex
									if c := buffer[position]; c < rune('0') || c > rune('9') {
										goto l173
									}
									position++
									goto l172
								l173:
									position, tokenIndex = position173, tokenIndex173
								}
								{
									position174, tokenIndex174 := position, tokenIndex
									if buffer[position] != rune('.') {
										goto l174
									}
									position++
								l176:
									{
										position177, tokenIndex177 := position, tokenIndex
										if c := buffer[position]; c < rune('0') || c > rune('9') {
											goto l177
										}
										position++
										goto l176
									l177:
										position, tokenIndex = position177, tokenIndex177
									}
									goto l175
								l174:
									position, tokenIndex = position174, tokenIndex174
								}
							l175:
								add(rulePegText, position169)
							}
							{
								add(ruleAction51, position)
							}
							goto l167
						l168:
							position, tokenIndex = position167, tokenIndex167
							{
								position179 := position
								{
									position180, tokenIndex180 := position, tokenIndex
									if buffer[position] != rune('-') {
										goto l180
									}
									position++
									goto l181
								l180:
									position, tokenIndex = position180, tokenIndex180
								}
							l181:
								if buffer[position] != rune('.') {
									goto l165
								}
								position++
								if c := buffer[position]; c < rune('0') || c > rune('9') {
									goto l165
								}
								position++
							l182:
								{
									position183, tokenIndex183 := position, tokenIndex
									if c := buffer[position]; c < rune('0') || c > rune('9') {
										goto l183
									}
									position++
									goto l182
								l183:
									position, tokenIndex = position183, tokenIndex183
								}
								add(rulePegText, position179)
							}
							{
								add(ruleAction52, position)
							}
						}
					l167:
						add(ruledecimal, position166)
					}
					goto l163
				l165:
					position, tokenIndex = position163, tokenIndex163
					if !_rules[ruleitemb]() {
						goto l161
					}
				}
			l163:
				add(ruleditem, position162)
			}
			return true
		l161:
			position, tokenIndex = position161, tokenIndex161
			return false
		},
		/* 17 fitem <- <(itema / float / itemb)> */
		func() bool {
			position185, tokenIndex185 := position, tokenIndex
			{
				position186 := position
				{
					position187, tokenIndex187 := position, tokenIndex
					if !_rules[ruleitema]() {
						goto l188
					}
					goto l187
				l188:
					position, tokenIndex = position187, tokenIndex187
					{
						position190 := position
						{
							position191, tokenIndex191 := position, tokenIndex
							{
								position193 := position
								{
									position194, tokenIndex194 := position, tokenIndex
									if buffer[position] != rune('-') {
										goto l194
									}
									position++
									goto l195
								l194:
									position, tokenIndex = position194, tokenIndex194
								}
							l195:
								if c := buffer[position]; c < rune('0') || c > rune('9') {
									goto l192
								}
								position++
							l196:
								{
									position197, tokenIndex197 := position, tokenIndex
									if c := buffer[position]; c < rune('0') || c > rune('9') {
										goto l197
									}
									position++
									goto l196
								l197:
									position, tokenIndex = position197, tokenIndex197
								}
								{
									position198, tokenIndex198 := position, tokenIndex
									if buffer[position] != rune('.') {
										goto l198
									}
									position++
								l200:
									{
										position201, tokenIndex201 := position, tokenIndex
										if c := buffer[position]; c < rune('0') || c > rune('9') {
											goto l201
										}
										position++
										goto l200
									l201:
										position, tokenIndex = position201, tokenIndex201
									}
									goto l199
								l198:
									position, tokenIndex = position198, tokenIndex198
								}
							l199:
								add(rulePegText, position193)
							}
							{
								add(ruleAction49, position)
							}
							goto l191
						l192:
							position, tokenIndex = position191, tokenIndex191
							{
								position203 := position
								{
									position204, tokenIndex204 := position, tokenIndex
									if buffer[position] != rune('-') {
										goto l204
									}
									position++
									goto l205
								l204:
									position, tokenIndex = position204, tokenIndex204
								}
							l205:
								if buffer[position] != rune('.') {
									goto l189
								}
								position++
								if c := buffer[position]; c < rune('0') || c > rune('9') {
									goto l189
								}
								position++
							l206:
								{
									position207, tokenIndex207 := position, tokenIndex
									if c := buffer[position]; c < rune('0') || c > rune('9') {
										goto l207
									}
									position++
									goto l206
								l207:
									position, tokenIndex = position207, tokenIndex207
								}
								add(rulePegText, position203)
							}
							{
								add(ruleAction50, position)
							}
						}
					l191:
						add(rulefloat, position190)
					}
					goto l187
				l189:
					position, tokenIndex = position187, tokenIndex187
					if !_rules[ruleitemb]() {
						goto l185
					}
				}
			l187:
				add(rulefitem, position186)
			}
			return true
		l185:
			position, tokenIndex = position185, tokenIndex185
			return false
		},
		/* 18 itema <- <(('n' 'u' 'l' 'l' &(comma / (sp close)) Action40) / ('t' 'r' 'u' 'e' &(comma / (sp close)) Action41) / ('f' 'a' 'l' 's' 'e' &(comma / (sp close)) Action42) / (timestampfmt Action43))> */
		func() bool {
			position209, tokenIndex209 := position, tokenIndex
			{
				position210 := position
				{
					position211, tokenIndex211 := position, tokenIndex
					if buffer[position] != rune('n') {
						goto l212
					}
					position++
					if buffer[position] != rune('u') {
						goto l212
					}
					position++
					if buffer[position] != rune('l') {
						goto l212
					}
					position++
					if buffer[position] != rune('l') {
						goto l212
					}
					position++
					{
						position213, tokenIndex213 := position, tokenIndex
						{
							position214, tokenIndex214 := position, tokenIndex
							if !_rules[rulecomma]() {
								goto l215
							}
							goto l214
						l215:
							position, tokenIndex = position214, tokenIndex214
							if !_rules[rulesp]() {
								goto l212
							}
							if !_rules[ruleclose]() {
								goto l212
							}
						}
					l214:
						position, tokenIndex = position213, tokenIndex213
					}
					{
						add(ruleAction40, position)
					}
					goto l211
				l212:
					position, tokenIndex = position211, tokenIndex211
					if buffer[position] != rune('t') {
						goto l217
					}
					position++
					if buffer[position] != rune('r') {
						goto l217
					}
					position++
					if buffer[position] != rune('u') {
						goto l217
					}
					position++
					if buffer[position] != rune('e') {
						goto l217
					}
					position++
					{
						position218, tokenIndex218 := position, tokenIndex
						{
							position219, tokenIndex219 := position, tokenIndex
							if !_rules[rulecomma]() {
								goto l220
							}
							goto l219
						l220:
							position, tokenIndex = position219, tokenIndex219
							if !_rules[rulesp]() {
								goto l217
							}
							if !_rules[ruleclose]() {
								goto l217
							}
						}
					l219:
						position, tokenIndex = position218, tokenIndex218
					}
					{
						add(ruleAction41, position)
					}
					goto l211
				l217:
					position, tokenIndex = position211, tokenIndex211
					if buffer[position] != rune('f') {
						goto l222
					}
					position++
					if buffer[position] != rune('a') {
						goto l222
					}
					position++
					if buffer[position] != rune('l') {
						goto l222
					}
					position++
					if buffer[position] != rune('s') {
						goto l222
					}
					position++
					if buffer[position] != rune('e') {
						goto l222
					}
					position++
					{
						position223, tokenIndex223 := position, tokenIndex
						{
							position224, tokenIndex224 := position, tokenIndex
							if !_rules[rulecomma]() {
								goto l225
							}
							goto l224
						l225:
							position, tokenIndex = position224, tokenIndex224
							if !_rules[rulesp]() {
								goto l222
							}
							if !_rules[ruleclose]() {
								goto l222
							}
						}
					l224:
						position, tokenIndex = position223, tokenIndex223
					}
					{
						add(ruleAction42, position)
					}
					goto l211
				l222:
					position, tokenIndex = position211, tokenIndex211
					if !_rules[ruletimestampfmt]() {
						goto l209
					}
					{
						add(ruleAction43, position)
					}
				}
			l211:
				add(ruleitema, position210)
			}
			return true
		l209:
			position, tokenIndex = position209, tokenIndex209
			return false
		},
		/* 19 itemb <- <((<IDENT> Action44 open allargs comma? close Action45) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action46) / (<('"' doublequotedstring '"')> Action47) / ('\'' <singlequotedstring> '\'' Action48))> */
		func() bool {
			position228, tokenIndex228 := position, tokenIndex
			{
				position229 := position
				{
					position230, tokenIndex230 := position, tokenIndex
					{
						position232 := position
						if !_rules[ruleIDENT]() {
							goto l231
						}
						add(rulePegText, position232)
					}
					{
						add(ruleAction44, position)
					}
					if !_rules[ruleopen]() {
						goto l231
					}
					if !_rules[ruleallargs]() {
						goto l231
					}
					{
						position234, tokenIndex234 := position, tokenIndex
						if !_rules[rulecomma]() {
							goto l234
						}
						goto l235
					l234:
						position, tokenIndex = position234, tokenIndex234
					}
				l235:
					if !_rules[ruleclose]() {
						goto l231
					}
					{
						add(ruleAction45, position)
					}
					goto l230
				l231:
					position, tokenIndex = position230, tokenIndex230
					{
						position238 := position
						{
							position241, tokenIndex241 := position, tokenIndex
							if c := buffer[position]; c < rune('a') || c > rune('z') {
								goto l242
							}
							position++
							goto l241
						l242:
							position, tokenIndex = position241, tokenIndex241
							if c := buffer[position]; c < rune('A') || c > rune('Z') {
								goto l243
							}
							position++
							goto l241
						l243:
							position, tokenIndex = position241, tokenIndex241
							if c := buffer[position]; c < rune('0') || c > rune('9') {
								goto l244
							}
							position++
							goto l241
						l244:
							position, tokenIndex = position241, tokenIndex241
							if buffer[position] != rune('-') {
								goto l245
							}
							position++
							goto l241
						l245:
							position, tokenIndex = position241, tokenIndex241
							if buffer[position] != rune('_') {
								goto l246
							}
							position++
							goto l241
						l246:
							position, tokenIndex = position241, tokenIndex241
							if buffer[position] != rune(':') {
								goto l237
							}
							position++
						}
					l241:
					l239:
						{
							position240, tokenIndex240 := position, tokenIndex
							{
								position247, tokenIndex247 := position, tokenIndex
								if c := buffer[position]; c < rune('a') || c > rune('z') {
									goto l248
								}
								position++
								goto l247
							l248:
								position, tokenIndex = position247, tokenIndex247
								if c := buffer[position]; c < rune('A') || c > rune('Z') {
									goto l249
								}
								position++
								goto l247
							l249:
								position, tokenIndex = position247, tokenIndex247
								if c := buffer[position]; c < rune('0') || c > rune('9') {
									goto l250
								}
								position++
								goto l247
							l250:
								position, tokenIndex = position247, tokenIndex247
								if buffer[position] != rune('-') {
									goto l251
								}
								position++
								goto l247
							l251:
								position, tokenIndex = position247, tokenIndex247
								if buffer[position] != rune('_') {
									goto l252
								}
								position++
								goto l247
							l252:
								position, tokenIndex = position247, tokenIndex247
								if buffer[position] != rune(':') {
									goto l240
								}
								position++
							}
						l247:
							goto l239
						l240:
							position, tokenIndex = position240, tokenIndex240
						}
						add(rulePegText, position238)
					}
					{
						add(ruleAction46, position)
					}
					goto l230
				l237:
					position, tokenIndex = position230, tokenIndex230
					{
						position255 := position
						if buffer[position] != rune('"') {
							goto l254
						}
						position++
						if !_rules[ruledoublequotedstring]() {
							goto l254
						}
						if buffer[position] != rune('"') {
							goto l254
						}
						position++
						add(rulePegText, position255)
					}
					{
						add(ruleAction47, position)
					}
					goto l230
				l254:
					position, tokenIndex = position230, tokenIndex230
					if buffer[position] != rune('\'') {
						goto l228
					}
					position++
					{
						position257 := position
						if !_rules[rulesinglequotedstring]() {
							goto l228
						}
						add(rulePegText, position257)
					}
					if buffer[position] != rune('\'') {
						goto l228
					}
					position++
					{
						add(ruleAction48, position)
					}
				}
			l230:
				add(ruleitemb, position229)
			}
			return true
		l228:
			position, tokenIndex = position228, tokenIndex228
			return false
		},
		/* 20 float <- <((<('-'? [0-9]+ ('.' [0-9]*)?)> Action49) / (<('-'? '.' [0-9]+)> Action50))> */
		nil,
		/* 21 decimal <- <((<('-'? [0-9]+ ('.' [0-9]*)?)> Action51) / (<('-'? '.' [0-9]+)> Action52))> */
		nil,
		/* 22 doublequotedstring <- <(('\\' '"') / ('\\' '\\') / (!'"' .))*> */
		func() bool {
			{
				position262 := position
			l263:
				{
					position264, tokenIndex264 := position, tokenIndex
					{
						position265, tokenIndex265 := position, tokenIndex
						if buffer[position] != rune('\\') {
							goto l266
						}
						position++
						if buffer[position] != rune('"') {
							goto l266
						}
						position++
						goto l265
					l266:
						position, tokenIndex = position265, tokenIndex265
						if buffer[position] != rune('\\') {
							goto l267
						}
						position++
						if buffer[position] != rune('\\') {
							goto l267
						}
						position++
						goto l265
					l267:
						position, tokenIndex = position265, tokenIndex265
						{
							position268, tokenIndex268 := position, tokenIndex
							if buffer[position] != rune('"') {
								goto l268
							}
							position++
							goto l264
						l268:
							position, tokenIndex = position268, tokenIndex268
						}
						if !matchDot() {
							goto l264
						}
					}
				l265:
					goto l263
				l264:
					position, tokenIndex = position264, tokenIndex264
				}
				add(ruledoublequotedstring, position262)
			}
			return true
		},
		/* 23 singlequotedstring <- <(('\\' '\'') / ('\\' '\\') / (!'\'' .))*> */
		func() bool {
			{
				position270 := position
			l271:
				{
					position272, tokenIndex272 := position, tokenIndex
					{
						position273, tokenIndex273 := position, tokenIndex
						if buffer[position] != rune('\\') {
							goto l274
						}
						position++
						if buffer[position] != rune('\'') {
							goto l274
						}
						position++
						goto l273
					l274:
						position, tokenIndex = position273, tokenIndex273
						if buffer[position] != rune('\\') {
							goto l275
						}
						position++
						if buffer[position] != rune('\\') {
							goto l275
						}
						position++
						goto l273
					l275:
						position, tokenIndex = position273, tokenIndex273
						{
							position276, tokenIndex276 := position, tokenIndex
							if buffer[position] != rune('\'') {
								goto l276
							}
							position++
							goto l272
						l276:
							position, tokenIndex = position276, tokenIndex276
						}
						if !matchDot() {
							goto l272
						}
					}
				l273:
					goto l271
				l272:
					position, tokenIndex = position272, tokenIndex272
				}
				add(rulesinglequotedstring, position270)
			}
			return true
		},
		/* 24 fieldExpr <- <(([a-z] / [A-Z] / '_') ([a-z] / [A-Z] / [0-9] / '_' / '-')*)> */
		func() bool {
			position277, tokenIndex277 := position, tokenIndex
			{
				position278 := position
				{
					position279, tokenIndex279 := position, tokenIndex
					if c := buffer[position]; c < rune('a') || c > rune('z') {
						goto l280
					}
					position++
					goto l279
				l280:
					position, tokenIndex = position279, tokenIndex279
					if c := buffer[position]; c < rune('A') || c > rune('Z') {
						goto l281
					}
					position++
					goto l279
				l281:
					position, tokenIndex = position279, tokenIndex279
					if buffer[position] != rune('_') {
						goto l277
					}
					position++
				}
			l279:
			l282:
				{
					position283, tokenIndex283 := position, tokenIndex
					{
						position284, tokenIndex284 := position, tokenIndex
						if c := buffer[position]; c < rune('a') || c > rune('z') {
							goto l285
						}
						position++
						goto l284
					l285:
						position, tokenIndex = position284, tokenIndex284
						if c := buffer[position]; c < rune('A') || c > rune('Z') {
							goto l286
						}
						position++
						goto l284
					l286:
						position, tokenIndex = position284, tokenIndex284
						if c := buffer[position]; c < rune('0') || c > rune('9') {
							goto l287
						}
						position++
						goto l284
					l287:
						position, tokenIndex = position284, tokenIndex284
						if buffer[position] != rune('_') {
							goto l288
						}
						position++
						goto l284
					l288:
						position, tokenIndex = position284, tokenIndex284
						if buffer[position] != rune('-') {
							goto l283
						}
						position++
					}
				l284:
					goto l282
				l283:
					position, tokenIndex = position283, tokenIndex283
				}
				add(rulefieldExpr, position278)
			}
			return true
		l277:
			position, tokenIndex = position277, tokenIndex277
			return false
		},
		/* 25 field <- <(<(fieldExpr / reserved)> Action53)> */
		func() bool {
			position289, tokenIndex289 := position, tokenIndex
			{
				position290 := position
				{
					position291 := position
					{
						position292, tokenIndex292 := position, tokenIndex
						if !_rules[rulefieldExpr]() {
							goto l293
						}
						goto l292
					l293:
						position, tokenIndex = position292, tokenIndex292
						{
							position294 := position
							{
								position295, tokenIndex295 := position, tokenIndex
								if buffer[position] != rune('_') {
									goto l296
								}
								position++
								if buffer[position] != rune('r') {
									goto l296
								}
								position++
								if buffer[position] != rune('o') {
									goto l296
								}
								position++
								if buffer[position] != rune('w') {
									goto l296
								}
								position++
								goto l295
							l296:
								position, tokenIndex = position295, tokenIndex295
								if buffer[position] != rune('_') {
									goto l297
								}
								position++
								if buffer[position] != rune('c') {
									goto l297
								}
								position++
								if buffer[position] != rune('o') {
									goto l297
								}
								position++
								if buffer[position] != rune('l') {
									goto l297
								}
								position++
								goto l295
							l297:
								position, tokenIndex = position295, tokenIndex295
								if buffer[position] != rune('_') {
									goto l298
								}
								position++
								if buffer[position] != rune('s') {
									goto l298
								}
								position++
								if buffer[position] != rune('t') {
									goto l298
								}
								position++
								if buffer[position] != rune('a') {
									goto l298
								}
								position++
								if buffer[position] != rune('r') {
									goto l298
								}
								position++
								if buffer[position] != rune('t') {
									goto l298
								}
								position++
								goto l295
							l298:
								position, tokenIndex = position295, tokenIndex295
								if buffer[position] != rune('_') {
									goto l299
								}
								position++
								if buffer[position] != rune('e') {
									goto l299
								}
								position++
								if buffer[position] != rune('n') {
									goto l299
								}
								position++
								if buffer[position] != rune('d') {
									goto l299
								}
								position++
								goto l295
							l299:
								position, tokenIndex = position295, tokenIndex295
								if buffer[position] != rune('_') {
									goto l300
								}
								position++
								if buffer[position] != rune('t') {
									goto l300
								}
								position++
								if buffer[position] != rune('i') {
									goto l300
								}
								position++
								if buffer[position] != rune('m') {
									goto l300
								}
								position++
								if buffer[position] != rune('e') {
									goto l300
								}
								position++
								if buffer[position] != rune('s') {
									goto l300
								}
								position++
								if buffer[position] != rune('t') {
									goto l300
								}
								position++
								if buffer[position] != rune('a') {
									goto l300
								}
								position++
								if buffer[position] != rune('m') {
									goto l300
								}
								position++
								if buffer[position] != rune('p') {
									goto l300
								}
								position++
								goto l295
							l300:
								position, tokenIndex = position295, tokenIndex295
								if buffer[position] != rune('_') {
									goto l289
								}
								position++
								if buffer[position] != rune('f') {
									goto l289
								}
								position++
								if buffer[position] != rune('i') {
									goto l289
								}
								position++
								if buffer[position] != rune('e') {
									goto l289
								}
								position++
								if buffer[position] != rune('l') {
									goto l289
								}
								position++
								if buffer[position] != rune('d') {
									goto l289
								}
								position++
							}
						l295:
							add(rulereserved, position294)
						}
					}
				l292:
					add(rulePegText, position291)
				}
				{
					add(ruleAction53, position)
				}
				add(rulefield, position290)
			}
			return true
		l289:
			position, tokenIndex = position289, tokenIndex289
			return false
		},
		/* 26 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,
		/* 27 posfield <- <(<fieldExpr> Action54)> */
		func() bool {
			position303, tokenIndex303 := position, tokenIndex
			{
				position304 := position
				{
					position305 := position
					if !_rules[rulefieldExpr]() {
						goto l303
					}
					add(rulePegText, position305)
				}
				{
					add(ruleAction54, position)
				}
				add(ruleposfield, position304)
			}
			return true
		l303:
			position, tokenIndex = position303, tokenIndex303
			return false
		},
		/* 28 uint <- <(([1-9] [0-9]*) / '0')> */
		func() bool {
			position307, tokenIndex307 := position, tokenIndex
			{
				position308 := position
				{
					position309, tokenIndex309 := position, tokenIndex
					if c := buffer[position]; c < rune('1') || c > rune('9') {
						goto l310
					}
					position++
				l311:
					{
						position312, tokenIndex312 := position, tokenIndex
						if c := buffer[position]; c < rune('0') || c > rune('9') {
							goto l312
						}
						position++
						goto l311
					l312:
						position, tokenIndex = position312, tokenIndex312
					}
					goto l309
				l310:
					position, tokenIndex = position309, tokenIndex309
					if buffer[position] != rune('0') {
						goto l307
					}
					position++
				}
			l309:
				add(ruleuint, position308)
			}
			return true
		l307:
			position, tokenIndex = position307, tokenIndex307
			return false
		},
		/* 29 col <- <((<uint> Action55) / ('\'' <singlequotedstring> '\'' Action56) / ('"' <doublequotedstring> '"' Action57))> */
		func() bool {
			position313, tokenIndex313 := position, tokenIndex
			{
				position314 := position
				{
					position315, tokenIndex315 := position, tokenIndex
					{
						position317 := position
						if !_rules[ruleuint]() {
							goto l316
						}
						add(rulePegText, position317)
					}
					{
						add(ruleAction55, position)
					}
					goto l315
				l316:
					position, tokenIndex = position315, tokenIndex315
					if buffer[position] != rune('\'') {
						goto l319
					}
					position++
					{
						position320 := position
						if !_rules[rulesinglequotedstring]() {
							goto l319
						}
						add(rulePegText, position320)
					}
					if buffer[position] != rune('\'') {
						goto l319
					}
					position++
					{
						add(ruleAction56, position)
					}
					goto l315
				l319:
					position, tokenIndex = position315, tokenIndex315
					if buffer[position] != rune('"') {
						goto l313
					}
					position++
					{
						position322 := position
						if !_rules[ruledoublequotedstring]() {
							goto l313
						}
						add(rulePegText, position322)
					}
					if buffer[position] != rune('"') {
						goto l313
					}
					position++
					{
						add(ruleAction57, position)
					}
				}
			l315:
				add(rulecol, position314)
			}
			return true
		l313:
			position, tokenIndex = position313, tokenIndex313
			return false
		},
		/* 30 row <- <((<uint> Action58) / ('\'' <singlequotedstring> '\'' Action59) / ('"' <doublequotedstring> '"' Action60))> */
		nil,
		/* 31 open <- <('(' sp)> */
		func() bool {
			position325, tokenIndex325 := position, tokenIndex
			{
				position326 := position
				if buffer[position] != rune('(') {
					goto l325
				}
				position++
				if !_rules[rulesp]() {
					goto l325
				}
				add(ruleopen, position326)
			}
			return true
		l325:
			position, tokenIndex = position325, tokenIndex325
			return false
		},
		/* 32 close <- <(')' sp)> */
		func() bool {
			position327, tokenIndex327 := position, tokenIndex
			{
				position328 := position
				if buffer[position] != rune(')') {
					goto l327
				}
				position++
				if !_rules[rulesp]() {
					goto l327
				}
				add(ruleclose, position328)
			}
			return true
		l327:
			position, tokenIndex = position327, tokenIndex327
			return false
		},
		/* 33 sp <- <(' ' / '\t' / '\n')*> */
		func() bool {
			{
				position330 := position
			l331:
				{
					position332, tokenIndex332 := position, tokenIndex
					{
						position333, tokenIndex333 := position, tokenIndex
						if buffer[position] != rune(' ') {
							goto l334
						}
						position++
						goto l333
					l334:
						position, tokenIndex = position333, tokenIndex333
						if buffer[position] != rune('\t') {
							goto l335
						}
						position++
						goto l333
					l335:
						position, tokenIndex = position333, tokenIndex333
						if buffer[position] != rune('\n') {
							goto l332
						}
						position++
					}
				l333:
					goto l331
				l332:
					position, tokenIndex = position332, tokenIndex332
				}
				add(rulesp, position330)
			}
			return true
		},
		/* 34 comma <- <(sp ',' sp)> */
		func() bool {
			position336, tokenIndex336 := position, tokenIndex
			{
				position337 := position
				if !_rules[rulesp]() {
					goto l336
				}
				if buffer[position] != rune(',') {
					goto l336
				}
				position++
				if !_rules[rulesp]() {
					goto l336
				}
				add(rulecomma, position337)
			}
			return true
		l336:
			position, tokenIndex = position336, tokenIndex336
			return false
		},
		/* 35 lbrack <- <('[' sp)> */
		func() bool {
			position338, tokenIndex338 := position, tokenIndex
			{
				position339 := position
				if buffer[position] != rune('[') {
					goto l338
				}
				position++
				if !_rules[rulesp]() {
					goto l338
				}
				add(rulelbrack, position339)
			}
			return true
		l338:
			position, tokenIndex = position338, tokenIndex338
			return false
		},
		/* 36 rbrack <- <(sp ']' sp)> */
		func() bool {
			position340, tokenIndex340 := position, tokenIndex
			{
				position341 := position
				if !_rules[rulesp]() {
					goto l340
				}
				if buffer[position] != rune(']') {
					goto l340
				}
				position++
				if !_rules[rulesp]() {
					goto l340
				}
				add(rulerbrack, position341)
			}
			return true
		l340:
			position, tokenIndex = position340, tokenIndex340
			return false
		},
		/* 37 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
		func() bool {
			position342, tokenIndex342 := position, tokenIndex
			{
				position343 := position
				{
					position344, tokenIndex344 := position, tokenIndex
					if c := buffer[position]; c < rune('a') || c > rune('z') {
						goto l345
					}
					position++
					goto l344
				l345:
					position, tokenIndex = position344, tokenIndex344
					if c := buffer[position]; c < rune('A') || c > rune('Z') {
						goto l342
					}
					position++
				}
			l344:
			l346:
				{
					position347, tokenIndex347 := position, tokenIndex
					{
						position348, tokenIndex348 := position, tokenIndex
						if c := buffer[position]; c < rune('a') || c > rune('z') {
							goto l349
						}
						position++
						goto l348
					l349:
						position, tokenIndex = position348, tokenIndex348
						if c := buffer[position]; c < rune('A') || c > rune('Z') {
							goto l350
						}
						position++
						goto l348
					l350:
						position, tokenIndex = position348, tokenIndex348
						if c := buffer[position]; c < rune('0') || c > rune('9') {
							goto l347
						}
						position++
					}
				l348:
					goto l346
				l347:
					position, tokenIndex = position347, tokenIndex347
				}
				add(ruleIDENT, position343)
			}
			return true
		l342:
			position, tokenIndex = position342, tokenIndex342
			return false
		},
		/* 38 timestampbasicfmt <- <([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 {
			position351, tokenIndex351 := position, tokenIndex
			{
				position352 := position
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if buffer[position] != rune('-') {
					goto l351
				}
				position++
				{
					position353, tokenIndex353 := position, tokenIndex
					if buffer[position] != rune('0') {
						goto l354
					}
					position++
					goto l353
				l354:
					position, tokenIndex = position353, tokenIndex353
					if buffer[position] != rune('1') {
						goto l351
					}
					position++
				}
			l353:
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if buffer[position] != rune('-') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('3') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if buffer[position] != rune('T') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if buffer[position] != rune(':') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l351
				}
				position++
				add(ruletimestampbasicfmt, position352)
			}
			return true
		l351:
			position, tokenIndex = position351, tokenIndex351
			return false
		},
		/* 39 timestampfmt <- <(('"' <timestampbasicfmt> '"') / ('\'' <timestampbasicfmt> '\'') / <timestampbasicfmt>)> */
		func() bool {
			position355, tokenIndex355 := position, tokenIndex
			{
				position356 := position
				{
					position357, tokenIndex357 := position, tokenIndex
					if buffer[position] != rune('"') {
						goto l358
					}
					position++
					{
						position359 := position
						if !_rules[ruletimestampbasicfmt]() {
							goto l358
						}
						add(rulePegText, position359)
					}
					if buffer[position] != rune('"') {
						goto l358
					}
					position++
					goto l357
				l358:
					position, tokenIndex = position357, tokenIndex357
					if buffer[position] != rune('\'') {
						goto l360
					}
					position++
					{
						position361 := position
						if !_rules[ruletimestampbasicfmt]() {
							goto l360
						}
						add(rulePegText, position361)
					}
					if buffer[position] != rune('\'') {
						goto l360
					}
					position++
					goto l357
				l360:
					position, tokenIndex = position357, tokenIndex357
					{
						position362 := position
						if !_rules[ruletimestampbasicfmt]() {
							goto l355
						}
						add(rulePegText, position362)
					}
				}
			l357:
				add(ruletimestampfmt, position356)
			}
			return true
		l355:
			position, tokenIndex = position355, tokenIndex355
			return false
		},
		/* 40 timestamp <- <(<timestampfmt> Action61)> */
		nil,
		/* 42 Action0 <- <{p.startCall("Set")}> */
		nil,
		/* 43 Action1 <- <{p.endCall()}> */
		nil,
		/* 44 Action2 <- <{p.startCall("SetRowAttrs")}> */
		nil,
		/* 45 Action3 <- <{p.endCall()}> */
		nil,
		/* 46 Action4 <- <{p.startCall("SetColumnAttrs")}> */
		nil,
		/* 47 Action5 <- <{p.endCall()}> */
		nil,
		/* 48 Action6 <- <{p.startCall("Clear")}> */
		nil,
		/* 49 Action7 <- <{p.endCall()}> */
		nil,
		/* 50 Action8 <- <{p.startCall("ClearRow")}> */
		nil,
		/* 51 Action9 <- <{p.endCall()}> */
		nil,
		/* 52 Action10 <- <{p.startCall("Store")}> */
		nil,
		/* 53 Action11 <- <{p.endCall()}> */
		nil,
		/* 54 Action12 <- <{p.startCall("TopN")}> */
		nil,
		/* 55 Action13 <- <{p.endCall()}> */
		nil,
		/* 56 Action14 <- <{p.startCall("Rows")}> */
		nil,
		/* 57 Action15 <- <{p.endCall()}> */
		nil,
		/* 58 Action16 <- <{p.startCall("Range")}> */
		nil,
		/* 59 Action17 <- <{p.addField("from")}> */
		nil,
		/* 60 Action18 <- <{p.addVal(buffer[begin:end])}> */
		nil,
		/* 61 Action19 <- <{p.addField("to")}> */
		nil,
		/* 62 Action20 <- <{p.addVal(buffer[begin:end])}> */
		nil,
		/* 63 Action21 <- <{p.endCall()}> */
		nil,
		nil,
		/* 65 Action22 <- <{ p.startCall(buffer[begin:end] ) }> */
		nil,
		/* 66 Action23 <- <{ p.endCall() }> */
		nil,
		/* 67 Action24 <- <{ p.addBTWN() }> */
		nil,
		/* 68 Action25 <- <{ p.addLTE() }> */
		nil,
		/* 69 Action26 <- <{ p.addGTE() }> */
		nil,
		/* 70 Action27 <- <{ p.addEQ() }> */
		nil,
		/* 71 Action28 <- <{ p.addNEQ() }> */
		nil,
		/* 72 Action29 <- <{ p.addLT() }> */
		nil,
		/* 73 Action30 <- <{ p.addGT() }> */
		nil,
		/* 74 Action31 <- <{p.startConditional()}> */
		nil,
		/* 75 Action32 <- <{p.endConditional()}> */
		nil,
		/* 76 Action33 <- <{p.condAdd(buffer[begin:end])}> */
		nil,
		/* 77 Action34 <- <{p.condAdd(buffer[begin:end])}> */
		nil,
		/* 78 Action35 <- <{p.condAdd(buffer[begin:end])}> */
		nil,
		/* 79 Action36 <- <{ p.startList() }> */
		nil,
		/* 80 Action37 <- <{ p.endList() }> */
		nil,
		/* 81 Action38 <- <{ p.startList() }> */
		nil,
		/* 82 Action39 <- <{ p.endList() }> */
		nil,
		/* 83 Action40 <- <{ p.addVal(nil) }> */
		nil,
		/* 84 Action41 <- <{ p.addVal(true) }> */
		nil,
		/* 85 Action42 <- <{ p.addVal(false) }> */
		nil,
		/* 86 Action43 <- <{ p.addVal(buffer[begin:end]) }> */
		nil,
		/* 87 Action44 <- <{ p.startCall(buffer[begin:end]) }> */
		nil,
		/* 88 Action45 <- <{ p.addVal(p.endCall()) }> */
		nil,
		/* 89 Action46 <- <{ p.addVal(buffer[begin:end]) }> */
		nil,
		/* 90 Action47 <- <{ s, _ := strconv.Unquote(buffer[begin:end]); p.addVal(s) }> */
		nil,
		/* 91 Action48 <- <{ p.addVal(buffer[begin:end]) }> */
		nil,
		/* 92 Action49 <- <{ p.addNumVal(buffer[begin:end], true) }> */
		nil,
		/* 93 Action50 <- <{ p.addNumVal(buffer[begin:end], true) }> */
		nil,
		/* 94 Action51 <- <{ p.addNumVal(buffer[begin:end], false) }> */
		nil,
		/* 95 Action52 <- <{ p.addNumVal(buffer[begin:end], false) }> */
		nil,
		/* 96 Action53 <- <{ p.addField(buffer[begin:end]) }> */
		nil,
		/* 97 Action54 <- <{ p.addPosStr("_field", buffer[begin:end]) }> */
		nil,
		/* 98 Action55 <- <{p.addPosNum("_col", buffer[begin:end])}> */
		nil,
		/* 99 Action56 <- <{p.addPosStr("_col", buffer[begin:end])}> */
		nil,
		/* 100 Action57 <- <{p.addPosStr("_col", buffer[begin:end])}> */
		nil,
		/* 101 Action58 <- <{p.addPosNum("_row", buffer[begin:end])}> */
		nil,
		/* 102 Action59 <- <{p.addPosStr("_row", buffer[begin:end])}> */
		nil,
		/* 103 Action60 <- <{p.addPosStr("_row", buffer[begin:end])}> */
		nil,
		/* 104 Action61 <- <{p.addPosStr("_timestamp", buffer[begin:end])}> */
		nil,
	}
	p.rules = _rules
	return nil
}