Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
2587 lines (2534 sloc) 62.2 KB
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
}
You can’t perform that action at this time.