aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/naoina/toml/parse.peg.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/naoina/toml/parse.peg.go')
-rw-r--r--vendor/github.com/naoina/toml/parse.peg.go2556
1 files changed, 2556 insertions, 0 deletions
diff --git a/vendor/github.com/naoina/toml/parse.peg.go b/vendor/github.com/naoina/toml/parse.peg.go
new file mode 100644
index 000000000..d7de73b19
--- /dev/null
+++ b/vendor/github.com/naoina/toml/parse.peg.go
@@ -0,0 +1,2556 @@
+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
+ 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
+)
+
+var rul3s = [...]string{
+ "Unknown",
+ "TOML",
+ "Expression",
+ "newline",
+ "ws",
+ "wsnl",
+ "comment",
+ "keyval",
+ "key",
+ "bareKey",
+ "quotedKey",
+ "val",
+ "table",
+ "stdTable",
+ "arrayTable",
+ "inlineTable",
+ "inlineTableKeyValues",
+ "tableKey",
+ "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",
+}
+
+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 [86]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-1, end+1)
+ 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.SetBasicString(p.buffer, begin, end)
+ case ruleAction18:
+ p.SetMultilineString()
+ case ruleAction19:
+ p.AddMultilineBasicBody(p.buffer, begin, end)
+ case ruleAction20:
+ p.SetLiteralString(p.buffer, begin, end)
+ case ruleAction21:
+ p.SetMultilineLiteralString(p.buffer, begin, end)
+ case ruleAction22:
+ p.StartArray()
+ case ruleAction23:
+ p.AddArrayVal()
+ case ruleAction24:
+ 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
+ if buffer[position] != rune('"') {
+ goto l70
+ }
+ position++
+ {
+ position82 := position
+ if !_rules[rulebasicChar]() {
+ goto l70
+ }
+ l83:
+ {
+ position84, tokenIndex84 := position, tokenIndex
+ if !_rules[rulebasicChar]() {
+ goto l84
+ }
+ goto l83
+ l84:
+ position, tokenIndex = position84, tokenIndex84
+ }
+ add(rulePegText, position82)
+ }
+ if buffer[position] != rune('"') {
+ goto l70
+ }
+ position++
+ {
+ 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 := position
+ {
+ position105, tokenIndex105 := position, tokenIndex
+ if buffer[position] != rune('Z') {
+ goto l106
+ }
+ position++
+ goto l105
+ l106:
+ position, tokenIndex = position105, tokenIndex105
+ {
+ position107 := position
+ {
+ position108, tokenIndex108 := position, tokenIndex
+ if buffer[position] != rune('-') {
+ goto l109
+ }
+ position++
+ goto l108
+ l109:
+ position, tokenIndex = position108, tokenIndex108
+ if buffer[position] != rune('+') {
+ goto l101
+ }
+ position++
+ }
+ l108:
+ if !_rules[ruletimeHour]() {
+ goto l101
+ }
+ if buffer[position] != rune(':') {
+ goto l101
+ }
+ position++
+ if !_rules[ruletimeMinute]() {
+ goto l101
+ }
+ add(ruletimeNumoffset, position107)
+ }
+ }
+ l105:
+ add(ruletimeOffset, position104)
+ }
+ 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
+ {
+ position112 := position
+ {
+ position113 := position
+ if !_rules[ruleinteger]() {
+ goto l111
+ }
+ {
+ position114, tokenIndex114 := position, tokenIndex
+ if !_rules[rulefrac]() {
+ goto l115
+ }
+ {
+ position116, tokenIndex116 := position, tokenIndex
+ if !_rules[ruleexp]() {
+ goto l116
+ }
+ goto l117
+ l116:
+ position, tokenIndex = position116, tokenIndex116
+ }
+ l117:
+ goto l114
+ l115:
+ position, tokenIndex = position114, tokenIndex114
+ {
+ position118, tokenIndex118 := position, tokenIndex
+ if !_rules[rulefrac]() {
+ goto l118
+ }
+ goto l119
+ l118:
+ position, tokenIndex = position118, tokenIndex118
+ }
+ l119:
+ if !_rules[ruleexp]() {
+ goto l111
+ }
+ }
+ l114:
+ add(rulefloat, position113)
+ }
+ add(rulePegText, position112)
+ }
+ {
+ add(ruleAction8, position)
+ }
+ goto l90
+ l111:
+ position, tokenIndex = position90, tokenIndex90
+ {
+ switch buffer[position] {
+ case '{':
+ {
+ position122 := position
+ if buffer[position] != rune('{') {
+ goto l88
+ }
+ position++
+ {
+ add(ruleAction15, position)
+ }
+ if !_rules[rulews]() {
+ goto l88
+ }
+ {
+ position124 := position
+ l125:
+ {
+ position126, tokenIndex126 := position, tokenIndex
+ if !_rules[rulekeyval]() {
+ goto l126
+ }
+ {
+ position127, tokenIndex127 := position, tokenIndex
+ {
+ position129 := position
+ if !_rules[rulews]() {
+ goto l127
+ }
+ if buffer[position] != rune(',') {
+ goto l127
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l127
+ }
+ add(ruleinlineTableValSep, position129)
+ }
+ goto l128
+ l127:
+ position, tokenIndex = position127, tokenIndex127
+ }
+ l128:
+ goto l125
+ l126:
+ position, tokenIndex = position126, tokenIndex126
+ }
+ add(ruleinlineTableKeyValues, position124)
+ }
+ if !_rules[rulews]() {
+ goto l88
+ }
+ if buffer[position] != rune('}') {
+ goto l88
+ }
+ position++
+ {
+ add(ruleAction16, position)
+ }
+ add(ruleinlineTable, position122)
+ }
+ break
+ case '[':
+ {
+ position131 := position
+ {
+ position132 := position
+ if buffer[position] != rune('[') {
+ goto l88
+ }
+ position++
+ {
+ add(ruleAction22, position)
+ }
+ if !_rules[rulewsnl]() {
+ goto l88
+ }
+ {
+ position134, tokenIndex134 := position, tokenIndex
+ {
+ position136 := position
+ if !_rules[ruleval]() {
+ goto l134
+ }
+ {
+ add(ruleAction23, position)
+ }
+ l138:
+ {
+ position139, tokenIndex139 := position, tokenIndex
+ if !_rules[rulewsnl]() {
+ goto l139
+ }
+ {
+ position140, tokenIndex140 := position, tokenIndex
+ if !_rules[rulecomment]() {
+ goto l140
+ }
+ goto l141
+ l140:
+ position, tokenIndex = position140, tokenIndex140
+ }
+ l141:
+ if !_rules[rulewsnl]() {
+ goto l139
+ }
+ if !_rules[rulearraySep]() {
+ goto l139
+ }
+ if !_rules[rulewsnl]() {
+ goto l139
+ }
+ {
+ position142, tokenIndex142 := position, tokenIndex
+ if !_rules[rulecomment]() {
+ goto l142
+ }
+ goto l143
+ l142:
+ position, tokenIndex = position142, tokenIndex142
+ }
+ l143:
+ if !_rules[rulewsnl]() {
+ goto l139
+ }
+ if !_rules[ruleval]() {
+ goto l139
+ }
+ {
+ add(ruleAction24, position)
+ }
+ goto l138
+ l139:
+ position, tokenIndex = position139, tokenIndex139
+ }
+ if !_rules[rulewsnl]() {
+ goto l134
+ }
+ {
+ position145, tokenIndex145 := position, tokenIndex
+ if !_rules[rulearraySep]() {
+ goto l145
+ }
+ goto l146
+ l145:
+ position, tokenIndex = position145, tokenIndex145
+ }
+ l146:
+ if !_rules[rulewsnl]() {
+ goto l134
+ }
+ {
+ position147, tokenIndex147 := position, tokenIndex
+ if !_rules[rulecomment]() {
+ goto l147
+ }
+ goto l148
+ l147:
+ position, tokenIndex = position147, tokenIndex147
+ }
+ l148:
+ add(rulearrayValues, position136)
+ }
+ goto l135
+ l134:
+ position, tokenIndex = position134, tokenIndex134
+ }
+ l135:
+ if !_rules[rulewsnl]() {
+ goto l88
+ }
+ if buffer[position] != rune(']') {
+ goto l88
+ }
+ position++
+ add(rulearray, position132)
+ }
+ add(rulePegText, position131)
+ }
+ {
+ add(ruleAction12, position)
+ }
+ break
+ case 'f', 't':
+ {
+ position150 := position
+ {
+ position151 := position
+ {
+ position152, tokenIndex152 := position, tokenIndex
+ if buffer[position] != rune('t') {
+ goto l153
+ }
+ position++
+ if buffer[position] != rune('r') {
+ goto l153
+ }
+ position++
+ if buffer[position] != rune('u') {
+ goto l153
+ }
+ position++
+ if buffer[position] != rune('e') {
+ goto l153
+ }
+ position++
+ goto l152
+ l153:
+ position, tokenIndex = position152, tokenIndex152
+ 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++
+ }
+ l152:
+ add(ruleboolean, position151)
+ }
+ add(rulePegText, position150)
+ }
+ {
+ add(ruleAction11, position)
+ }
+ break
+ case '"', '\'':
+ {
+ position155 := position
+ {
+ position156 := position
+ {
+ position157, tokenIndex157 := position, tokenIndex
+ {
+ position159 := position
+ if buffer[position] != rune('\'') {
+ goto l158
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l158
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l158
+ }
+ position++
+ {
+ position160 := position
+ {
+ position161 := position
+ l162:
+ {
+ position163, tokenIndex163 := position, tokenIndex
+ {
+ position164, tokenIndex164 := position, tokenIndex
+ if buffer[position] != rune('\'') {
+ goto l164
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l164
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l164
+ }
+ position++
+ goto l163
+ l164:
+ position, tokenIndex = position164, tokenIndex164
+ }
+ {
+ position165, tokenIndex165 := position, tokenIndex
+ {
+ position167 := position
+ {
+ position168, tokenIndex168 := position, tokenIndex
+ if buffer[position] != rune('\t') {
+ goto l169
+ }
+ position++
+ goto l168
+ l169:
+ position, tokenIndex = position168, tokenIndex168
+ if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
+ goto l166
+ }
+ position++
+ }
+ l168:
+ add(rulemlLiteralChar, position167)
+ }
+ goto l165
+ l166:
+ position, tokenIndex = position165, tokenIndex165
+ if !_rules[rulenewline]() {
+ goto l163
+ }
+ }
+ l165:
+ goto l162
+ l163:
+ position, tokenIndex = position163, tokenIndex163
+ }
+ add(rulemlLiteralBody, position161)
+ }
+ add(rulePegText, position160)
+ }
+ if buffer[position] != rune('\'') {
+ goto l158
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l158
+ }
+ position++
+ if buffer[position] != rune('\'') {
+ goto l158
+ }
+ position++
+ {
+ add(ruleAction21, position)
+ }
+ add(rulemlLiteralString, position159)
+ }
+ goto l157
+ l158:
+ position, tokenIndex = position157, tokenIndex157
+ {
+ position172 := position
+ if buffer[position] != rune('\'') {
+ goto l171
+ }
+ position++
+ {
+ position173 := position
+ l174:
+ {
+ position175, tokenIndex175 := position, tokenIndex
+ {
+ position176 := position
+ {
+ switch buffer[position] {
+ case '\t':
+ if buffer[position] != rune('\t') {
+ goto l175
+ }
+ position++
+ break
+ case ' ', '!', '"', '#', '$', '%', '&':
+ if c := buffer[position]; c < rune(' ') || c > rune('&') {
+ goto l175
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune('(') || c > rune('\U0010ffff') {
+ goto l175
+ }
+ position++
+ break
+ }
+ }
+
+ add(ruleliteralChar, position176)
+ }
+ goto l174
+ l175:
+ position, tokenIndex = position175, tokenIndex175
+ }
+ add(rulePegText, position173)
+ }
+ if buffer[position] != rune('\'') {
+ goto l171
+ }
+ position++
+ {
+ add(ruleAction20, position)
+ }
+ add(ruleliteralString, position172)
+ }
+ goto l157
+ l171:
+ position, tokenIndex = position157, tokenIndex157
+ {
+ position180 := position
+ if buffer[position] != rune('"') {
+ goto l179
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l179
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l179
+ }
+ position++
+ {
+ position181 := position
+ l182:
+ {
+ position183, tokenIndex183 := position, tokenIndex
+ {
+ position184, tokenIndex184 := position, tokenIndex
+ {
+ position186 := position
+ {
+ position187, tokenIndex187 := position, tokenIndex
+ if !_rules[rulebasicChar]() {
+ goto l188
+ }
+ goto l187
+ l188:
+ position, tokenIndex = position187, tokenIndex187
+ if !_rules[rulenewline]() {
+ goto l185
+ }
+ }
+ l187:
+ add(rulePegText, position186)
+ }
+ {
+ add(ruleAction19, position)
+ }
+ goto l184
+ l185:
+ position, tokenIndex = position184, tokenIndex184
+ if !_rules[ruleescape]() {
+ goto l183
+ }
+ if !_rules[rulenewline]() {
+ goto l183
+ }
+ if !_rules[rulewsnl]() {
+ goto l183
+ }
+ }
+ l184:
+ goto l182
+ l183:
+ position, tokenIndex = position183, tokenIndex183
+ }
+ add(rulemlBasicBody, position181)
+ }
+ if buffer[position] != rune('"') {
+ goto l179
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l179
+ }
+ position++
+ if buffer[position] != rune('"') {
+ goto l179
+ }
+ position++
+ {
+ add(ruleAction18, position)
+ }
+ add(rulemlBasicString, position180)
+ }
+ goto l157
+ l179:
+ position, tokenIndex = position157, tokenIndex157
+ {
+ position191 := position
+ {
+ position192 := position
+ if buffer[position] != rune('"') {
+ goto l88
+ }
+ position++
+ l193:
+ {
+ position194, tokenIndex194 := position, tokenIndex
+ if !_rules[rulebasicChar]() {
+ goto l194
+ }
+ goto l193
+ l194:
+ position, tokenIndex = position194, tokenIndex194
+ }
+ if buffer[position] != rune('"') {
+ goto l88
+ }
+ position++
+ add(rulePegText, position192)
+ }
+ {
+ add(ruleAction17, position)
+ }
+ add(rulebasicString, position191)
+ }
+ }
+ l157:
+ add(rulestring, position156)
+ }
+ add(rulePegText, position155)
+ }
+ {
+ add(ruleAction10, position)
+ }
+ break
+ default:
+ {
+ position197 := position
+ if !_rules[ruleinteger]() {
+ goto l88
+ }
+ add(rulePegText, position197)
+ }
+ {
+ 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 <- <(key (tableKeySep key)*)> */
+ func() bool {
+ position204, tokenIndex204 := position, tokenIndex
+ {
+ position205 := position
+ if !_rules[rulekey]() {
+ goto l204
+ }
+ l206:
+ {
+ position207, tokenIndex207 := position, tokenIndex
+ {
+ position208 := position
+ if !_rules[rulews]() {
+ goto l207
+ }
+ if buffer[position] != rune('.') {
+ goto l207
+ }
+ position++
+ if !_rules[rulews]() {
+ goto l207
+ }
+ add(ruletableKeySep, position208)
+ }
+ if !_rules[rulekey]() {
+ goto l207
+ }
+ goto l206
+ l207:
+ position, tokenIndex = position207, tokenIndex207
+ }
+ add(ruletableKey, position205)
+ }
+ return true
+ l204:
+ position, tokenIndex = position204, tokenIndex204
+ return false
+ },
+ /* 17 tableKeySep <- <(ws '.' ws)> */
+ nil,
+ /* 18 inlineTableValSep <- <(ws ',' ws)> */
+ nil,
+ /* 19 integer <- <(('-' / '+')? int)> */
+ func() bool {
+ position211, tokenIndex211 := position, tokenIndex
+ {
+ position212 := position
+ {
+ position213, tokenIndex213 := position, tokenIndex
+ {
+ position215, tokenIndex215 := position, tokenIndex
+ if buffer[position] != rune('-') {
+ goto l216
+ }
+ position++
+ goto l215
+ l216:
+ position, tokenIndex = position215, tokenIndex215
+ if buffer[position] != rune('+') {
+ goto l213
+ }
+ position++
+ }
+ l215:
+ goto l214
+ l213:
+ position, tokenIndex = position213, tokenIndex213
+ }
+ l214:
+ {
+ position217 := position
+ {
+ position218, tokenIndex218 := position, tokenIndex
+ if c := buffer[position]; c < rune('1') || c > rune('9') {
+ goto l219
+ }
+ position++
+ {
+ position222, tokenIndex222 := position, tokenIndex
+ if !_rules[ruledigit]() {
+ goto l223
+ }
+ goto l222
+ l223:
+ position, tokenIndex = position222, tokenIndex222
+ if buffer[position] != rune('_') {
+ goto l219
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l219
+ }
+ }
+ l222:
+ l220:
+ {
+ position221, tokenIndex221 := position, tokenIndex
+ {
+ position224, tokenIndex224 := position, tokenIndex
+ if !_rules[ruledigit]() {
+ goto l225
+ }
+ goto l224
+ l225:
+ position, tokenIndex = position224, tokenIndex224
+ if buffer[position] != rune('_') {
+ goto l221
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l221
+ }
+ }
+ l224:
+ goto l220
+ l221:
+ position, tokenIndex = position221, tokenIndex221
+ }
+ goto l218
+ l219:
+ position, tokenIndex = position218, tokenIndex218
+ if !_rules[ruledigit]() {
+ goto l211
+ }
+ }
+ l218:
+ add(ruleint, position217)
+ }
+ add(ruleinteger, position212)
+ }
+ return true
+ l211:
+ position, tokenIndex = position211, tokenIndex211
+ return false
+ },
+ /* 20 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
+ nil,
+ /* 21 float <- <(integer ((frac exp?) / (frac? exp)))> */
+ nil,
+ /* 22 frac <- <('.' digit (digit / ('_' digit))*)> */
+ func() bool {
+ position228, tokenIndex228 := position, tokenIndex
+ {
+ position229 := position
+ if buffer[position] != rune('.') {
+ goto l228
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l228
+ }
+ l230:
+ {
+ position231, tokenIndex231 := position, tokenIndex
+ {
+ position232, tokenIndex232 := position, tokenIndex
+ if !_rules[ruledigit]() {
+ goto l233
+ }
+ goto l232
+ l233:
+ position, tokenIndex = position232, tokenIndex232
+ if buffer[position] != rune('_') {
+ goto l231
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l231
+ }
+ }
+ l232:
+ goto l230
+ l231:
+ position, tokenIndex = position231, tokenIndex231
+ }
+ add(rulefrac, position229)
+ }
+ return true
+ l228:
+ position, tokenIndex = position228, tokenIndex228
+ return false
+ },
+ /* 23 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
+ func() bool {
+ position234, tokenIndex234 := position, tokenIndex
+ {
+ position235 := position
+ {
+ position236, tokenIndex236 := position, tokenIndex
+ if buffer[position] != rune('e') {
+ goto l237
+ }
+ position++
+ goto l236
+ l237:
+ position, tokenIndex = position236, tokenIndex236
+ if buffer[position] != rune('E') {
+ goto l234
+ }
+ position++
+ }
+ l236:
+ {
+ position238, tokenIndex238 := position, tokenIndex
+ {
+ position240, tokenIndex240 := position, tokenIndex
+ if buffer[position] != rune('-') {
+ goto l241
+ }
+ position++
+ goto l240
+ l241:
+ position, tokenIndex = position240, tokenIndex240
+ if buffer[position] != rune('+') {
+ goto l238
+ }
+ position++
+ }
+ l240:
+ goto l239
+ l238:
+ position, tokenIndex = position238, tokenIndex238
+ }
+ l239:
+ if !_rules[ruledigit]() {
+ goto l234
+ }
+ l242:
+ {
+ position243, tokenIndex243 := position, tokenIndex
+ {
+ position244, tokenIndex244 := position, tokenIndex
+ if !_rules[ruledigit]() {
+ goto l245
+ }
+ goto l244
+ l245:
+ position, tokenIndex = position244, tokenIndex244
+ if buffer[position] != rune('_') {
+ goto l243
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l243
+ }
+ }
+ l244:
+ goto l242
+ l243:
+ position, tokenIndex = position243, tokenIndex243
+ }
+ add(ruleexp, position235)
+ }
+ return true
+ l234:
+ position, tokenIndex = position234, tokenIndex234
+ return false
+ },
+ /* 24 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
+ nil,
+ /* 25 basicString <- <(<('"' basicChar* '"')> Action17)> */
+ nil,
+ /* 26 basicChar <- <(basicUnescaped / escaped)> */
+ func() bool {
+ position248, tokenIndex248 := position, tokenIndex
+ {
+ position249 := position
+ {
+ position250, tokenIndex250 := position, tokenIndex
+ {
+ position252 := position
+ {
+ switch buffer[position] {
+ case ' ', '!':
+ if c := buffer[position]; c < rune(' ') || c > rune('!') {
+ goto l251
+ }
+ 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 l251
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune(']') || c > rune('\U0010ffff') {
+ goto l251
+ }
+ position++
+ break
+ }
+ }
+
+ add(rulebasicUnescaped, position252)
+ }
+ goto l250
+ l251:
+ position, tokenIndex = position250, tokenIndex250
+ {
+ position254 := position
+ if !_rules[ruleescape]() {
+ goto l248
+ }
+ {
+ switch buffer[position] {
+ case 'U':
+ if buffer[position] != rune('U') {
+ goto l248
+ }
+ position++
+ if !_rules[rulehexQuad]() {
+ goto l248
+ }
+ if !_rules[rulehexQuad]() {
+ goto l248
+ }
+ break
+ case 'u':
+ if buffer[position] != rune('u') {
+ goto l248
+ }
+ position++
+ if !_rules[rulehexQuad]() {
+ goto l248
+ }
+ break
+ case '\\':
+ if buffer[position] != rune('\\') {
+ goto l248
+ }
+ position++
+ break
+ case '/':
+ if buffer[position] != rune('/') {
+ goto l248
+ }
+ position++
+ break
+ case '"':
+ if buffer[position] != rune('"') {
+ goto l248
+ }
+ position++
+ break
+ case 'r':
+ if buffer[position] != rune('r') {
+ goto l248
+ }
+ position++
+ break
+ case 'f':
+ if buffer[position] != rune('f') {
+ goto l248
+ }
+ position++
+ break
+ case 'n':
+ if buffer[position] != rune('n') {
+ goto l248
+ }
+ position++
+ break
+ case 't':
+ if buffer[position] != rune('t') {
+ goto l248
+ }
+ position++
+ break
+ default:
+ if buffer[position] != rune('b') {
+ goto l248
+ }
+ position++
+ break
+ }
+ }
+
+ add(ruleescaped, position254)
+ }
+ }
+ l250:
+ add(rulebasicChar, position249)
+ }
+ return true
+ l248:
+ position, tokenIndex = position248, tokenIndex248
+ return false
+ },
+ /* 27 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
+ nil,
+ /* 28 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,
+ /* 29 escape <- <'\\'> */
+ func() bool {
+ position258, tokenIndex258 := position, tokenIndex
+ {
+ position259 := position
+ if buffer[position] != rune('\\') {
+ goto l258
+ }
+ position++
+ add(ruleescape, position259)
+ }
+ return true
+ l258:
+ position, tokenIndex = position258, tokenIndex258
+ return false
+ },
+ /* 30 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action18)> */
+ nil,
+ /* 31 mlBasicBody <- <((<(basicChar / newline)> Action19) / (escape newline wsnl))*> */
+ nil,
+ /* 32 literalString <- <('\'' <literalChar*> '\'' Action20)> */
+ nil,
+ /* 33 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,
+ /* 34 mlLiteralString <- <('\'' '\'' '\'' <mlLiteralBody> ('\'' '\'' '\'') Action21)> */
+ nil,
+ /* 35 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
+ nil,
+ /* 36 mlLiteralChar <- <('\t' / [ -\U0010ffff])> */
+ nil,
+ /* 37 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 {
+ position267, tokenIndex267 := position, tokenIndex
+ {
+ position268 := position
+ {
+ switch buffer[position] {
+ case 'a', 'b', 'c', 'd', 'e', 'f':
+ if c := buffer[position]; c < rune('a') || c > rune('f') {
+ goto l267
+ }
+ position++
+ break
+ case 'A', 'B', 'C', 'D', 'E', 'F':
+ if c := buffer[position]; c < rune('A') || c > rune('F') {
+ goto l267
+ }
+ position++
+ break
+ default:
+ if c := buffer[position]; c < rune('0') || c > rune('9') {
+ goto l267
+ }
+ position++
+ break
+ }
+ }
+
+ add(rulehexdigit, position268)
+ }
+ return true
+ l267:
+ position, tokenIndex = position267, tokenIndex267
+ return false
+ },
+ /* 38 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
+ func() bool {
+ position270, tokenIndex270 := position, tokenIndex
+ {
+ position271 := position
+ if !_rules[rulehexdigit]() {
+ goto l270
+ }
+ if !_rules[rulehexdigit]() {
+ goto l270
+ }
+ if !_rules[rulehexdigit]() {
+ goto l270
+ }
+ if !_rules[rulehexdigit]() {
+ goto l270
+ }
+ add(rulehexQuad, position271)
+ }
+ return true
+ l270:
+ position, tokenIndex = position270, tokenIndex270
+ return false
+ },
+ /* 39 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
+ nil,
+ /* 40 dateFullYear <- <digitQuad> */
+ nil,
+ /* 41 dateMonth <- <digitDual> */
+ nil,
+ /* 42 dateMDay <- <digitDual> */
+ nil,
+ /* 43 timeHour <- <digitDual> */
+ func() bool {
+ position276, tokenIndex276 := position, tokenIndex
+ {
+ position277 := position
+ if !_rules[ruledigitDual]() {
+ goto l276
+ }
+ add(ruletimeHour, position277)
+ }
+ return true
+ l276:
+ position, tokenIndex = position276, tokenIndex276
+ return false
+ },
+ /* 44 timeMinute <- <digitDual> */
+ func() bool {
+ position278, tokenIndex278 := position, tokenIndex
+ {
+ position279 := position
+ if !_rules[ruledigitDual]() {
+ goto l278
+ }
+ add(ruletimeMinute, position279)
+ }
+ return true
+ l278:
+ position, tokenIndex = position278, tokenIndex278
+ return false
+ },
+ /* 45 timeSecond <- <digitDual> */
+ nil,
+ /* 46 timeSecfrac <- <('.' digit+)> */
+ nil,
+ /* 47 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
+ nil,
+ /* 48 timeOffset <- <('Z' / timeNumoffset)> */
+ nil,
+ /* 49 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
+ func() bool {
+ position284, tokenIndex284 := position, tokenIndex
+ {
+ position285 := position
+ if !_rules[ruletimeHour]() {
+ goto l284
+ }
+ if buffer[position] != rune(':') {
+ goto l284
+ }
+ position++
+ if !_rules[ruletimeMinute]() {
+ goto l284
+ }
+ if buffer[position] != rune(':') {
+ goto l284
+ }
+ position++
+ {
+ position286 := position
+ if !_rules[ruledigitDual]() {
+ goto l284
+ }
+ add(ruletimeSecond, position286)
+ }
+ {
+ position287, tokenIndex287 := position, tokenIndex
+ {
+ position289 := position
+ if buffer[position] != rune('.') {
+ goto l287
+ }
+ position++
+ if !_rules[ruledigit]() {
+ goto l287
+ }
+ l290:
+ {
+ position291, tokenIndex291 := position, tokenIndex
+ if !_rules[ruledigit]() {
+ goto l291
+ }
+ goto l290
+ l291:
+ position, tokenIndex = position291, tokenIndex291
+ }
+ add(ruletimeSecfrac, position289)
+ }
+ goto l288
+ l287:
+ position, tokenIndex = position287, tokenIndex287
+ }
+ l288:
+ add(rulepartialTime, position285)
+ }
+ return true
+ l284:
+ position, tokenIndex = position284, tokenIndex284
+ return false
+ },
+ /* 50 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
+ nil,
+ /* 51 fullTime <- <(partialTime timeOffset)> */
+ nil,
+ /* 52 datetime <- <((fullDate ('T' fullTime)?) / partialTime)> */
+ nil,
+ /* 53 digit <- <[0-9]> */
+ func() bool {
+ position295, tokenIndex295 := position, tokenIndex
+ {
+ position296 := position
+ if c := buffer[position]; c < rune('0') || c > rune('9') {
+ goto l295
+ }
+ position++
+ add(ruledigit, position296)
+ }
+ return true
+ l295:
+ position, tokenIndex = position295, tokenIndex295
+ return false
+ },
+ /* 54 digitDual <- <(digit digit)> */
+ func() bool {
+ position297, tokenIndex297 := position, tokenIndex
+ {
+ position298 := position
+ if !_rules[ruledigit]() {
+ goto l297
+ }
+ if !_rules[ruledigit]() {
+ goto l297
+ }
+ add(ruledigitDual, position298)
+ }
+ return true
+ l297:
+ position, tokenIndex = position297, tokenIndex297
+ return false
+ },
+ /* 55 digitQuad <- <(digitDual digitDual)> */
+ nil,
+ /* 56 array <- <('[' Action22 wsnl arrayValues? wsnl ']')> */
+ nil,
+ /* 57 arrayValues <- <(val Action23 (wsnl comment? wsnl arraySep wsnl comment? wsnl val Action24)* wsnl arraySep? wsnl comment?)> */
+ nil,
+ /* 58 arraySep <- <','> */
+ func() bool {
+ position302, tokenIndex302 := position, tokenIndex
+ {
+ position303 := position
+ if buffer[position] != rune(',') {
+ goto l302
+ }
+ position++
+ add(rulearraySep, position303)
+ }
+ return true
+ l302:
+ position, tokenIndex = position302, tokenIndex302
+ return false
+ },
+ /* 60 Action0 <- <{ _ = buffer }> */
+ nil,
+ nil,
+ /* 62 Action1 <- <{ p.SetTableString(begin, end) }> */
+ nil,
+ /* 63 Action2 <- <{ p.AddLineCount(end - begin) }> */
+ nil,
+ /* 64 Action3 <- <{ p.AddLineCount(end - begin) }> */
+ nil,
+ /* 65 Action4 <- <{ p.AddKeyValue() }> */
+ nil,
+ /* 66 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
+ nil,
+ /* 67 Action6 <- <{ p.SetKey(p.buffer, begin-1, end+1) }> */
+ nil,
+ /* 68 Action7 <- <{ p.SetTime(begin, end) }> */
+ nil,
+ /* 69 Action8 <- <{ p.SetFloat64(begin, end) }> */
+ nil,
+ /* 70 Action9 <- <{ p.SetInt64(begin, end) }> */
+ nil,
+ /* 71 Action10 <- <{ p.SetString(begin, end) }> */
+ nil,
+ /* 72 Action11 <- <{ p.SetBool(begin, end) }> */
+ nil,
+ /* 73 Action12 <- <{ p.SetArray(begin, end) }> */
+ nil,
+ /* 74 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
+ nil,
+ /* 75 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
+ nil,
+ /* 76 Action15 <- <{ p.StartInlineTable() }> */
+ nil,
+ /* 77 Action16 <- <{ p.EndInlineTable() }> */
+ nil,
+ /* 78 Action17 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
+ nil,
+ /* 79 Action18 <- <{ p.SetMultilineString() }> */
+ nil,
+ /* 80 Action19 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
+ nil,
+ /* 81 Action20 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
+ nil,
+ /* 82 Action21 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
+ nil,
+ /* 83 Action22 <- <{ p.StartArray() }> */
+ nil,
+ /* 84 Action23 <- <{ p.AddArrayVal() }> */
+ nil,
+ /* 85 Action24 <- <{ p.AddArrayVal() }> */
+ nil,
+ }
+ p.rules = _rules
+}
generated by cgit (git 2.34.1) at 2025-03-12 08:57:48 +0800