2587 lines
62 KiB
Go
2587 lines
62 KiB
Go
package toml
|
||
|
||
import (
|
||
"fmt"
|
||
"math"
|
||
"sort"
|
||
"strconv"
|
||
)
|
||
|
||
const endSymbol rune = 1114112
|
||
|
||
/* The rule types inferred from the grammar are below. */
|
||
type pegRule uint8
|
||
|
||
const (
|
||
ruleUnknown pegRule = iota
|
||
ruleTOML
|
||
ruleExpression
|
||
rulenewline
|
||
rulews
|
||
rulewsnl
|
||
rulecomment
|
||
rulekeyval
|
||
rulekey
|
||
rulebareKey
|
||
rulequotedKey
|
||
ruleval
|
||
ruletable
|
||
rulestdTable
|
||
rulearrayTable
|
||
ruleinlineTable
|
||
ruleinlineTableKeyValues
|
||
ruletableKey
|
||
ruletableKeyComp
|
||
ruletableKeySep
|
||
ruleinlineTableValSep
|
||
ruleinteger
|
||
ruleint
|
||
rulefloat
|
||
rulefrac
|
||
ruleexp
|
||
rulestring
|
||
rulebasicString
|
||
rulebasicChar
|
||
ruleescaped
|
||
rulebasicUnescaped
|
||
ruleescape
|
||
rulemlBasicString
|
||
rulemlBasicBody
|
||
ruleliteralString
|
||
ruleliteralChar
|
||
rulemlLiteralString
|
||
rulemlLiteralBody
|
||
rulemlLiteralChar
|
||
rulehexdigit
|
||
rulehexQuad
|
||
ruleboolean
|
||
ruledateFullYear
|
||
ruledateMonth
|
||
ruledateMDay
|
||
ruletimeHour
|
||
ruletimeMinute
|
||
ruletimeSecond
|
||
ruletimeSecfrac
|
||
ruletimeNumoffset
|
||
ruletimeOffset
|
||
rulepartialTime
|
||
rulefullDate
|
||
rulefullTime
|
||
ruledatetime
|
||
ruledigit
|
||
ruledigitDual
|
||
ruledigitQuad
|
||
rulearray
|
||
rulearrayValues
|
||
rulearraySep
|
||
ruleAction0
|
||
rulePegText
|
||
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
|
||
)
|
||
|
||
var rul3s = [...]string{
|
||
"Unknown",
|
||
"TOML",
|
||
"Expression",
|
||
"newline",
|
||
"ws",
|
||
"wsnl",
|
||
"comment",
|
||
"keyval",
|
||
"key",
|
||
"bareKey",
|
||
"quotedKey",
|
||
"val",
|
||
"table",
|
||
"stdTable",
|
||
"arrayTable",
|
||
"inlineTable",
|
||
"inlineTableKeyValues",
|
||
"tableKey",
|
||
"tableKeyComp",
|
||
"tableKeySep",
|
||
"inlineTableValSep",
|
||
"integer",
|
||
"int",
|
||
"float",
|
||
"frac",
|
||
"exp",
|
||
"string",
|
||
"basicString",
|
||
"basicChar",
|
||
"escaped",
|
||
"basicUnescaped",
|
||
"escape",
|
||
"mlBasicString",
|
||
"mlBasicBody",
|
||
"literalString",
|
||
"literalChar",
|
||
"mlLiteralString",
|
||
"mlLiteralBody",
|
||
"mlLiteralChar",
|
||
"hexdigit",
|
||
"hexQuad",
|
||
"boolean",
|
||
"dateFullYear",
|
||
"dateMonth",
|
||
"dateMDay",
|
||
"timeHour",
|
||
"timeMinute",
|
||
"timeSecond",
|
||
"timeSecfrac",
|
||
"timeNumoffset",
|
||
"timeOffset",
|
||
"partialTime",
|
||
"fullDate",
|
||
"fullTime",
|
||
"datetime",
|
||
"digit",
|
||
"digitDual",
|
||
"digitQuad",
|
||
"array",
|
||
"arrayValues",
|
||
"arraySep",
|
||
"Action0",
|
||
"PegText",
|
||
"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",
|
||
}
|
||
|
||
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(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.Printf(" ")
|
||
}
|
||
rule := rul3s[node.pegRule]
|
||
quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
|
||
if !pretty {
|
||
fmt.Printf("%v %v\n", rule, quote)
|
||
} else {
|
||
fmt.Printf("\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(buffer string) {
|
||
node.print(false, buffer)
|
||
}
|
||
|
||
func (node *node32) PrettyPrint(buffer string) {
|
||
node.print(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(buffer)
|
||
}
|
||
|
||
func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
|
||
t.AST().PrettyPrint(buffer)
|
||
}
|
||
|
||
func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
|
||
if tree := t.tree; int(index) >= len(tree) {
|
||
expanded := make([]token32, 2*len(tree))
|
||
copy(expanded, tree)
|
||
t.tree = expanded
|
||
}
|
||
t.tree[index] = token32{
|
||
pegRule: rule,
|
||
begin: begin,
|
||
end: end,
|
||
}
|
||
}
|
||
|
||
func (t *tokens32) Tokens() []token32 {
|
||
return t.tree
|
||
}
|
||
|
||
type tomlParser struct {
|
||
toml
|
||
|
||
Buffer string
|
||
buffer []rune
|
||
rules [88]func() bool
|
||
parse func(rule ...int) error
|
||
reset func()
|
||
Pretty bool
|
||
tokens32
|
||
}
|
||
|
||
func (p *tomlParser) Parse(rule ...int) error {
|
||
return p.parse(rule...)
|
||
}
|
||
|
||
func (p *tomlParser) 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 *tomlParser
|
||
max token32
|
||
}
|
||
|
||
func (e *parseError) Error() string {
|
||
tokens, error := []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)
|
||
error += 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 error
|
||
}
|
||
|
||
func (p *tomlParser) PrintSyntaxTree() {
|
||
if p.Pretty {
|
||
p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
|
||
} else {
|
||
p.tokens32.PrintSyntaxTree(p.Buffer)
|
||
}
|
||
}
|
||
|
||
func (p *tomlParser) 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:
|
||
_ = buffer
|
||
case ruleAction1:
|
||
p.SetTableString(begin, end)
|
||
case ruleAction2:
|
||
p.AddLineCount(end - begin)
|
||
case ruleAction3:
|
||
p.AddLineCount(end - begin)
|
||
case ruleAction4:
|
||
p.AddKeyValue()
|
||
case ruleAction5:
|
||
p.SetKey(p.buffer, begin, end)
|
||
case ruleAction6:
|
||
p.SetKey(p.buffer, begin, end)
|
||
case ruleAction7:
|
||
p.SetTime(begin, end)
|
||
case ruleAction8:
|
||
p.SetFloat64(begin, end)
|
||
case ruleAction9:
|
||
p.SetInt64(begin, end)
|
||
case ruleAction10:
|
||
p.SetString(begin, end)
|
||
case ruleAction11:
|
||
p.SetBool(begin, end)
|
||
case ruleAction12:
|
||
p.SetArray(begin, end)
|
||
case ruleAction13:
|
||
p.SetTable(p.buffer, begin, end)
|
||
case ruleAction14:
|
||
p.SetArrayTable(p.buffer, begin, end)
|
||
case ruleAction15:
|
||
p.StartInlineTable()
|
||
case ruleAction16:
|
||
p.EndInlineTable()
|
||
case ruleAction17:
|
||
p.AddTableKey()
|
||
case ruleAction18:
|
||
p.SetBasicString(p.buffer, begin, end)
|
||
case ruleAction19:
|
||
p.SetMultilineString()
|
||
case ruleAction20:
|
||
p.AddMultilineBasicBody(p.buffer, begin, end)
|
||
case ruleAction21:
|
||
p.SetLiteralString(p.buffer, begin, end)
|
||
case ruleAction22:
|
||
p.SetMultilineLiteralString(p.buffer, begin, end)
|
||
case ruleAction23:
|
||
p.StartArray()
|
||
case ruleAction24:
|
||
p.AddArrayVal()
|
||
case ruleAction25:
|
||
p.AddArrayVal()
|
||
|
||
}
|
||
}
|
||
_, _, _, _, _ = buffer, _buffer, text, begin, end
|
||
}
|
||
|
||
func (p *tomlParser) Init() {
|
||
var (
|
||
max token32
|
||
position, tokenIndex uint32
|
||
buffer []rune
|
||
)
|
||
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 := tokens32{tree: make([]token32, math.MaxInt16)}
|
||
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 TOML <- <(Expression (newline Expression)* newline? !. Action0)> */
|
||
func() bool {
|
||
position0, tokenIndex0 := position, tokenIndex
|
||
{
|
||
position1 := position
|
||
if !_rules[ruleExpression]() {
|
||
goto l0
|
||
}
|
||
l2:
|
||
{
|
||
position3, tokenIndex3 := position, tokenIndex
|
||
if !_rules[rulenewline]() {
|
||
goto l3
|
||
}
|
||
if !_rules[ruleExpression]() {
|
||
goto l3
|
||
}
|
||
goto l2
|
||
l3:
|
||
position, tokenIndex = position3, tokenIndex3
|
||
}
|
||
{
|
||
position4, tokenIndex4 := position, tokenIndex
|
||
if !_rules[rulenewline]() {
|
||
goto l4
|
||
}
|
||
goto l5
|
||
l4:
|
||
position, tokenIndex = position4, tokenIndex4
|
||
}
|
||
l5:
|
||
{
|
||
position6, tokenIndex6 := position, tokenIndex
|
||
if !matchDot() {
|
||
goto l6
|
||
}
|
||
goto l0
|
||
l6:
|
||
position, tokenIndex = position6, tokenIndex6
|
||
}
|
||
{
|
||
add(ruleAction0, position)
|
||
}
|
||
add(ruleTOML, position1)
|
||
}
|
||
return true
|
||
l0:
|
||
position, tokenIndex = position0, tokenIndex0
|
||
return false
|
||
},
|
||
/* 1 Expression <- <((<(ws table ws comment? (wsnl keyval ws comment?)*)> Action1) / (ws keyval ws comment?) / (ws comment?) / ws)> */
|
||
func() bool {
|
||
position8, tokenIndex8 := position, tokenIndex
|
||
{
|
||
position9 := position
|
||
{
|
||
position10, tokenIndex10 := position, tokenIndex
|
||
{
|
||
position12 := position
|
||
if !_rules[rulews]() {
|
||
goto l11
|
||
}
|
||
{
|
||
position13 := position
|
||
{
|
||
position14, tokenIndex14 := position, tokenIndex
|
||
{
|
||
position16 := position
|
||
if buffer[position] != rune('[') {
|
||
goto l15
|
||
}
|
||
position++
|
||
if !_rules[rulews]() {
|
||
goto l15
|
||
}
|
||
{
|
||
position17 := position
|
||
if !_rules[ruletableKey]() {
|
||
goto l15
|
||
}
|
||
add(rulePegText, position17)
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l15
|
||
}
|
||
if buffer[position] != rune(']') {
|
||
goto l15
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction13, position)
|
||
}
|
||
add(rulestdTable, position16)
|
||
}
|
||
goto l14
|
||
l15:
|
||
position, tokenIndex = position14, tokenIndex14
|
||
{
|
||
position19 := position
|
||
if buffer[position] != rune('[') {
|
||
goto l11
|
||
}
|
||
position++
|
||
if buffer[position] != rune('[') {
|
||
goto l11
|
||
}
|
||
position++
|
||
if !_rules[rulews]() {
|
||
goto l11
|
||
}
|
||
{
|
||
position20 := position
|
||
if !_rules[ruletableKey]() {
|
||
goto l11
|
||
}
|
||
add(rulePegText, position20)
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l11
|
||
}
|
||
if buffer[position] != rune(']') {
|
||
goto l11
|
||
}
|
||
position++
|
||
if buffer[position] != rune(']') {
|
||
goto l11
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction14, position)
|
||
}
|
||
add(rulearrayTable, position19)
|
||
}
|
||
}
|
||
l14:
|
||
add(ruletable, position13)
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l11
|
||
}
|
||
{
|
||
position22, tokenIndex22 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l22
|
||
}
|
||
goto l23
|
||
l22:
|
||
position, tokenIndex = position22, tokenIndex22
|
||
}
|
||
l23:
|
||
l24:
|
||
{
|
||
position25, tokenIndex25 := position, tokenIndex
|
||
if !_rules[rulewsnl]() {
|
||
goto l25
|
||
}
|
||
if !_rules[rulekeyval]() {
|
||
goto l25
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l25
|
||
}
|
||
{
|
||
position26, tokenIndex26 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l26
|
||
}
|
||
goto l27
|
||
l26:
|
||
position, tokenIndex = position26, tokenIndex26
|
||
}
|
||
l27:
|
||
goto l24
|
||
l25:
|
||
position, tokenIndex = position25, tokenIndex25
|
||
}
|
||
add(rulePegText, position12)
|
||
}
|
||
{
|
||
add(ruleAction1, position)
|
||
}
|
||
goto l10
|
||
l11:
|
||
position, tokenIndex = position10, tokenIndex10
|
||
if !_rules[rulews]() {
|
||
goto l29
|
||
}
|
||
if !_rules[rulekeyval]() {
|
||
goto l29
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l29
|
||
}
|
||
{
|
||
position30, tokenIndex30 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l30
|
||
}
|
||
goto l31
|
||
l30:
|
||
position, tokenIndex = position30, tokenIndex30
|
||
}
|
||
l31:
|
||
goto l10
|
||
l29:
|
||
position, tokenIndex = position10, tokenIndex10
|
||
if !_rules[rulews]() {
|
||
goto l32
|
||
}
|
||
{
|
||
position33, tokenIndex33 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l33
|
||
}
|
||
goto l34
|
||
l33:
|
||
position, tokenIndex = position33, tokenIndex33
|
||
}
|
||
l34:
|
||
goto l10
|
||
l32:
|
||
position, tokenIndex = position10, tokenIndex10
|
||
if !_rules[rulews]() {
|
||
goto l8
|
||
}
|
||
}
|
||
l10:
|
||
add(ruleExpression, position9)
|
||
}
|
||
return true
|
||
l8:
|
||
position, tokenIndex = position8, tokenIndex8
|
||
return false
|
||
},
|
||
/* 2 newline <- <(<('\r' / '\n')+> Action2)> */
|
||
func() bool {
|
||
position35, tokenIndex35 := position, tokenIndex
|
||
{
|
||
position36 := position
|
||
{
|
||
position37 := position
|
||
{
|
||
position40, tokenIndex40 := position, tokenIndex
|
||
if buffer[position] != rune('\r') {
|
||
goto l41
|
||
}
|
||
position++
|
||
goto l40
|
||
l41:
|
||
position, tokenIndex = position40, tokenIndex40
|
||
if buffer[position] != rune('\n') {
|
||
goto l35
|
||
}
|
||
position++
|
||
}
|
||
l40:
|
||
l38:
|
||
{
|
||
position39, tokenIndex39 := position, tokenIndex
|
||
{
|
||
position42, tokenIndex42 := position, tokenIndex
|
||
if buffer[position] != rune('\r') {
|
||
goto l43
|
||
}
|
||
position++
|
||
goto l42
|
||
l43:
|
||
position, tokenIndex = position42, tokenIndex42
|
||
if buffer[position] != rune('\n') {
|
||
goto l39
|
||
}
|
||
position++
|
||
}
|
||
l42:
|
||
goto l38
|
||
l39:
|
||
position, tokenIndex = position39, tokenIndex39
|
||
}
|
||
add(rulePegText, position37)
|
||
}
|
||
{
|
||
add(ruleAction2, position)
|
||
}
|
||
add(rulenewline, position36)
|
||
}
|
||
return true
|
||
l35:
|
||
position, tokenIndex = position35, tokenIndex35
|
||
return false
|
||
},
|
||
/* 3 ws <- <(' ' / '\t')*> */
|
||
func() bool {
|
||
{
|
||
position46 := position
|
||
l47:
|
||
{
|
||
position48, tokenIndex48 := position, tokenIndex
|
||
{
|
||
position49, tokenIndex49 := position, tokenIndex
|
||
if buffer[position] != rune(' ') {
|
||
goto l50
|
||
}
|
||
position++
|
||
goto l49
|
||
l50:
|
||
position, tokenIndex = position49, tokenIndex49
|
||
if buffer[position] != rune('\t') {
|
||
goto l48
|
||
}
|
||
position++
|
||
}
|
||
l49:
|
||
goto l47
|
||
l48:
|
||
position, tokenIndex = position48, tokenIndex48
|
||
}
|
||
add(rulews, position46)
|
||
}
|
||
return true
|
||
},
|
||
/* 4 wsnl <- <((&('\t') '\t') | (&(' ') ' ') | (&('\n' | '\r') (<('\r' / '\n')> Action3)))*> */
|
||
func() bool {
|
||
{
|
||
position52 := position
|
||
l53:
|
||
{
|
||
position54, tokenIndex54 := position, tokenIndex
|
||
{
|
||
switch buffer[position] {
|
||
case '\t':
|
||
if buffer[position] != rune('\t') {
|
||
goto l54
|
||
}
|
||
position++
|
||
break
|
||
case ' ':
|
||
if buffer[position] != rune(' ') {
|
||
goto l54
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
{
|
||
position56 := position
|
||
{
|
||
position57, tokenIndex57 := position, tokenIndex
|
||
if buffer[position] != rune('\r') {
|
||
goto l58
|
||
}
|
||
position++
|
||
goto l57
|
||
l58:
|
||
position, tokenIndex = position57, tokenIndex57
|
||
if buffer[position] != rune('\n') {
|
||
goto l54
|
||
}
|
||
position++
|
||
}
|
||
l57:
|
||
add(rulePegText, position56)
|
||
}
|
||
{
|
||
add(ruleAction3, position)
|
||
}
|
||
break
|
||
}
|
||
}
|
||
|
||
goto l53
|
||
l54:
|
||
position, tokenIndex = position54, tokenIndex54
|
||
}
|
||
add(rulewsnl, position52)
|
||
}
|
||
return true
|
||
},
|
||
/* 5 comment <- <('#' <('\t' / [ -\U0010ffff])*>)> */
|
||
func() bool {
|
||
position60, tokenIndex60 := position, tokenIndex
|
||
{
|
||
position61 := position
|
||
if buffer[position] != rune('#') {
|
||
goto l60
|
||
}
|
||
position++
|
||
{
|
||
position62 := position
|
||
l63:
|
||
{
|
||
position64, tokenIndex64 := position, tokenIndex
|
||
{
|
||
position65, tokenIndex65 := position, tokenIndex
|
||
if buffer[position] != rune('\t') {
|
||
goto l66
|
||
}
|
||
position++
|
||
goto l65
|
||
l66:
|
||
position, tokenIndex = position65, tokenIndex65
|
||
if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
|
||
goto l64
|
||
}
|
||
position++
|
||
}
|
||
l65:
|
||
goto l63
|
||
l64:
|
||
position, tokenIndex = position64, tokenIndex64
|
||
}
|
||
add(rulePegText, position62)
|
||
}
|
||
add(rulecomment, position61)
|
||
}
|
||
return true
|
||
l60:
|
||
position, tokenIndex = position60, tokenIndex60
|
||
return false
|
||
},
|
||
/* 6 keyval <- <(key ws '=' ws val Action4)> */
|
||
func() bool {
|
||
position67, tokenIndex67 := position, tokenIndex
|
||
{
|
||
position68 := position
|
||
if !_rules[rulekey]() {
|
||
goto l67
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l67
|
||
}
|
||
if buffer[position] != rune('=') {
|
||
goto l67
|
||
}
|
||
position++
|
||
if !_rules[rulews]() {
|
||
goto l67
|
||
}
|
||
if !_rules[ruleval]() {
|
||
goto l67
|
||
}
|
||
{
|
||
add(ruleAction4, position)
|
||
}
|
||
add(rulekeyval, position68)
|
||
}
|
||
return true
|
||
l67:
|
||
position, tokenIndex = position67, tokenIndex67
|
||
return false
|
||
},
|
||
/* 7 key <- <(bareKey / quotedKey)> */
|
||
func() bool {
|
||
position70, tokenIndex70 := position, tokenIndex
|
||
{
|
||
position71 := position
|
||
{
|
||
position72, tokenIndex72 := position, tokenIndex
|
||
{
|
||
position74 := position
|
||
{
|
||
position75 := position
|
||
{
|
||
switch buffer[position] {
|
||
case '_':
|
||
if buffer[position] != rune('_') {
|
||
goto l73
|
||
}
|
||
position++
|
||
break
|
||
case '-':
|
||
if buffer[position] != rune('-') {
|
||
goto l73
|
||
}
|
||
position++
|
||
break
|
||
case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
|
||
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
||
goto l73
|
||
}
|
||
position++
|
||
break
|
||
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
||
goto l73
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
||
goto l73
|
||
}
|
||
position++
|
||
break
|
||
}
|
||
}
|
||
|
||
l76:
|
||
{
|
||
position77, tokenIndex77 := position, tokenIndex
|
||
{
|
||
switch buffer[position] {
|
||
case '_':
|
||
if buffer[position] != rune('_') {
|
||
goto l77
|
||
}
|
||
position++
|
||
break
|
||
case '-':
|
||
if buffer[position] != rune('-') {
|
||
goto l77
|
||
}
|
||
position++
|
||
break
|
||
case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
|
||
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
||
goto l77
|
||
}
|
||
position++
|
||
break
|
||
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
||
goto l77
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
||
goto l77
|
||
}
|
||
position++
|
||
break
|
||
}
|
||
}
|
||
|
||
goto l76
|
||
l77:
|
||
position, tokenIndex = position77, tokenIndex77
|
||
}
|
||
add(rulePegText, position75)
|
||
}
|
||
{
|
||
add(ruleAction5, position)
|
||
}
|
||
add(rulebareKey, position74)
|
||
}
|
||
goto l72
|
||
l73:
|
||
position, tokenIndex = position72, tokenIndex72
|
||
{
|
||
position81 := position
|
||
{
|
||
position82 := position
|
||
if buffer[position] != rune('"') {
|
||
goto l70
|
||
}
|
||
position++
|
||
l83:
|
||
{
|
||
position84, tokenIndex84 := position, tokenIndex
|
||
if !_rules[rulebasicChar]() {
|
||
goto l84
|
||
}
|
||
goto l83
|
||
l84:
|
||
position, tokenIndex = position84, tokenIndex84
|
||
}
|
||
if buffer[position] != rune('"') {
|
||
goto l70
|
||
}
|
||
position++
|
||
add(rulePegText, position82)
|
||
}
|
||
{
|
||
add(ruleAction6, position)
|
||
}
|
||
add(rulequotedKey, position81)
|
||
}
|
||
}
|
||
l72:
|
||
add(rulekey, position71)
|
||
}
|
||
return true
|
||
l70:
|
||
position, tokenIndex = position70, tokenIndex70
|
||
return false
|
||
},
|
||
/* 8 bareKey <- <(<((&('_') '_') | (&('-') '-') | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') [a-z]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z') [A-Z]))+> Action5)> */
|
||
nil,
|
||
/* 9 quotedKey <- <(<('"' basicChar* '"')> Action6)> */
|
||
nil,
|
||
/* 10 val <- <((<datetime> Action7) / (<float> Action8) / ((&('{') inlineTable) | (&('[') (<array> Action12)) | (&('f' | 't') (<boolean> Action11)) | (&('"' | '\'') (<string> Action10)) | (&('+' | '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') (<integer> Action9))))> */
|
||
func() bool {
|
||
position88, tokenIndex88 := position, tokenIndex
|
||
{
|
||
position89 := position
|
||
{
|
||
position90, tokenIndex90 := position, tokenIndex
|
||
{
|
||
position92 := position
|
||
{
|
||
position93 := position
|
||
{
|
||
position94, tokenIndex94 := position, tokenIndex
|
||
{
|
||
position96 := position
|
||
{
|
||
position97 := position
|
||
{
|
||
position98 := position
|
||
if !_rules[ruledigitDual]() {
|
||
goto l95
|
||
}
|
||
if !_rules[ruledigitDual]() {
|
||
goto l95
|
||
}
|
||
add(ruledigitQuad, position98)
|
||
}
|
||
add(ruledateFullYear, position97)
|
||
}
|
||
if buffer[position] != rune('-') {
|
||
goto l95
|
||
}
|
||
position++
|
||
{
|
||
position99 := position
|
||
if !_rules[ruledigitDual]() {
|
||
goto l95
|
||
}
|
||
add(ruledateMonth, position99)
|
||
}
|
||
if buffer[position] != rune('-') {
|
||
goto l95
|
||
}
|
||
position++
|
||
{
|
||
position100 := position
|
||
if !_rules[ruledigitDual]() {
|
||
goto l95
|
||
}
|
||
add(ruledateMDay, position100)
|
||
}
|
||
add(rulefullDate, position96)
|
||
}
|
||
{
|
||
position101, tokenIndex101 := position, tokenIndex
|
||
if buffer[position] != rune('T') {
|
||
goto l101
|
||
}
|
||
position++
|
||
{
|
||
position103 := position
|
||
if !_rules[rulepartialTime]() {
|
||
goto l101
|
||
}
|
||
{
|
||
position104, tokenIndex104 := position, tokenIndex
|
||
{
|
||
position106 := position
|
||
{
|
||
position107, tokenIndex107 := position, tokenIndex
|
||
if buffer[position] != rune('Z') {
|
||
goto l108
|
||
}
|
||
position++
|
||
goto l107
|
||
l108:
|
||
position, tokenIndex = position107, tokenIndex107
|
||
{
|
||
position109 := position
|
||
{
|
||
position110, tokenIndex110 := position, tokenIndex
|
||
if buffer[position] != rune('-') {
|
||
goto l111
|
||
}
|
||
position++
|
||
goto l110
|
||
l111:
|
||
position, tokenIndex = position110, tokenIndex110
|
||
if buffer[position] != rune('+') {
|
||
goto l104
|
||
}
|
||
position++
|
||
}
|
||
l110:
|
||
if !_rules[ruletimeHour]() {
|
||
goto l104
|
||
}
|
||
if buffer[position] != rune(':') {
|
||
goto l104
|
||
}
|
||
position++
|
||
if !_rules[ruletimeMinute]() {
|
||
goto l104
|
||
}
|
||
add(ruletimeNumoffset, position109)
|
||
}
|
||
}
|
||
l107:
|
||
add(ruletimeOffset, position106)
|
||
}
|
||
goto l105
|
||
l104:
|
||
position, tokenIndex = position104, tokenIndex104
|
||
}
|
||
l105:
|
||
add(rulefullTime, position103)
|
||
}
|
||
goto l102
|
||
l101:
|
||
position, tokenIndex = position101, tokenIndex101
|
||
}
|
||
l102:
|
||
goto l94
|
||
l95:
|
||
position, tokenIndex = position94, tokenIndex94
|
||
if !_rules[rulepartialTime]() {
|
||
goto l91
|
||
}
|
||
}
|
||
l94:
|
||
add(ruledatetime, position93)
|
||
}
|
||
add(rulePegText, position92)
|
||
}
|
||
{
|
||
add(ruleAction7, position)
|
||
}
|
||
goto l90
|
||
l91:
|
||
position, tokenIndex = position90, tokenIndex90
|
||
{
|
||
position114 := position
|
||
{
|
||
position115 := position
|
||
if !_rules[ruleinteger]() {
|
||
goto l113
|
||
}
|
||
{
|
||
position116, tokenIndex116 := position, tokenIndex
|
||
if !_rules[rulefrac]() {
|
||
goto l117
|
||
}
|
||
{
|
||
position118, tokenIndex118 := position, tokenIndex
|
||
if !_rules[ruleexp]() {
|
||
goto l118
|
||
}
|
||
goto l119
|
||
l118:
|
||
position, tokenIndex = position118, tokenIndex118
|
||
}
|
||
l119:
|
||
goto l116
|
||
l117:
|
||
position, tokenIndex = position116, tokenIndex116
|
||
{
|
||
position120, tokenIndex120 := position, tokenIndex
|
||
if !_rules[rulefrac]() {
|
||
goto l120
|
||
}
|
||
goto l121
|
||
l120:
|
||
position, tokenIndex = position120, tokenIndex120
|
||
}
|
||
l121:
|
||
if !_rules[ruleexp]() {
|
||
goto l113
|
||
}
|
||
}
|
||
l116:
|
||
add(rulefloat, position115)
|
||
}
|
||
add(rulePegText, position114)
|
||
}
|
||
{
|
||
add(ruleAction8, position)
|
||
}
|
||
goto l90
|
||
l113:
|
||
position, tokenIndex = position90, tokenIndex90
|
||
{
|
||
switch buffer[position] {
|
||
case '{':
|
||
{
|
||
position124 := position
|
||
if buffer[position] != rune('{') {
|
||
goto l88
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction15, position)
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l88
|
||
}
|
||
{
|
||
position126 := position
|
||
l127:
|
||
{
|
||
position128, tokenIndex128 := position, tokenIndex
|
||
if !_rules[rulekeyval]() {
|
||
goto l128
|
||
}
|
||
{
|
||
position129, tokenIndex129 := position, tokenIndex
|
||
{
|
||
position131 := position
|
||
if !_rules[rulews]() {
|
||
goto l129
|
||
}
|
||
if buffer[position] != rune(',') {
|
||
goto l129
|
||
}
|
||
position++
|
||
if !_rules[rulews]() {
|
||
goto l129
|
||
}
|
||
add(ruleinlineTableValSep, position131)
|
||
}
|
||
goto l130
|
||
l129:
|
||
position, tokenIndex = position129, tokenIndex129
|
||
}
|
||
l130:
|
||
goto l127
|
||
l128:
|
||
position, tokenIndex = position128, tokenIndex128
|
||
}
|
||
add(ruleinlineTableKeyValues, position126)
|
||
}
|
||
if !_rules[rulews]() {
|
||
goto l88
|
||
}
|
||
if buffer[position] != rune('}') {
|
||
goto l88
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction16, position)
|
||
}
|
||
add(ruleinlineTable, position124)
|
||
}
|
||
break
|
||
case '[':
|
||
{
|
||
position133 := position
|
||
{
|
||
position134 := position
|
||
if buffer[position] != rune('[') {
|
||
goto l88
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction23, position)
|
||
}
|
||
if !_rules[rulewsnl]() {
|
||
goto l88
|
||
}
|
||
{
|
||
position136, tokenIndex136 := position, tokenIndex
|
||
{
|
||
position138 := position
|
||
if !_rules[ruleval]() {
|
||
goto l136
|
||
}
|
||
{
|
||
add(ruleAction24, position)
|
||
}
|
||
l140:
|
||
{
|
||
position141, tokenIndex141 := position, tokenIndex
|
||
if !_rules[rulewsnl]() {
|
||
goto l141
|
||
}
|
||
{
|
||
position142, tokenIndex142 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l142
|
||
}
|
||
goto l143
|
||
l142:
|
||
position, tokenIndex = position142, tokenIndex142
|
||
}
|
||
l143:
|
||
if !_rules[rulewsnl]() {
|
||
goto l141
|
||
}
|
||
if !_rules[rulearraySep]() {
|
||
goto l141
|
||
}
|
||
if !_rules[rulewsnl]() {
|
||
goto l141
|
||
}
|
||
{
|
||
position144, tokenIndex144 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l144
|
||
}
|
||
goto l145
|
||
l144:
|
||
position, tokenIndex = position144, tokenIndex144
|
||
}
|
||
l145:
|
||
if !_rules[rulewsnl]() {
|
||
goto l141
|
||
}
|
||
if !_rules[ruleval]() {
|
||
goto l141
|
||
}
|
||
{
|
||
add(ruleAction25, position)
|
||
}
|
||
goto l140
|
||
l141:
|
||
position, tokenIndex = position141, tokenIndex141
|
||
}
|
||
if !_rules[rulewsnl]() {
|
||
goto l136
|
||
}
|
||
{
|
||
position147, tokenIndex147 := position, tokenIndex
|
||
if !_rules[rulearraySep]() {
|
||
goto l147
|
||
}
|
||
goto l148
|
||
l147:
|
||
position, tokenIndex = position147, tokenIndex147
|
||
}
|
||
l148:
|
||
if !_rules[rulewsnl]() {
|
||
goto l136
|
||
}
|
||
{
|
||
position149, tokenIndex149 := position, tokenIndex
|
||
if !_rules[rulecomment]() {
|
||
goto l149
|
||
}
|
||
goto l150
|
||
l149:
|
||
position, tokenIndex = position149, tokenIndex149
|
||
}
|
||
l150:
|
||
add(rulearrayValues, position138)
|
||
}
|
||
goto l137
|
||
l136:
|
||
position, tokenIndex = position136, tokenIndex136
|
||
}
|
||
l137:
|
||
if !_rules[rulewsnl]() {
|
||
goto l88
|
||
}
|
||
if buffer[position] != rune(']') {
|
||
goto l88
|
||
}
|
||
position++
|
||
add(rulearray, position134)
|
||
}
|
||
add(rulePegText, position133)
|
||
}
|
||
{
|
||
add(ruleAction12, position)
|
||
}
|
||
break
|
||
case 'f', 't':
|
||
{
|
||
position152 := position
|
||
{
|
||
position153 := position
|
||
{
|
||
position154, tokenIndex154 := position, tokenIndex
|
||
if buffer[position] != rune('t') {
|
||
goto l155
|
||
}
|
||
position++
|
||
if buffer[position] != rune('r') {
|
||
goto l155
|
||
}
|
||
position++
|
||
if buffer[position] != rune('u') {
|
||
goto l155
|
||
}
|
||
position++
|
||
if buffer[position] != rune('e') {
|
||
goto l155
|
||
}
|
||
position++
|
||
goto l154
|
||
l155:
|
||
position, tokenIndex = position154, tokenIndex154
|
||
if buffer[position] != rune('f') {
|
||
goto l88
|
||
}
|
||
position++
|
||
if buffer[position] != rune('a') {
|
||
goto l88
|
||
}
|
||
position++
|
||
if buffer[position] != rune('l') {
|
||
goto l88
|
||
}
|
||
position++
|
||
if buffer[position] != rune('s') {
|
||
goto l88
|
||
}
|
||
position++
|
||
if buffer[position] != rune('e') {
|
||
goto l88
|
||
}
|
||
position++
|
||
}
|
||
l154:
|
||
add(ruleboolean, position153)
|
||
}
|
||
add(rulePegText, position152)
|
||
}
|
||
{
|
||
add(ruleAction11, position)
|
||
}
|
||
break
|
||
case '"', '\'':
|
||
{
|
||
position157 := position
|
||
{
|
||
position158 := position
|
||
{
|
||
position159, tokenIndex159 := position, tokenIndex
|
||
{
|
||
position161 := position
|
||
if buffer[position] != rune('\'') {
|
||
goto l160
|
||
}
|
||
position++
|
||
if buffer[position] != rune('\'') {
|
||
goto l160
|
||
}
|
||
position++
|
||
if buffer[position] != rune('\'') {
|
||
goto l160
|
||
}
|
||
position++
|
||
{
|
||
position162 := position
|
||
{
|
||
position163 := position
|
||
l164:
|
||
{
|
||
position165, tokenIndex165 := position, tokenIndex
|
||
{
|
||
position166, tokenIndex166 := position, tokenIndex
|
||
if buffer[position] != rune('\'') {
|
||
goto l166
|
||
}
|
||
position++
|
||
if buffer[position] != rune('\'') {
|
||
goto l166
|
||
}
|
||
position++
|
||
if buffer[position] != rune('\'') {
|
||
goto l166
|
||
}
|
||
position++
|
||
goto l165
|
||
l166:
|
||
position, tokenIndex = position166, tokenIndex166
|
||
}
|
||
{
|
||
position167, tokenIndex167 := position, tokenIndex
|
||
{
|
||
position169 := position
|
||
{
|
||
position170, tokenIndex170 := position, tokenIndex
|
||
if buffer[position] != rune('\t') {
|
||
goto l171
|
||
}
|
||
position++
|
||
goto l170
|
||
l171:
|
||
position, tokenIndex = position170, tokenIndex170
|
||
if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
|
||
goto l168
|
||
}
|
||
position++
|
||
}
|
||
l170:
|
||
add(rulemlLiteralChar, position169)
|
||
}
|
||
goto l167
|
||
l168:
|
||
position, tokenIndex = position167, tokenIndex167
|
||
if !_rules[rulenewline]() {
|
||
goto l165
|
||
}
|
||
}
|
||
l167:
|
||
goto l164
|
||
l165:
|
||
position, tokenIndex = position165, tokenIndex165
|
||
}
|
||
add(rulemlLiteralBody, position163)
|
||
}
|
||
add(rulePegText, position162)
|
||
}
|
||
if buffer[position] != rune('\'') {
|
||
goto l160
|
||
}
|
||
position++
|
||
if buffer[position] != rune('\'') {
|
||
goto l160
|
||
}
|
||
position++
|
||
if buffer[position] != rune('\'') {
|
||
goto l160
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction22, position)
|
||
}
|
||
add(rulemlLiteralString, position161)
|
||
}
|
||
goto l159
|
||
l160:
|
||
position, tokenIndex = position159, tokenIndex159
|
||
{
|
||
position174 := position
|
||
if buffer[position] != rune('\'') {
|
||
goto l173
|
||
}
|
||
position++
|
||
{
|
||
position175 := position
|
||
l176:
|
||
{
|
||
position177, tokenIndex177 := position, tokenIndex
|
||
{
|
||
position178 := position
|
||
{
|
||
switch buffer[position] {
|
||
case '\t':
|
||
if buffer[position] != rune('\t') {
|
||
goto l177
|
||
}
|
||
position++
|
||
break
|
||
case ' ', '!', '"', '#', '$', '%', '&':
|
||
if c := buffer[position]; c < rune(' ') || c > rune('&') {
|
||
goto l177
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
if c := buffer[position]; c < rune('(') || c > rune('\U0010ffff') {
|
||
goto l177
|
||
}
|
||
position++
|
||
break
|
||
}
|
||
}
|
||
|
||
add(ruleliteralChar, position178)
|
||
}
|
||
goto l176
|
||
l177:
|
||
position, tokenIndex = position177, tokenIndex177
|
||
}
|
||
add(rulePegText, position175)
|
||
}
|
||
if buffer[position] != rune('\'') {
|
||
goto l173
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction21, position)
|
||
}
|
||
add(ruleliteralString, position174)
|
||
}
|
||
goto l159
|
||
l173:
|
||
position, tokenIndex = position159, tokenIndex159
|
||
{
|
||
position182 := position
|
||
if buffer[position] != rune('"') {
|
||
goto l181
|
||
}
|
||
position++
|
||
if buffer[position] != rune('"') {
|
||
goto l181
|
||
}
|
||
position++
|
||
if buffer[position] != rune('"') {
|
||
goto l181
|
||
}
|
||
position++
|
||
{
|
||
position183 := position
|
||
l184:
|
||
{
|
||
position185, tokenIndex185 := position, tokenIndex
|
||
{
|
||
position186, tokenIndex186 := position, tokenIndex
|
||
{
|
||
position188 := position
|
||
{
|
||
position189, tokenIndex189 := position, tokenIndex
|
||
if !_rules[rulebasicChar]() {
|
||
goto l190
|
||
}
|
||
goto l189
|
||
l190:
|
||
position, tokenIndex = position189, tokenIndex189
|
||
if !_rules[rulenewline]() {
|
||
goto l187
|
||
}
|
||
}
|
||
l189:
|
||
add(rulePegText, position188)
|
||
}
|
||
{
|
||
add(ruleAction20, position)
|
||
}
|
||
goto l186
|
||
l187:
|
||
position, tokenIndex = position186, tokenIndex186
|
||
if !_rules[ruleescape]() {
|
||
goto l185
|
||
}
|
||
if !_rules[rulenewline]() {
|
||
goto l185
|
||
}
|
||
if !_rules[rulewsnl]() {
|
||
goto l185
|
||
}
|
||
}
|
||
l186:
|
||
goto l184
|
||
l185:
|
||
position, tokenIndex = position185, tokenIndex185
|
||
}
|
||
add(rulemlBasicBody, position183)
|
||
}
|
||
if buffer[position] != rune('"') {
|
||
goto l181
|
||
}
|
||
position++
|
||
if buffer[position] != rune('"') {
|
||
goto l181
|
||
}
|
||
position++
|
||
if buffer[position] != rune('"') {
|
||
goto l181
|
||
}
|
||
position++
|
||
{
|
||
add(ruleAction19, position)
|
||
}
|
||
add(rulemlBasicString, position182)
|
||
}
|
||
goto l159
|
||
l181:
|
||
position, tokenIndex = position159, tokenIndex159
|
||
{
|
||
position193 := position
|
||
{
|
||
position194 := position
|
||
if buffer[position] != rune('"') {
|
||
goto l88
|
||
}
|
||
position++
|
||
l195:
|
||
{
|
||
position196, tokenIndex196 := position, tokenIndex
|
||
if !_rules[rulebasicChar]() {
|
||
goto l196
|
||
}
|
||
goto l195
|
||
l196:
|
||
position, tokenIndex = position196, tokenIndex196
|
||
}
|
||
if buffer[position] != rune('"') {
|
||
goto l88
|
||
}
|
||
position++
|
||
add(rulePegText, position194)
|
||
}
|
||
{
|
||
add(ruleAction18, position)
|
||
}
|
||
add(rulebasicString, position193)
|
||
}
|
||
}
|
||
l159:
|
||
add(rulestring, position158)
|
||
}
|
||
add(rulePegText, position157)
|
||
}
|
||
{
|
||
add(ruleAction10, position)
|
||
}
|
||
break
|
||
default:
|
||
{
|
||
position199 := position
|
||
if !_rules[ruleinteger]() {
|
||
goto l88
|
||
}
|
||
add(rulePegText, position199)
|
||
}
|
||
{
|
||
add(ruleAction9, position)
|
||
}
|
||
break
|
||
}
|
||
}
|
||
|
||
}
|
||
l90:
|
||
add(ruleval, position89)
|
||
}
|
||
return true
|
||
l88:
|
||
position, tokenIndex = position88, tokenIndex88
|
||
return false
|
||
},
|
||
/* 11 table <- <(stdTable / arrayTable)> */
|
||
nil,
|
||
/* 12 stdTable <- <('[' ws <tableKey> ws ']' Action13)> */
|
||
nil,
|
||
/* 13 arrayTable <- <('[' '[' ws <tableKey> ws (']' ']') Action14)> */
|
||
nil,
|
||
/* 14 inlineTable <- <('{' Action15 ws inlineTableKeyValues ws '}' Action16)> */
|
||
nil,
|
||
/* 15 inlineTableKeyValues <- <(keyval inlineTableValSep?)*> */
|
||
nil,
|
||
/* 16 tableKey <- <(tableKeyComp (tableKeySep tableKeyComp)*)> */
|
||
func() bool {
|
||
position206, tokenIndex206 := position, tokenIndex
|
||
{
|
||
position207 := position
|
||
if !_rules[ruletableKeyComp]() {
|
||
goto l206
|
||
}
|
||
l208:
|
||
{
|
||
position209, tokenIndex209 := position, tokenIndex
|
||
{
|
||
position210 := position
|
||
if !_rules[rulews]() {
|
||
goto l209
|
||
}
|
||
if buffer[position] != rune('.') {
|
||
goto l209
|
||
}
|
||
position++
|
||
if !_rules[rulews]() {
|
||
goto l209
|
||
}
|
||
add(ruletableKeySep, position210)
|
||
}
|
||
if !_rules[ruletableKeyComp]() {
|
||
goto l209
|
||
}
|
||
goto l208
|
||
l209:
|
||
position, tokenIndex = position209, tokenIndex209
|
||
}
|
||
add(ruletableKey, position207)
|
||
}
|
||
return true
|
||
l206:
|
||
position, tokenIndex = position206, tokenIndex206
|
||
return false
|
||
},
|
||
/* 17 tableKeyComp <- <(key Action17)> */
|
||
func() bool {
|
||
position211, tokenIndex211 := position, tokenIndex
|
||
{
|
||
position212 := position
|
||
if !_rules[rulekey]() {
|
||
goto l211
|
||
}
|
||
{
|
||
add(ruleAction17, position)
|
||
}
|
||
add(ruletableKeyComp, position212)
|
||
}
|
||
return true
|
||
l211:
|
||
position, tokenIndex = position211, tokenIndex211
|
||
return false
|
||
},
|
||
/* 18 tableKeySep <- <(ws '.' ws)> */
|
||
nil,
|
||
/* 19 inlineTableValSep <- <(ws ',' ws)> */
|
||
nil,
|
||
/* 20 integer <- <(('-' / '+')? int)> */
|
||
func() bool {
|
||
position216, tokenIndex216 := position, tokenIndex
|
||
{
|
||
position217 := position
|
||
{
|
||
position218, tokenIndex218 := position, tokenIndex
|
||
{
|
||
position220, tokenIndex220 := position, tokenIndex
|
||
if buffer[position] != rune('-') {
|
||
goto l221
|
||
}
|
||
position++
|
||
goto l220
|
||
l221:
|
||
position, tokenIndex = position220, tokenIndex220
|
||
if buffer[position] != rune('+') {
|
||
goto l218
|
||
}
|
||
position++
|
||
}
|
||
l220:
|
||
goto l219
|
||
l218:
|
||
position, tokenIndex = position218, tokenIndex218
|
||
}
|
||
l219:
|
||
{
|
||
position222 := position
|
||
{
|
||
position223, tokenIndex223 := position, tokenIndex
|
||
if c := buffer[position]; c < rune('1') || c > rune('9') {
|
||
goto l224
|
||
}
|
||
position++
|
||
{
|
||
position227, tokenIndex227 := position, tokenIndex
|
||
if !_rules[ruledigit]() {
|
||
goto l228
|
||
}
|
||
goto l227
|
||
l228:
|
||
position, tokenIndex = position227, tokenIndex227
|
||
if buffer[position] != rune('_') {
|
||
goto l224
|
||
}
|
||
position++
|
||
if !_rules[ruledigit]() {
|
||
goto l224
|
||
}
|
||
}
|
||
l227:
|
||
l225:
|
||
{
|
||
position226, tokenIndex226 := position, tokenIndex
|
||
{
|
||
position229, tokenIndex229 := position, tokenIndex
|
||
if !_rules[ruledigit]() {
|
||
goto l230
|
||
}
|
||
goto l229
|
||
l230:
|
||
position, tokenIndex = position229, tokenIndex229
|
||
if buffer[position] != rune('_') {
|
||
goto l226
|
||
}
|
||
position++
|
||
if !_rules[ruledigit]() {
|
||
goto l226
|
||
}
|
||
}
|
||
l229:
|
||
goto l225
|
||
l226:
|
||
position, tokenIndex = position226, tokenIndex226
|
||
}
|
||
goto l223
|
||
l224:
|
||
position, tokenIndex = position223, tokenIndex223
|
||
if !_rules[ruledigit]() {
|
||
goto l216
|
||
}
|
||
}
|
||
l223:
|
||
add(ruleint, position222)
|
||
}
|
||
add(ruleinteger, position217)
|
||
}
|
||
return true
|
||
l216:
|
||
position, tokenIndex = position216, tokenIndex216
|
||
return false
|
||
},
|
||
/* 21 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
|
||
nil,
|
||
/* 22 float <- <(integer ((frac exp?) / (frac? exp)))> */
|
||
nil,
|
||
/* 23 frac <- <('.' digit (digit / ('_' digit))*)> */
|
||
func() bool {
|
||
position233, tokenIndex233 := position, tokenIndex
|
||
{
|
||
position234 := position
|
||
if buffer[position] != rune('.') {
|
||
goto l233
|
||
}
|
||
position++
|
||
if !_rules[ruledigit]() {
|
||
goto l233
|
||
}
|
||
l235:
|
||
{
|
||
position236, tokenIndex236 := position, tokenIndex
|
||
{
|
||
position237, tokenIndex237 := position, tokenIndex
|
||
if !_rules[ruledigit]() {
|
||
goto l238
|
||
}
|
||
goto l237
|
||
l238:
|
||
position, tokenIndex = position237, tokenIndex237
|
||
if buffer[position] != rune('_') {
|
||
goto l236
|
||
}
|
||
position++
|
||
if !_rules[ruledigit]() {
|
||
goto l236
|
||
}
|
||
}
|
||
l237:
|
||
goto l235
|
||
l236:
|
||
position, tokenIndex = position236, tokenIndex236
|
||
}
|
||
add(rulefrac, position234)
|
||
}
|
||
return true
|
||
l233:
|
||
position, tokenIndex = position233, tokenIndex233
|
||
return false
|
||
},
|
||
/* 24 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
|
||
func() bool {
|
||
position239, tokenIndex239 := position, tokenIndex
|
||
{
|
||
position240 := position
|
||
{
|
||
position241, tokenIndex241 := position, tokenIndex
|
||
if buffer[position] != rune('e') {
|
||
goto l242
|
||
}
|
||
position++
|
||
goto l241
|
||
l242:
|
||
position, tokenIndex = position241, tokenIndex241
|
||
if buffer[position] != rune('E') {
|
||
goto l239
|
||
}
|
||
position++
|
||
}
|
||
l241:
|
||
{
|
||
position243, tokenIndex243 := position, tokenIndex
|
||
{
|
||
position245, tokenIndex245 := position, tokenIndex
|
||
if buffer[position] != rune('-') {
|
||
goto l246
|
||
}
|
||
position++
|
||
goto l245
|
||
l246:
|
||
position, tokenIndex = position245, tokenIndex245
|
||
if buffer[position] != rune('+') {
|
||
goto l243
|
||
}
|
||
position++
|
||
}
|
||
l245:
|
||
goto l244
|
||
l243:
|
||
position, tokenIndex = position243, tokenIndex243
|
||
}
|
||
l244:
|
||
if !_rules[ruledigit]() {
|
||
goto l239
|
||
}
|
||
l247:
|
||
{
|
||
position248, tokenIndex248 := position, tokenIndex
|
||
{
|
||
position249, tokenIndex249 := position, tokenIndex
|
||
if !_rules[ruledigit]() {
|
||
goto l250
|
||
}
|
||
goto l249
|
||
l250:
|
||
position, tokenIndex = position249, tokenIndex249
|
||
if buffer[position] != rune('_') {
|
||
goto l248
|
||
}
|
||
position++
|
||
if !_rules[ruledigit]() {
|
||
goto l248
|
||
}
|
||
}
|
||
l249:
|
||
goto l247
|
||
l248:
|
||
position, tokenIndex = position248, tokenIndex248
|
||
}
|
||
add(ruleexp, position240)
|
||
}
|
||
return true
|
||
l239:
|
||
position, tokenIndex = position239, tokenIndex239
|
||
return false
|
||
},
|
||
/* 25 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
|
||
nil,
|
||
/* 26 basicString <- <(<('"' basicChar* '"')> Action18)> */
|
||
nil,
|
||
/* 27 basicChar <- <(basicUnescaped / escaped)> */
|
||
func() bool {
|
||
position253, tokenIndex253 := position, tokenIndex
|
||
{
|
||
position254 := position
|
||
{
|
||
position255, tokenIndex255 := position, tokenIndex
|
||
{
|
||
position257 := position
|
||
{
|
||
switch buffer[position] {
|
||
case ' ', '!':
|
||
if c := buffer[position]; c < rune(' ') || c > rune('!') {
|
||
goto l256
|
||
}
|
||
position++
|
||
break
|
||
case '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[':
|
||
if c := buffer[position]; c < rune('#') || c > rune('[') {
|
||
goto l256
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
if c := buffer[position]; c < rune(']') || c > rune('\U0010ffff') {
|
||
goto l256
|
||
}
|
||
position++
|
||
break
|
||
}
|
||
}
|
||
|
||
add(rulebasicUnescaped, position257)
|
||
}
|
||
goto l255
|
||
l256:
|
||
position, tokenIndex = position255, tokenIndex255
|
||
{
|
||
position259 := position
|
||
if !_rules[ruleescape]() {
|
||
goto l253
|
||
}
|
||
{
|
||
switch buffer[position] {
|
||
case 'U':
|
||
if buffer[position] != rune('U') {
|
||
goto l253
|
||
}
|
||
position++
|
||
if !_rules[rulehexQuad]() {
|
||
goto l253
|
||
}
|
||
if !_rules[rulehexQuad]() {
|
||
goto l253
|
||
}
|
||
break
|
||
case 'u':
|
||
if buffer[position] != rune('u') {
|
||
goto l253
|
||
}
|
||
position++
|
||
if !_rules[rulehexQuad]() {
|
||
goto l253
|
||
}
|
||
break
|
||
case '\\':
|
||
if buffer[position] != rune('\\') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
case '/':
|
||
if buffer[position] != rune('/') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
case '"':
|
||
if buffer[position] != rune('"') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
case 'r':
|
||
if buffer[position] != rune('r') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
case 'f':
|
||
if buffer[position] != rune('f') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
case 'n':
|
||
if buffer[position] != rune('n') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
case 't':
|
||
if buffer[position] != rune('t') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
if buffer[position] != rune('b') {
|
||
goto l253
|
||
}
|
||
position++
|
||
break
|
||
}
|
||
}
|
||
|
||
add(ruleescaped, position259)
|
||
}
|
||
}
|
||
l255:
|
||
add(rulebasicChar, position254)
|
||
}
|
||
return true
|
||
l253:
|
||
position, tokenIndex = position253, tokenIndex253
|
||
return false
|
||
},
|
||
/* 28 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
|
||
nil,
|
||
/* 29 basicUnescaped <- <((&(' ' | '!') [ -!]) | (&('#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[') [#-[]) | (&(']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') []-\U0010ffff]))> */
|
||
nil,
|
||
/* 30 escape <- <'\\'> */
|
||
func() bool {
|
||
position263, tokenIndex263 := position, tokenIndex
|
||
{
|
||
position264 := position
|
||
if buffer[position] != rune('\\') {
|
||
goto l263
|
||
}
|
||
position++
|
||
add(ruleescape, position264)
|
||
}
|
||
return true
|
||
l263:
|
||
position, tokenIndex = position263, tokenIndex263
|
||
return false
|
||
},
|
||
/* 31 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action19)> */
|
||
nil,
|
||
/* 32 mlBasicBody <- <((<(basicChar / newline)> Action20) / (escape newline wsnl))*> */
|
||
nil,
|
||
/* 33 literalString <- <('\'' <literalChar*> '\'' Action21)> */
|
||
nil,
|
||
/* 34 literalChar <- <((&('\t') '\t') | (&(' ' | '!' | '"' | '#' | '$' | '%' | '&') [ -&]) | (&('(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') [(-\U0010ffff]))> */
|
||
nil,
|
||
/* 35 mlLiteralString <- <('\'' '\'' '\'' <mlLiteralBody> ('\'' '\'' '\'') Action22)> */
|
||
nil,
|
||
/* 36 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
|
||
nil,
|
||
/* 37 mlLiteralChar <- <('\t' / [ -\U0010ffff])> */
|
||
nil,
|
||
/* 38 hexdigit <- <((&('a' | 'b' | 'c' | 'd' | 'e' | 'f') [a-f]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F') [A-F]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]))> */
|
||
func() bool {
|
||
position272, tokenIndex272 := position, tokenIndex
|
||
{
|
||
position273 := position
|
||
{
|
||
switch buffer[position] {
|
||
case 'a', 'b', 'c', 'd', 'e', 'f':
|
||
if c := buffer[position]; c < rune('a') || c > rune('f') {
|
||
goto l272
|
||
}
|
||
position++
|
||
break
|
||
case 'A', 'B', 'C', 'D', 'E', 'F':
|
||
if c := buffer[position]; c < rune('A') || c > rune('F') {
|
||
goto l272
|
||
}
|
||
position++
|
||
break
|
||
default:
|
||
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
||
goto l272
|
||
}
|
||
position++
|
||
break
|
||
}
|
||
}
|
||
|
||
add(rulehexdigit, position273)
|
||
}
|
||
return true
|
||
l272:
|
||
position, tokenIndex = position272, tokenIndex272
|
||
return false
|
||
},
|
||
/* 39 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
|
||
func() bool {
|
||
position275, tokenIndex275 := position, tokenIndex
|
||
{
|
||
position276 := position
|
||
if !_rules[rulehexdigit]() {
|
||
goto l275
|
||
}
|
||
if !_rules[rulehexdigit]() {
|
||
goto l275
|
||
}
|
||
if !_rules[rulehexdigit]() {
|
||
goto l275
|
||
}
|
||
if !_rules[rulehexdigit]() {
|
||
goto l275
|
||
}
|
||
add(rulehexQuad, position276)
|
||
}
|
||
return true
|
||
l275:
|
||
position, tokenIndex = position275, tokenIndex275
|
||
return false
|
||
},
|
||
/* 40 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
|
||
nil,
|
||
/* 41 dateFullYear <- <digitQuad> */
|
||
nil,
|
||
/* 42 dateMonth <- <digitDual> */
|
||
nil,
|
||
/* 43 dateMDay <- <digitDual> */
|
||
nil,
|
||
/* 44 timeHour <- <digitDual> */
|
||
func() bool {
|
||
position281, tokenIndex281 := position, tokenIndex
|
||
{
|
||
position282 := position
|
||
if !_rules[ruledigitDual]() {
|
||
goto l281
|
||
}
|
||
add(ruletimeHour, position282)
|
||
}
|
||
return true
|
||
l281:
|
||
position, tokenIndex = position281, tokenIndex281
|
||
return false
|
||
},
|
||
/* 45 timeMinute <- <digitDual> */
|
||
func() bool {
|
||
position283, tokenIndex283 := position, tokenIndex
|
||
{
|
||
position284 := position
|
||
if !_rules[ruledigitDual]() {
|
||
goto l283
|
||
}
|
||
add(ruletimeMinute, position284)
|
||
}
|
||
return true
|
||
l283:
|
||
position, tokenIndex = position283, tokenIndex283
|
||
return false
|
||
},
|
||
/* 46 timeSecond <- <digitDual> */
|
||
nil,
|
||
/* 47 timeSecfrac <- <('.' digit+)> */
|
||
nil,
|
||
/* 48 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
|
||
nil,
|
||
/* 49 timeOffset <- <('Z' / timeNumoffset)> */
|
||
nil,
|
||
/* 50 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
|
||
func() bool {
|
||
position289, tokenIndex289 := position, tokenIndex
|
||
{
|
||
position290 := position
|
||
if !_rules[ruletimeHour]() {
|
||
goto l289
|
||
}
|
||
if buffer[position] != rune(':') {
|
||
goto l289
|
||
}
|
||
position++
|
||
if !_rules[ruletimeMinute]() {
|
||
goto l289
|
||
}
|
||
if buffer[position] != rune(':') {
|
||
goto l289
|
||
}
|
||
position++
|
||
{
|
||
position291 := position
|
||
if !_rules[ruledigitDual]() {
|
||
goto l289
|
||
}
|
||
add(ruletimeSecond, position291)
|
||
}
|
||
{
|
||
position292, tokenIndex292 := position, tokenIndex
|
||
{
|
||
position294 := position
|
||
if buffer[position] != rune('.') {
|
||
goto l292
|
||
}
|
||
position++
|
||
if !_rules[ruledigit]() {
|
||
goto l292
|
||
}
|
||
l295:
|
||
{
|
||
position296, tokenIndex296 := position, tokenIndex
|
||
if !_rules[ruledigit]() {
|
||
goto l296
|
||
}
|
||
goto l295
|
||
l296:
|
||
position, tokenIndex = position296, tokenIndex296
|
||
}
|
||
add(ruletimeSecfrac, position294)
|
||
}
|
||
goto l293
|
||
l292:
|
||
position, tokenIndex = position292, tokenIndex292
|
||
}
|
||
l293:
|
||
add(rulepartialTime, position290)
|
||
}
|
||
return true
|
||
l289:
|
||
position, tokenIndex = position289, tokenIndex289
|
||
return false
|
||
},
|
||
/* 51 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
|
||
nil,
|
||
/* 52 fullTime <- <(partialTime timeOffset?)> */
|
||
nil,
|
||
/* 53 datetime <- <((fullDate ('T' fullTime)?) / partialTime)> */
|
||
nil,
|
||
/* 54 digit <- <[0-9]> */
|
||
func() bool {
|
||
position300, tokenIndex300 := position, tokenIndex
|
||
{
|
||
position301 := position
|
||
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
||
goto l300
|
||
}
|
||
position++
|
||
add(ruledigit, position301)
|
||
}
|
||
return true
|
||
l300:
|
||
position, tokenIndex = position300, tokenIndex300
|
||
return false
|
||
},
|
||
/* 55 digitDual <- <(digit digit)> */
|
||
func() bool {
|
||
position302, tokenIndex302 := position, tokenIndex
|
||
{
|
||
position303 := position
|
||
if !_rules[ruledigit]() {
|
||
goto l302
|
||
}
|
||
if !_rules[ruledigit]() {
|
||
goto l302
|
||
}
|
||
add(ruledigitDual, position303)
|
||
}
|
||
return true
|
||
l302:
|
||
position, tokenIndex = position302, tokenIndex302
|
||
return false
|
||
},
|
||
/* 56 digitQuad <- <(digitDual digitDual)> */
|
||
nil,
|
||
/* 57 array <- <('[' Action23 wsnl arrayValues? wsnl ']')> */
|
||
nil,
|
||
/* 58 arrayValues <- <(val Action24 (wsnl comment? wsnl arraySep wsnl comment? wsnl val Action25)* wsnl arraySep? wsnl comment?)> */
|
||
nil,
|
||
/* 59 arraySep <- <','> */
|
||
func() bool {
|
||
position307, tokenIndex307 := position, tokenIndex
|
||
{
|
||
position308 := position
|
||
if buffer[position] != rune(',') {
|
||
goto l307
|
||
}
|
||
position++
|
||
add(rulearraySep, position308)
|
||
}
|
||
return true
|
||
l307:
|
||
position, tokenIndex = position307, tokenIndex307
|
||
return false
|
||
},
|
||
/* 61 Action0 <- <{ _ = buffer }> */
|
||
nil,
|
||
nil,
|
||
/* 63 Action1 <- <{ p.SetTableString(begin, end) }> */
|
||
nil,
|
||
/* 64 Action2 <- <{ p.AddLineCount(end - begin) }> */
|
||
nil,
|
||
/* 65 Action3 <- <{ p.AddLineCount(end - begin) }> */
|
||
nil,
|
||
/* 66 Action4 <- <{ p.AddKeyValue() }> */
|
||
nil,
|
||
/* 67 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 68 Action6 <- <{ p.SetKey(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 69 Action7 <- <{ p.SetTime(begin, end) }> */
|
||
nil,
|
||
/* 70 Action8 <- <{ p.SetFloat64(begin, end) }> */
|
||
nil,
|
||
/* 71 Action9 <- <{ p.SetInt64(begin, end) }> */
|
||
nil,
|
||
/* 72 Action10 <- <{ p.SetString(begin, end) }> */
|
||
nil,
|
||
/* 73 Action11 <- <{ p.SetBool(begin, end) }> */
|
||
nil,
|
||
/* 74 Action12 <- <{ p.SetArray(begin, end) }> */
|
||
nil,
|
||
/* 75 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 76 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 77 Action15 <- <{ p.StartInlineTable() }> */
|
||
nil,
|
||
/* 78 Action16 <- <{ p.EndInlineTable() }> */
|
||
nil,
|
||
/* 79 Action17 <- <{ p.AddTableKey() }> */
|
||
nil,
|
||
/* 80 Action18 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 81 Action19 <- <{ p.SetMultilineString() }> */
|
||
nil,
|
||
/* 82 Action20 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 83 Action21 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 84 Action22 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
|
||
nil,
|
||
/* 85 Action23 <- <{ p.StartArray() }> */
|
||
nil,
|
||
/* 86 Action24 <- <{ p.AddArrayVal() }> */
|
||
nil,
|
||
/* 87 Action25 <- <{ p.AddArrayVal() }> */
|
||
nil,
|
||
}
|
||
p.rules = _rules
|
||
}
|