path: root/vendor/github.com/naoina/toml/parse.peg.go

package toml

import (
    "fmt"
    "math"
    "sort"
    "strconv"
)

const endSymbol rune = 1114112

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

const (
    ruleUnknown pegRule = iota
    ruleTOML
    ruleExpression
    rulenewline
    rulews
    rulewsnl
    rulecomment
    rulekeyval
    rulekey
    rulebareKey
    rulequotedKey
    ruleval
    ruletable
    rulestdTable
    rulearrayTable
    ruleinlineTable
    ruleinlineTableKeyValues
    ruletableKey
    ruletableKeyComp
    ruletableKeySep
    ruleinlineTableValSep
    ruleinteger
    ruleint
    rulefloat
    rulefrac
    ruleexp
    rulestring
    rulebasicString
    rulebasicChar
    ruleescaped
    rulebasicUnescaped
    ruleescape
    rulemlBasicString
    rulemlBasicBody
    ruleliteralString
    ruleliteralChar
    rulemlLiteralString
    rulemlLiteralBody
    rulemlLiteralChar
    rulehexdigit
    rulehexQuad
    ruleboolean
    ruledateFullYear
    ruledateMonth
    ruledateMDay
    ruletimeHour
    ruletimeMinute
    ruletimeSecond
    ruletimeSecfrac
    ruletimeNumoffset
    ruletimeOffset
    rulepartialTime
    rulefullDate
    rulefullTime
    ruledatetime
    ruledigit
    ruledigitDual
    ruledigitQuad
    rulearray
    rulearrayValues
    rulearraySep
    ruleAction0
    rulePegText
    ruleAction1
    ruleAction2
    ruleAction3
    ruleAction4
    ruleAction5
    ruleAction6
    ruleAction7
    ruleAction8
    ruleAction9
    ruleAction10
    ruleAction11
    ruleAction12
    ruleAction13
    ruleAction14
    ruleAction15
    ruleAction16
    ruleAction17
    ruleAction18
    ruleAction19
    ruleAction20
    ruleAction21
    ruleAction22
    ruleAction23
    ruleAction24
    ruleAction25
)

var rul3s = [...]string{
    "Unknown",
    "TOML",
    "Expression",
    "newline",
    "ws",
    "wsnl",
    "comment",
    "keyval",
    "key",
    "bareKey",
    "quotedKey",
    "val",
    "table",
    "stdTable",
    "arrayTable",
    "inlineTable",
    "inlineTableKeyValues",
    "tableKey",
    "tableKeyComp",
    "tableKeySep",
    "inlineTableValSep",
    "integer",
    "int",
    "float",
    "frac",
    "exp",
    "string",
    "basicString",
    "basicChar",
    "escaped",
    "basicUnescaped",
    "escape",
    "mlBasicString",
    "mlBasicBody",
    "literalString",
    "literalChar",
    "mlLiteralString",
    "mlLiteralBody",
    "mlLiteralChar",
    "hexdigit",
    "hexQuad",
    "boolean",
    "dateFullYear",
    "dateMonth",
    "dateMDay",
    "timeHour",
    "timeMinute",
    "timeSecond",
    "timeSecfrac",
    "timeNumoffset",
    "timeOffset",
    "partialTime",
    "fullDate",
    "fullTime",
    "datetime",
    "digit",
    "digitDual",
    "digitQuad",
    "array",
    "arrayValues",
    "arraySep",
    "Action0",
    "PegText",
    "Action1",
    "Action2",
    "Action3",
    "Action4",
    "Action5",
    "Action6",
    "Action7",
    "Action8",
    "Action9",
    "Action10",
    "Action11",
    "Action12",
    "Action13",
    "Action14",
    "Action15",
    "Action16",
    "Action17",
    "Action18",
    "Action19",
    "Action20",
    "Action21",
    "Action22",
    "Action23",
    "Action24",
    "Action25",
}

type token32 struct {
    pegRule
    begin, end uint32
}

func (t *token32) String() string {
    return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v", rul3s[t.pegRule], t.begin, t.end)
}

type node32 struct {
    token32
    up, next *node32
}

func (node *node32) print(pretty bool, buffer string) {
    var print func(node *node32, depth int)
    print = func(node *node32, depth int) {
        for node != nil {
            for c := 0; c < depth; c++ {
                fmt.Printf(" ")
            }
            rule := rul3s[node.pegRule]
            quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
            if !pretty {
                fmt.Printf("%v %v\n", rule, quote)
            } else {
                fmt.Printf("\x1B[34m%v\x1B[m %v\n", rule, quote)
            }
            if node.up != nil {
                print(node.up, depth+1)
            }
            node = node.next
        }
    }
    print(node, 0)
}

func (node *node32) Print(buffer string) {
    node.print(false, buffer)
}

func (node *node32) PrettyPrint(buffer string) {
    node.print(true, buffer)
}

type tokens32 struct {
    tree []token32
}

func (t *tokens32) Trim(length uint32) {
    t.tree = t.tree[:length]
}

func (t *tokens32) Print() {
    for _, token := range t.tree {
        fmt.Println(token.String())
    }
}

func (t *tokens32) AST() *node32 {
    type element struct {
        node *node32
        down *element
    }
    tokens := t.Tokens()
    var stack *element
    for _, token := range tokens {
        if token.begin == token.end {
            continue
        }
        node := &node32{token32: token}
        for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
            stack.node.next = node.up
            node.up = stack.node
            stack = stack.down
        }
        stack = &element{node: node, down: stack}
    }
    if stack != nil {
        return stack.node
    }
    return nil
}

func (t *tokens32) PrintSyntaxTree(buffer string) {
    t.AST().Print(buffer)
}

func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
    t.AST().PrettyPrint(buffer)
}

func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
    if tree := t.tree; int(index) >= len(tree) {
        expanded := make([]token32, 2*len(tree))
        copy(expanded, tree)
        t.tree = expanded
    }
    t.tree[index] = token32{
        pegRule: rule,
        begin:   begin,
        end:     end,
    }
}

func (t *tokens32) Tokens() []token32 {
    return t.tree
}

type tomlParser struct {
    toml

    Buffer string
    buffer []rune
    rules  [88]func() bool
    parse  func(rule ...int) error
    reset  func()
    Pretty bool
    tokens32
}

func (p *tomlParser) Parse(rule ...int) error {
    return p.parse(rule...)
}

func (p *tomlParser) Reset() {
    p.reset()
}

type textPosition struct {
    line, symbol int
}

type textPositionMap map[int]textPosition

func translatePositions(buffer []rune, positions []int) textPositionMap {
    length, translations, j, line, symbol := len(positions), make(textPositionMap, len(positions)), 0, 1, 0
    sort.Ints(positions)

search:
    for i, c := range buffer {
        if c == '\n' {
            line, symbol = line+1, 0
        } else {
            symbol++
        }
        if i == positions[j] {
            translations[positions[j]] = textPosition{line, symbol}
            for j++; j < length; j++ {
                if i != positions[j] {
                    continue search
                }
            }
            break search
        }
    }

    return translations
}

type parseError struct {
    p   *tomlParser
    max token32
}

func (e *parseError) Error() string {
    tokens, error := []token32{e.max}, "\n"
    positions, p := make([]int, 2*len(tokens)), 0
    for _, token := range tokens {
        positions[p], p = int(token.begin), p+1
        positions[p], p = int(token.end), p+1
    }
    translations := translatePositions(e.p.buffer, positions)
    format := "parse error near %v (line %v symbol %v - line %v symbol %v):\n%v\n"
    if e.p.Pretty {
        format = "parse error near \x1B[34m%v\x1B[m (line %v symbol %v - line %v symbol %v):\n%v\n"
    }
    for _, token := range tokens {
        begin, end := int(token.begin), int(token.end)
        error += fmt.Sprintf(format,
            rul3s[token.pegRule],
            translations[begin].line, translations[begin].symbol,
            translations[end].line, translations[end].symbol,
            strconv.Quote(string(e.p.buffer[begin:end])))
    }

    return error
}

func (p *tomlParser) PrintSyntaxTree() {
    if p.Pretty {
        p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
    } else {
        p.tokens32.PrintSyntaxTree(p.Buffer)
    }
}

func (p *tomlParser) Execute() {
    buffer, _buffer, text, begin, end := p.Buffer, p.buffer, "", 0, 0
    for _, token := range p.Tokens() {
        switch token.pegRule {

        case rulePegText:
            begin, end = int(token.begin), int(token.end)
            text = string(_buffer[begin:end])

        case ruleAction0:
            _ = buffer
        case ruleAction1:
            p.SetTableString(begin, end)
        case ruleAction2:
            p.AddLineCount(end - begin)
        case ruleAction3:
            p.AddLineCount(end - begin)
        case ruleAction4:
            p.AddKeyValue()
        case ruleAction5:
            p.SetKey(p.buffer, begin, end)
        case ruleAction6:
            p.SetKey(p.buffer, begin, end)
        case ruleAction7:
            p.SetTime(begin, end)
        case ruleAction8:
            p.SetFloat64(begin, end)
        case ruleAction9:
            p.SetInt64(begin, end)
        case ruleAction10:
            p.SetString(begin, end)
        case ruleAction11:
            p.SetBool(begin, end)
        case ruleAction12:
            p.SetArray(begin, end)
        case ruleAction13:
            p.SetTable(p.buffer, begin, end)
        case ruleAction14:
            p.SetArrayTable(p.buffer, begin, end)
        case ruleAction15:
            p.StartInlineTable()
        case ruleAction16:
            p.EndInlineTable()
        case ruleAction17:
            p.AddTableKey()
        case ruleAction18:
            p.SetBasicString(p.buffer, begin, end)
        case ruleAction19:
            p.SetMultilineString()
        case ruleAction20:
            p.AddMultilineBasicBody(p.buffer, begin, end)
        case ruleAction21:
            p.SetLiteralString(p.buffer, begin, end)
        case ruleAction22:
            p.SetMultilineLiteralString(p.buffer, begin, end)
        case ruleAction23:
            p.StartArray()
        case ruleAction24:
            p.AddArrayVal()
        case ruleAction25:
            p.AddArrayVal()

        }
    }
    _, _, _, _, _ = buffer, _buffer, text, begin, end
}

func (p *tomlParser) Init() {
    var (
        max                  token32
        position, tokenIndex uint32
        buffer               []rune
    )
    p.reset = func() {
        max = token32{}
        position, tokenIndex = 0, 0

        p.buffer = []rune(p.Buffer)
        if len(p.buffer) == 0 || p.buffer[len(p.buffer)-1] != endSymbol {
            p.buffer = append(p.buffer, endSymbol)
        }
        buffer = p.buffer
    }
    p.reset()

    _rules := p.rules
    tree := tokens32{tree: make([]token32, math.MaxInt16)}
    p.parse = func(rule ...int) error {
        r := 1
        if len(rule) > 0 {
            r = rule[0]
        }
        matches := p.rules[r]()
        p.tokens32 = tree
        if matches {
            p.Trim(tokenIndex)
            return nil
        }
        return &parseError{p, max}
    }

    add := func(rule pegRule, begin uint32) {
        tree.Add(rule, begin, position, tokenIndex)
        tokenIndex++
        if begin != position && position > max.end {
            max = token32{rule, begin, position}
        }
    }

    matchDot := func() bool {
        if buffer[position] != endSymbol {
            position++
            return true
        }
        return false
    }

    /*matchChar := func(c byte) bool {
        if buffer[position] == c {
            position++
            return true
        }
        return false
    }*/

    /*matchRange := func(lower byte, upper byte) bool {
        if c := buffer[position]; c >= lower && c <= upper {
            position++
            return true
        }
        return false
    }*/

    _rules = [...]func() bool{
        nil,
        /* 0 TOML <- <(Expression (newline Expression)* newline? !. Action0)> */
        func() bool {
            position0, tokenIndex0 := position, tokenIndex
            {
                position1 := position
                if !_rules[ruleExpression]() {
                    goto l0
                }
            l2:
                {
                    position3, tokenIndex3 := position, tokenIndex
                    if !_rules[rulenewline]() {
                        goto l3
                    }
                    if !_rules[ruleExpression]() {
                        goto l3
                    }
                    goto l2
                l3:
                    position, tokenIndex = position3, tokenIndex3
                }
                {
                    position4, tokenIndex4 := position, tokenIndex
                    if !_rules[rulenewline]() {
                        goto l4
                    }
                    goto l5
                l4:
                    position, tokenIndex = position4, tokenIndex4
                }
            l5:
                {
                    position6, tokenIndex6 := position, tokenIndex
                    if !matchDot() {
                        goto l6
                    }
                    goto l0
                l6:
                    position, tokenIndex = position6, tokenIndex6
                }
                {
                    add(ruleAction0, position)
                }
                add(ruleTOML, position1)
            }
            return true
        l0:
            position, tokenIndex = position0, tokenIndex0
            return false
        },
        /* 1 Expression <- <((<(ws table ws comment? (wsnl keyval ws comment?)*)> Action1) / (ws keyval ws comment?) / (ws comment?) / ws)> */
        func() bool {
            position8, tokenIndex8 := position, tokenIndex
            {
                position9 := position
                {
                    position10, tokenIndex10 := position, tokenIndex
                    {
                        position12 := position
                        if !_rules[rulews]() {
                            goto l11
                        }
                        {
                            position13 := position
                            {
                                position14, tokenIndex14 := position, tokenIndex
                                {
                                    position16 := position
                                    if buffer[position] != rune('[') {
                                        goto l15
                                    }
                                    position++
                                    if !_rules[rulews]() {
                                        goto l15
                                    }
                                    {
                                        position17 := position
                                        if !_rules[ruletableKey]() {
                                            goto l15
                                        }
                                        add(rulePegText, position17)
                                    }
                                    if !_rules[rulews]() {
                                        goto l15
                                    }
                                    if buffer[position] != rune(']') {
                                        goto l15
                                    }
                                    position++
                                    {
                                        add(ruleAction13, position)
                                    }
                                    add(rulestdTable, position16)
                                }
                                goto l14
                            l15:
                                position, tokenIndex = position14, tokenIndex14
                                {
                                    position19 := position
                                    if buffer[position] != rune('[') {
                                        goto l11
                                    }
                                    position++
                                    if buffer[position] != rune('[') {
                                        goto l11
                                    }
                                    position++
                                    if !_rules[rulews]() {
                                        goto l11
                                    }
                                    {
                                        position20 := position
                                        if !_rules[ruletableKey]() {
                                            goto l11
                                        }
                                        add(rulePegText, position20)
                                    }
                                    if !_rules[rulews]() {
                                        goto l11
                                    }
                                    if buffer[position] != rune(']') {
                                        goto l11
                                    }
                                    position++
                                    if buffer[position] != rune(']') {
                                        goto l11
                                    }
                                    position++
                                    {
                                        add(ruleAction14, position)
                                    }
                                    add(rulearrayTable, position19)
                                }
                            }
                        l14:
                            add(ruletable, position13)
                        }
                        if !_rules[rulews]() {
                            goto l11
                        }
                        {
                            position22, tokenIndex22 := position, tokenIndex
                            if !_rules[rulecomment]() {
                                goto l22
                            }
                            goto l23
                        l22:
                            position, tokenIndex = position22, tokenIndex22
                        }
                    l23:
                    l24:
                        {
                            position25, tokenIndex25 := position, tokenIndex
                            if !_rules[rulewsnl]() {
                                goto l25
                            }
                            if !_rules[rulekeyval]() {
                                goto l25
                            }
                            if !_rules[rulews]() {
                                goto l25
                            }
                            {
                                position26, tokenIndex26 := position, tokenIndex
                                if !_rules[rulecomment]() {
                                    goto l26
                                }
                                goto l27
                            l26:
                                position, tokenIndex = position26, tokenIndex26
                            }
                        l27:
                            goto l24
                        l25:
                            position, tokenIndex = position25, tokenIndex25
                        }
                        add(rulePegText, position12)
                    }
                    {
                        add(ruleAction1, position)
                    }
                    goto l10
                l11:
                    position, tokenIndex = position10, tokenIndex10
                    if !_rules[rulews]() {
                        goto l29
                    }
                    if !_rules[rulekeyval]() {
                        goto l29
                    }
                    if !_rules[rulews]() {
                        goto l29
                    }
                    {
                        position30, tokenIndex30 := position, tokenIndex
                        if !_rules[rulecomment]() {
                            goto l30
                        }
                        goto l31
                    l30:
                        position, tokenIndex = position30, tokenIndex30
                    }
                l31:
                    goto l10
                l29:
                    position, tokenIndex = position10, tokenIndex10
                    if !_rules[rulews]() {
                        goto l32
                    }
                    {
                        position33, tokenIndex33 := position, tokenIndex
                        if !_rules[rulecomment]() {
                            goto l33
                        }
                        goto l34
                    l33:
                        position, tokenIndex = position33, tokenIndex33
                    }
                l34:
                    goto l10
                l32:
                    position, tokenIndex = position10, tokenIndex10
                    if !_rules[rulews]() {
                        goto l8
                    }
                }
            l10:
                add(ruleExpression, position9)
            }
            return true
        l8:
            position, tokenIndex = position8, tokenIndex8
            return false
        },
        /* 2 newline <- <(<('\r' / '\n')+> Action2)> */
        func() bool {
            position35, tokenIndex35 := position, tokenIndex
            {
                position36 := position
                {
                    position37 := position
                    {
                        position40, tokenIndex40 := position, tokenIndex
                        if buffer[position] != rune('\r') {
                            goto l41
                        }
                        position++
                        goto l40
                    l41:
                        position, tokenIndex = position40, tokenIndex40
                        if buffer[position] != rune('\n') {
                            goto l35
                        }
                        position++
                    }
                l40:
                l38:
                    {
                        position39, tokenIndex39 := position, tokenIndex
                        {
                            position42, tokenIndex42 := position, tokenIndex
                            if buffer[position] != rune('\r') {
                                goto l43
                            }
                            position++
                            goto l42
                        l43:
                            position, tokenIndex = position42, tokenIndex42
                            if buffer[position] != rune('\n') {
                                goto l39
                            }
                            position++
                        }
                    l42:
                        goto l38
                    l39:
                        position, tokenIndex = position39, tokenIndex39
                    }
                    add(rulePegText, position37)
                }
                {
                    add(ruleAction2, position)
                }
                add(rulenewline, position36)
            }
            return true
        l35:
            position, tokenIndex = position35, tokenIndex35
            return false
        },
        /* 3 ws <- <(' ' / '\t')*> */
        func() bool {
            {
                position46 := position
            l47:
                {
                    position48, tokenIndex48 := position, tokenIndex
                    {
                        position49, tokenIndex49 := position, tokenIndex
                        if buffer[position] != rune(' ') {
                            goto l50
                        }
                        position++
                        goto l49
                    l50:
                        position, tokenIndex = position49, tokenIndex49
                        if buffer[position] != rune('\t') {
                            goto l48
                        }
                        position++
                    }
                l49:
                    goto l47
                l48:
                    position, tokenIndex = position48, tokenIndex48
                }
                add(rulews, position46)
            }
            return true
        },
        /* 4 wsnl <- <((&('\t') '\t') | (&(' ') ' ') | (&('\n' | '\r') (<('\r' / '\n')> Action3)))*> */
        func() bool {
            {
                position52 := position
            l53:
                {
                    position54, tokenIndex54 := position, tokenIndex
                    {
                        switch buffer[position] {
                        case '\t':
                            if buffer[position] != rune('\t') {
                                goto l54
                            }
                            position++
                            break
                        case ' ':
                            if buffer[position] != rune(' ') {
                                goto l54
                            }
                            position++
                            break
                        default:
                            {
                                position56 := position
                                {
                                    position57, tokenIndex57 := position, tokenIndex
                                    if buffer[position] != rune('\r') {
                                        goto l58
                                    }
                                    position++
                                    goto l57
                                l58:
                                    position, tokenIndex = position57, tokenIndex57
                                    if buffer[position] != rune('\n') {
                                        goto l54
                                    }
                                    position++
                                }
                            l57:
                                add(rulePegText, position56)
                            }
                            {
                                add(ruleAction3, position)
                            }
                            break
                        }
                    }

                    goto l53
                l54:
                    position, tokenIndex = position54, tokenIndex54
                }
                add(rulewsnl, position52)
            }
            return true
        },
        /* 5 comment <- <('#' <('\t' / [ -\U0010ffff])*>)> */
        func() bool {
            position60, tokenIndex60 := position, tokenIndex
            {
                position61 := position
                if buffer[position] != rune('#') {
                    goto l60
                }
                position++
                {
                    position62 := position
                l63:
                    {
                        position64, tokenIndex64 := position, tokenIndex
                        {
                            position65, tokenIndex65 := position, tokenIndex
                            if buffer[position] != rune('\t') {
                                goto l66
                            }
                            position++
                            goto l65
                        l66:
                            position, tokenIndex = position65, tokenIndex65
                            if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
                                goto l64
                            }
                            position++
                        }
                    l65:
                        goto l63
                    l64:
                        position, tokenIndex = position64, tokenIndex64
                    }
                    add(rulePegText, position62)
                }
                add(rulecomment, position61)
            }
            return true
        l60:
            position, tokenIndex = position60, tokenIndex60
            return false
        },
        /* 6 keyval <- <(key ws '=' ws val Action4)> */
        func() bool {
            position67, tokenIndex67 := position, tokenIndex
            {
                position68 := position
                if !_rules[rulekey]() {
                    goto l67
                }
                if !_rules[rulews]() {
                    goto l67
                }
                if buffer[position] != rune('=') {
                    goto l67
                }
                position++
                if !_rules[rulews]() {
                    goto l67
                }
                if !_rules[ruleval]() {
                    goto l67
                }
                {
                    add(ruleAction4, position)
                }
                add(rulekeyval, position68)
            }
            return true
        l67:
            position, tokenIndex = position67, tokenIndex67
            return false
        },
        /* 7 key <- <(bareKey / quotedKey)> */
        func() bool {
            position70, tokenIndex70 := position, tokenIndex
            {
                position71 := position
                {
                    position72, tokenIndex72 := position, tokenIndex
                    {
                        position74 := position
                        {
                            position75 := position
                            {
                                switch buffer[position] {
                                case '_':
                                    if buffer[position] != rune('_') {
                                        goto l73
                                    }
                                    position++
                                    break
                                case '-':
                                    if buffer[position] != rune('-') {
                                        goto l73
                                    }
                                    position++
                                    break
                                case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
                                    if c := buffer[position]; c < rune('a') || c > rune('z') {
                                        goto l73
                                    }
                                    position++
                                    break
                                case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
                                    if c := buffer[position]; c < rune('0') || c > rune('9') {
                                        goto l73
                                    }
                                    position++
                                    break
                                default:
                                    if c := buffer[position]; c < rune('A') || c > rune('Z') {
                                        goto l73
                                    }
                                    position++
                                    break
                                }
                            }

                        l76:
                            {
                                position77, tokenIndex77 := position, tokenIndex
                                {
                                    switch buffer[position] {
                                    case '_':
                                        if buffer[position] != rune('_') {
                                            goto l77
                                        }
                                        position++
                                        break
                                    case '-':
                                        if buffer[position] != rune('-') {
                                            goto l77
                                        }
                                        position++
                                        break
                                    case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
                                        if c := buffer[position]; c < rune('a') || c > rune('z') {
                                            goto l77
                                        }
                                        position++
                                        break
                                    case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
                                        if c := buffer[position]; c < rune('0') || c > rune('9') {
                                            goto l77
                                        }
                                        position++
                                        break
                                    default:
                                        if c := buffer[position]; c < rune('A') || c > rune('Z') {
                                            goto l77
                                        }
                                        position++
                                        break
                                    }
                                }

                                goto l76
                            l77:
                                position, tokenIndex = position77, tokenIndex77
                            }
                            add(rulePegText, position75)
                        }
                        {
                            add(ruleAction5, position)
                        }
                        add(rulebareKey, position74)
                    }
                    goto l72
                l73:
                    position, tokenIndex = position72, tokenIndex72
                    {
                        position81 := position
                        {
                            position82 := position
                            if buffer[position] != rune('"') {
                                goto l70
                            }
                            position++
                        l83:
                            {
                                position84, tokenIndex84 := position, tokenIndex
                                if !_rules[rulebasicChar]() {
                                    goto l84
                                }
                                goto l83
                            l84:
                                position, tokenIndex = position84, tokenIndex84
                            }
                            if buffer[position] != rune('"') {
                                goto l70
                            }
                            position++
                            add(rulePegText, position82)
                        }
                        {
                            add(ruleAction6, position)
                        }
                        add(rulequotedKey, position81)
                    }
                }
            l72:
                add(rulekey, position71)
            }
            return true
        l70:
            position, tokenIndex = position70, tokenIndex70
            return false
        },
        /* 8 bareKey <- <(<((&('_') '_') | (&('-') '-') | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') [a-z]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z') [A-Z]))+> Action5)> */
        nil,
        /* 9 quotedKey <- <(<('"' basicChar* '"')> Action6)> */
        nil,
        /* 10 val <- <((<datetime> Action7) / (<float> Action8) / ((&('{') inlineTable) | (&('[') (<array> Action12)) | (&('f' | 't') (<boolean> Action11)) | (&('"' | '\'') (<string> Action10)) | (&('+' | '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') (<integer> Action9))))> */
        func() bool {
            position88, tokenIndex88 := position, tokenIndex
            {
                position89 := position
                {
                    position90, tokenIndex90 := position, tokenIndex
                    {
                        position92 := position
                        {
                            position93 := position
                            {
                                position94, tokenIndex94 := position, tokenIndex
                                {
                                    position96 := position
                                    {
                                        position97 := position
                                        {
                                            position98 := position
                                            if !_rules[ruledigitDual]() {
                                                goto l95
                                            }
                                            if !_rules[ruledigitDual]() {
                                                goto l95
                                            }
                                            add(ruledigitQuad, position98)
                                        }
                                        add(ruledateFullYear, position97)
                                    }
                                    if buffer[position] != rune('-') {
                                        goto l95
                                    }
                                    position++
                                    {
                                        position99 := position
                                        if !_rules[ruledigitDual]() {
                                            goto l95
                                        }
                                        add(ruledateMonth, position99)
                                    }
                                    if buffer[position] != rune('-') {
                                        goto l95
                                    }
                                    position++
                                    {
                                        position100 := position
                                        if !_rules[ruledigitDual]() {
                                            goto l95
                                        }
                                        add(ruledateMDay, position100)
                                    }
                                    add(rulefullDate, position96)
                                }
                                {
                                    position101, tokenIndex101 := position, tokenIndex
                                    if buffer[position] != rune('T') {
                                        goto l101
                                    }
                                    position++
                                    {
                                        position103 := position
                                        if !_rules[rulepartialTime]() {
                                            goto l101
                                        }
                                        {
                                            position104, tokenIndex104 := position, tokenIndex
                                            {
                                                position106 := position
                                                {
                                                    position107, tokenIndex107 := position, tokenIndex
                                                    if buffer[position] != rune('Z') {
                                                        goto l108
                                                    }
                                                    position++
                                                    goto l107
                                                l108:
                                                    position, tokenIndex = position107, tokenIndex107
                                                    {
                                                        position109 := position
                                                        {
                                                            position110, tokenIndex110 := position, tokenIndex
                                                            if buffer[position] != rune('-') {
                                                                goto l111
                                                            }
                                                            position++
                                                            goto l110
                                                        l111:
                                                            position, tokenIndex = position110, tokenIndex110
                                                            if buffer[position] != rune('+') {
                                                                goto l104
                                                            }
                                                            position++
                                                        }
                                                    l110:
                                                        if !_rules[ruletimeHour]() {
                                                            goto l104
                                                        }
                                                        if buffer[position] != rune(':') {
                                                            goto l104
                                                        }
                                                        position++
                                                        if !_rules[ruletimeMinute]() {
                                                            goto l104
                                                        }
                                                        add(ruletimeNumoffset, position109)
                                                    }
                                                }
                                            l107:
                                                add(ruletimeOffset, position106)
                                            }
                                            goto l105
                                        l104:
                                            position, tokenIndex = position104, tokenIndex104
                                        }
                                    l105:
                                        add(rulefullTime, position103)
                                    }
                                    goto l102
                                l101:
                                    position, tokenIndex = position101, tokenIndex101
                                }
                            l102:
                                goto l94
                            l95:
                                position, tokenIndex = position94, tokenIndex94
                                if !_rules[rulepartialTime]() {
                                    goto l91
                                }
                            }
                        l94:
                            add(ruledatetime, position93)
                        }
                        add(rulePegText, position92)
                    }
                    {
                        add(ruleAction7, position)
                    }
                    goto l90
                l91:
                    position, tokenIndex = position90, tokenIndex90
                    {
                        position114 := position
                        {
                            position115 := position
                            if !_rules[ruleinteger]() {
                                goto l113
                            }
                            {
                                position116, tokenIndex116 := position, tokenIndex
                                if !_rules[rulefrac]() {
                                    goto l117
                                }
                                {
                                    position118, tokenIndex118 := position, tokenIndex
                                    if !_rules[ruleexp]() {
                                        goto l118
                                    }
                                    goto l119
                                l118:
                                    position, tokenIndex = position118, tokenIndex118
                                }
                            l119:
                                goto l116
                            l117:
                                position, tokenIndex = position116, tokenIndex116
                                {
                                    position120, tokenIndex120 := position, tokenIndex
                                    if !_rules[rulefrac]() {
                                        goto l120
                                    }
                                    goto l121
                                l120:
                                    position, tokenIndex = position120, tokenIndex120
                                }
                            l121:
                                if !_rules[ruleexp]() {
                                    goto l113
                                }
                            }
                        l116:
                            add(rulefloat, position115)
                        }
                        add(rulePegText, position114)
                    }
                    {
                        add(ruleAction8, position)
                    }
                    goto l90
                l113:
                    position, tokenIndex = position90, tokenIndex90
                    {
                        switch buffer[position] {
                        case '{':
                            {
                                position124 := position
                                if buffer[position] != rune('{') {
                                    goto l88
                                }
                                position++
                                {
                                    add(ruleAction15, position)
                                }
                                if !_rules[rulews]() {
                                    goto l88
                                }
                                {
                                    position126 := position
                                l127:
                                    {
                                        position128, tokenIndex128 := position, tokenIndex
                                        if !_rules[rulekeyval]() {
                                            goto l128
                                        }
                                        {
                                            position129, tokenIndex129 := position, tokenIndex
                                            {
                                                position131 := position
                                                if !_rules[rulews]() {
                                                    goto l129
                                                }
                                                if buffer[position] != rune(',') {
                                                    goto l129
                                                }
                                                position++
                                                if !_rules[rulews]() {
                                                    goto l129
                                                }
                                                add(ruleinlineTableValSep, position131)
                                            }
                                            goto l130
                                        l129:
                                            position, tokenIndex = position129, tokenIndex129
                                        }
                                    l130:
                                        goto l127
                                    l128:
                                        position, tokenIndex = position128, tokenIndex128
                                    }
                                    add(ruleinlineTableKeyValues, position126)
                                }
                                if !_rules[rulews]() {
                                    goto l88
                                }
                                if buffer[position] != rune('}') {
                                    goto l88
                                }
                                position++
                                {
                                    add(ruleAction16, position)
                                }
                                add(ruleinlineTable, position124)
                            }
                            break
                        case '[':
                            {
                                position133 := position
                                {
                                    position134 := position
                                    if buffer[position] != rune('[') {
                                        goto l88
                                    }
                                    position++
                                    {
                                        add(ruleAction23, position)
                                    }
                                    if !_rules[rulewsnl]() {
                                        goto l88
                                    }
                                    {
                                        position136, tokenIndex136 := position, tokenIndex
                                        {
                                            position138 := position
                                            if !_rules[ruleval]() {
                                                goto l136
                                            }
                                            {
                                                add(ruleAction24, position)
                                            }
                                        l140:
                                            {
                                                position141, tokenIndex141 := position, tokenIndex
                                                if !_rules[rulewsnl]() {
                                                    goto l141
                                                }
                                                {
                                                    position142, tokenIndex142 := position, tokenIndex
                                                    if !_rules[rulecomment]() {
                                                        goto l142
                                                    }
                                                    goto l143
                                                l142:
                                                    position, tokenIndex = position142, tokenIndex142
                                                }
                                            l143:
                                                if !_rules[rulewsnl]() {
                                                    goto l141
                                                }
                                                if !_rules[rulearraySep]() {
                                                    goto l141
                                                }
                                                if !_rules[rulewsnl]() {
                                                    goto l141
                                                }
                                                {
                                                    position144, tokenIndex144 := position, tokenIndex
                                                    if !_rules[rulecomment]() {
                                                        goto l144
                                                    }
                                                    goto l145
                                                l144:
                                                    position, tokenIndex = position144, tokenIndex144
                                                }
                                            l145:
                                                if !_rules[rulewsnl]() {
                                                    goto l141
                                                }
                                                if !_rules[ruleval]() {
                                                    goto l141
                                                }
                                                {
                                                    add(ruleAction25, position)
                                                }
                                                goto l140
                                            l141:
                                                position, tokenIndex = position141, tokenIndex141
                                            }
                                            if !_rules[rulewsnl]() {
                                                goto l136
                                            }
                                            {
                                                position147, tokenIndex147 := position, tokenIndex
                                                if !_rules[rulearraySep]() {
                                                    goto l147
                                                }
                                                goto l148
                                            l147:
                                                position, tokenIndex = position147, tokenIndex147
                                            }
                                        l148:
                                            if !_rules[rulewsnl]() {
                                                goto l136
                                            }
                                            {
                                                position149, tokenIndex149 := position, tokenIndex
                                                if !_rules[rulecomment]() {
                                                    goto l149
                                                }
                                                goto l150
                                            l149:
                                                position, tokenIndex = position149, tokenIndex149
                                            }
                                        l150:
                                            add(rulearrayValues, position138)
                                        }
                                        goto l137
                                    l136:
                                        position, tokenIndex = position136, tokenIndex136
                                    }
                                l137:
                                    if !_rules[rulewsnl]() {
                                        goto l88
                                    }
                                    if buffer[position] != rune(']') {
                                        goto l88
                                    }
                                    position++
                                    add(rulearray, position134)
                                }
                                add(rulePegText, position133)
                            }
                            {
                                add(ruleAction12, position)
                            }
                            break
                        case 'f', 't':
                            {
                                position152 := position
                                {
                                    position153 := position
                                    {
                                        position154, tokenIndex154 := position, tokenIndex
                                        if buffer[position] != rune('t') {
                                            goto l155
                                        }
                                        position++
                                        if buffer[position] != rune('r') {
                                            goto l155
                                        }
                                        position++
                                        if buffer[position] != rune('u') {
                                            goto l155
                                        }
                                        position++
                                        if buffer[position] != rune('e') {
                                            goto l155
                                        }
                                        position++
                                        goto l154
                                    l155:
                                        position, tokenIndex = position154, tokenIndex154
                                        if buffer[position] != rune('f') {
                                            goto l88
                                        }
                                        position++
                                        if buffer[position] != rune('a') {
                                            goto l88
                                        }
                                        position++
                                        if buffer[position] != rune('l') {
                                            goto l88
                                        }
                                        position++
                                        if buffer[position] != rune('s') {
                                            goto l88
                                        }
                                        position++
                                        if buffer[position] != rune('e') {
                                            goto l88
                                        }
                                        position++
                                    }
                                l154:
                                    add(ruleboolean, position153)
                                }
                                add(rulePegText, position152)
                            }
                            {
                                add(ruleAction11, position)
                            }
                            break
                        case '"', '\'':
                            {
                                position157 := position
                                {
                                    position158 := position
                                    {
                                        position159, tokenIndex159 := position, tokenIndex
                                        {
                                            position161 := position
                                            if buffer[position] != rune('\'') {
                                                goto l160
                                            }
                                            position++
                                            if buffer[position] != rune('\'') {
                                                goto l160
                                            }
                                            position++
                                            if buffer[position] != rune('\'') {
                                                goto l160
                                            }
                                            position++
                                            {
                                                position162 := position
                                                {
                                                    position163 := position
                                                l164:
                                                    {
                                                        position165, tokenIndex165 := position, tokenIndex
                                                        {
                                                            position166, tokenIndex166 := position, tokenIndex
                                                            if buffer[position] != rune('\'') {
                                                                goto l166
                                                            }
                                                            position++
                                                            if buffer[position] != rune('\'') {
                                                                goto l166
                                                            }
                                                            position++
                                                            if buffer[position] != rune('\'') {
                                                                goto l166
                                                            }
                                                            position++
                                                            goto l165
                                                        l166:
                                                            position, tokenIndex = position166, tokenIndex166
                                                        }
                                                        {
                                                            position167, tokenIndex167 := position, tokenIndex
                                                            {
                                                                position169 := position
                                                                {
                                                                    position170, tokenIndex170 := position, tokenIndex
                                                                    if buffer[position] != rune('\t') {
                                                                        goto l171
                                                                    }
                                                                    position++
                                                                    goto l170
                                                                l171:
                                                                    position, tokenIndex = position170, tokenIndex170
                                                                    if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
                                                                        goto l168
                                                                    }
                                                                    position++
                                                                }
                                                            l170:
                                                                add(rulemlLiteralChar, position169)
                                                            }
                                                            goto l167
                                                        l168:
                                                            position, tokenIndex = position167, tokenIndex167
                                                            if !_rules[rulenewline]() {
                                                                goto l165
                                                            }
                                                        }
                                                    l167:
                                                        goto l164
                                                    l165:
                                                        position, tokenIndex = position165, tokenIndex165
                                                    }
                                                    add(rulemlLiteralBody, position163)
                                                }
                                                add(rulePegText, position162)
                                            }
                                            if buffer[position] != rune('\'') {
                                                goto l160
                                            }
                                            position++
                                            if buffer[position] != rune('\'') {
                                                goto l160
                                            }
                                            position++
                                            if buffer[position] != rune('\'') {
                                                goto l160
                                            }
                                            position++
                                            {
                                                add(ruleAction22, position)
                                            }
                                            add(rulemlLiteralString, position161)
                                        }
                                        goto l159
                                    l160:
                                        position, tokenIndex = position159, tokenIndex159
                                        {
                                            position174 := position
                                            if buffer[position] != rune('\'') {
                                                goto l173
                                            }
                                            position++
                                            {
                                                position175 := position
                                            l176:
                                                {
                                                    position177, tokenIndex177 := position, tokenIndex
                                                    {
                                                        position178 := position
                                                        {
                                                            switch buffer[position] {
                                                            case '\t':
                                                                if buffer[position] != rune('\t') {
                                                                    goto l177
                                                                }
                                                                position++
                                                                break
                                                            case ' ', '!', '"', '#', '$', '%', '&':
                                                                if c := buffer[position]; c < rune(' ') || c > rune('&') {
                                                                    goto l177
                                                                }
                                                                position++
                                                                break
                                                            default:
                                                                if c := buffer[position]; c < rune('(') || c > rune('\U0010ffff') {
                                                                    goto l177
                                                                }
                                                                position++
                                                                break
                                                            }
                                                        }

                                                        add(ruleliteralChar, position178)
                                                    }
                                                    goto l176
                                                l177:
                                                    position, tokenIndex = position177, tokenIndex177
                                                }
                                                add(rulePegText, position175)
                                            }
                                            if buffer[position] != rune('\'') {
                                                goto l173
                                            }
                                            position++
                                            {
                                                add(ruleAction21, position)
                                            }
                                            add(ruleliteralString, position174)
                                        }
                                        goto l159
                                    l173:
                                        position, tokenIndex = position159, tokenIndex159
                                        {
                                            position182 := position
                                            if buffer[position] != rune('"') {
                                                goto l181
                                            }
                                            position++
                                            if buffer[position] != rune('"') {
                                                goto l181
                                            }
                                            position++
                                            if buffer[position] != rune('"') {
                                                goto l181
                                            }
                                            position++
                                            {
                                                position183 := position
                                            l184:
                                                {
                                                    position185, tokenIndex185 := position, tokenIndex
                                                    {
                                                        position186, tokenIndex186 := position, tokenIndex
                                                        {
                                                            position188 := position
                                                            {
                                                                position189, tokenIndex189 := position, tokenIndex
                                                                if !_rules[rulebasicChar]() {
                                                                    goto l190
                                                                }
                                                                goto l189
                                                            l190:
                                                                position, tokenIndex = position189, tokenIndex189
                                                                if !_rules[rulenewline]() {
                                                                    goto l187
                                                                }
                                                            }
                                                        l189:
                                                            add(rulePegText, position188)
                                                        }
                                                        {
                                                            add(ruleAction20, position)
                                                        }
                                                        goto l186
                                                    l187:
                                                        position, tokenIndex = position186, tokenIndex186
                                                        if !_rules[ruleescape]() {
                                                            goto l185
                                                        }
                                                        if !_rules[rulenewline]() {
                                                            goto l185
                                                        }
                                                        if !_rules[rulewsnl]() {
                                                            goto l185
                                                        }
                                                    }
                                                l186:
                                                    goto l184
                                                l185:
                                                    position, tokenIndex = position185, tokenIndex185
                                                }
                                                add(rulemlBasicBody, position183)
                                            }
                                            if buffer[position] != rune('"') {
                                                goto l181
                                            }
                                            position++
                                            if buffer[position] != rune('"') {
                                                goto l181
                                            }
                                            position++
                                            if buffer[position] != rune('"') {
                                                goto l181
                                            }
                                            position++
                                            {
                                                add(ruleAction19, position)
                                            }
                                            add(rulemlBasicString, position182)
                                        }
                                        goto l159
                                    l181:
                                        position, tokenIndex = position159, tokenIndex159
                                        {
                                            position193 := position
                                            {
                                                position194 := position
                                                if buffer[position] != rune('"') {
                                                    goto l88
                                                }
                                                position++
                                            l195:
                                                {
                                                    position196, tokenIndex196 := position, tokenIndex
                                                    if !_rules[rulebasicChar]() {
                                                        goto l196
                                                    }
                                                    goto l195
                                                l196:
                                                    position, tokenIndex = position196, tokenIndex196
                                                }
                                                if buffer[position] != rune('"') {
                                                    goto l88
                                                }
                                                position++
                                                add(rulePegText, position194)
                                            }
                                            {
                                                add(ruleAction18, position)
                                            }
                                            add(rulebasicString, position193)
                                        }
                                    }
                                l159:
                                    add(rulestring, position158)
                                }
                                add(rulePegText, position157)
                            }
                            {
                                add(ruleAction10, position)
                            }
                            break
                        default:
                            {
                                position199 := position
                                if !_rules[ruleinteger]() {
                                    goto l88
                                }
                                add(rulePegText, position199)
                            }
                            {
                                add(ruleAction9, position)
                            }
                            break
                        }
                    }

                }
            l90:
                add(ruleval, position89)
            }
            return true
        l88:
            position, tokenIndex = position88, tokenIndex88
            return false
        },
        /* 11 table <- <(stdTable / arrayTable)> */
        nil,
        /* 12 stdTable <- <('[' ws <tableKey> ws ']' Action13)> */
        nil,
        /* 13 arrayTable <- <('[' '[' ws <tableKey> ws (']' ']') Action14)> */
        nil,
        /* 14 inlineTable <- <('{' Action15 ws inlineTableKeyValues ws '}' Action16)> */
        nil,
        /* 15 inlineTableKeyValues <- <(keyval inlineTableValSep?)*> */
        nil,
        /* 16 tableKey <- <(tableKeyComp (tableKeySep tableKeyComp)*)> */
        func() bool {
            position206, tokenIndex206 := position, tokenIndex
            {
                position207 := position
                if !_rules[ruletableKeyComp]() {
                    goto l206
                }
            l208:
                {
                    position209, tokenIndex209 := position, tokenIndex
                    {
                        position210 := position
                        if !_rules[rulews]() {
                            goto l209
                        }
                        if buffer[position] != rune('.') {
                            goto l209
                        }
                        position++
                        if !_rules[rulews]() {
                            goto l209
                        }
                        add(ruletableKeySep, position210)
                    }
                    if !_rules[ruletableKeyComp]() {
                        goto l209
                    }
                    goto l208
                l209:
                    position, tokenIndex = position209, tokenIndex209
                }
                add(ruletableKey, position207)
            }
            return true
        l206:
            position, tokenIndex = position206, tokenIndex206
            return false
        },
        /* 17 tableKeyComp <- <(key Action17)> */
        func() bool {
            position211, tokenIndex211 := position, tokenIndex
            {
                position212 := position
                if !_rules[rulekey]() {
                    goto l211
                }
                {
                    add(ruleAction17, position)
                }
                add(ruletableKeyComp, position212)
            }
            return true
        l211:
            position, tokenIndex = position211, tokenIndex211
            return false
        },
        /* 18 tableKeySep <- <(ws '.' ws)> */
        nil,
        /* 19 inlineTableValSep <- <(ws ',' ws)> */
        nil,
        /* 20 integer <- <(('-' / '+')? int)> */
        func() bool {
            position216, tokenIndex216 := position, tokenIndex
            {
                position217 := position
                {
                    position218, tokenIndex218 := position, tokenIndex
                    {
                        position220, tokenIndex220 := position, tokenIndex
                        if buffer[position] != rune('-') {
                            goto l221
                        }
                        position++
                        goto l220
                    l221:
                        position, tokenIndex = position220, tokenIndex220
                        if buffer[position] != rune('+') {
                            goto l218
                        }
                        position++
                    }
                l220:
                    goto l219
                l218:
                    position, tokenIndex = position218, tokenIndex218
                }
            l219:
                {
                    position222 := position
                    {
                        position223, tokenIndex223 := position, tokenIndex
                        if c := buffer[position]; c < rune('1') || c > rune('9') {
                            goto l224
                        }
                        position++
                        {
                            position227, tokenIndex227 := position, tokenIndex
                            if !_rules[ruledigit]() {
                                goto l228
                            }
                            goto l227
                        l228:
                            position, tokenIndex = position227, tokenIndex227
                            if buffer[position] != rune('_') {
                                goto l224
                            }
                            position++
                            if !_rules[ruledigit]() {
                                goto l224
                            }
                        }
                    l227:
                    l225:
                        {
                            position226, tokenIndex226 := position, tokenIndex
                            {
                                position229, tokenIndex229 := position, tokenIndex
                                if !_rules[ruledigit]() {
                                    goto l230
                                }
                                goto l229
                            l230:
                                position, tokenIndex = position229, tokenIndex229
                                if buffer[position] != rune('_') {
                                    goto l226
                                }
                                position++
                                if !_rules[ruledigit]() {
                                    goto l226
                                }
                            }
                        l229:
                            goto l225
                        l226:
                            position, tokenIndex = position226, tokenIndex226
                        }
                        goto l223
                    l224:
                        position, tokenIndex = position223, tokenIndex223
                        if !_rules[ruledigit]() {
                            goto l216
                        }
                    }
                l223:
                    add(ruleint, position222)
                }
                add(ruleinteger, position217)
            }
            return true
        l216:
            position, tokenIndex = position216, tokenIndex216
            return false
        },
        /* 21 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
        nil,
        /* 22 float <- <(integer ((frac exp?) / (frac? exp)))> */
        nil,
        /* 23 frac <- <('.' digit (digit / ('_' digit))*)> */
        func() bool {
            position233, tokenIndex233 := position, tokenIndex
            {
                position234 := position
                if buffer[position] != rune('.') {
                    goto l233
                }
                position++
                if !_rules[ruledigit]() {
                    goto l233
                }
            l235:
                {
                    position236, tokenIndex236 := position, tokenIndex
                    {
                        position237, tokenIndex237 := position, tokenIndex
                        if !_rules[ruledigit]() {
                            goto l238
                        }
                        goto l237
                    l238:
                        position, tokenIndex = position237, tokenIndex237
                        if buffer[position] != rune('_') {
                            goto l236
                        }
                        position++
                        if !_rules[ruledigit]() {
                            goto l236
                        }
                    }
                l237:
                    goto l235
                l236:
                    position, tokenIndex = position236, tokenIndex236
                }
                add(rulefrac, position234)
            }
            return true
        l233:
            position, tokenIndex = position233, tokenIndex233
            return false
        },
        /* 24 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
        func() bool {
            position239, tokenIndex239 := position, tokenIndex
            {
                position240 := position
                {
                    position241, tokenIndex241 := position, tokenIndex
                    if buffer[position] != rune('e') {
                        goto l242
                    }
                    position++
                    goto l241
                l242:
                    position, tokenIndex = position241, tokenIndex241
                    if buffer[position] != rune('E') {
                        goto l239
                    }
                    position++
                }
            l241:
                {
                    position243, tokenIndex243 := position, tokenIndex
                    {
                        position245, tokenIndex245 := position, tokenIndex
                        if buffer[position] != rune('-') {
                            goto l246
                        }
                        position++
                        goto l245
                    l246:
                        position, tokenIndex = position245, tokenIndex245
                        if buffer[position] != rune('+') {
                            goto l243
                        }
                        position++
                    }
                l245:
                    goto l244
                l243:
                    position, tokenIndex = position243, tokenIndex243
                }
            l244:
                if !_rules[ruledigit]() {
                    goto l239
                }
            l247:
                {
                    position248, tokenIndex248 := position, tokenIndex
                    {
                        position249, tokenIndex249 := position, tokenIndex
                        if !_rules[ruledigit]() {
                            goto l250
                        }
                        goto l249
                    l250:
                        position, tokenIndex = position249, tokenIndex249
                        if buffer[position] != rune('_') {
                            goto l248
                        }
                        position++
                        if !_rules[ruledigit]() {
                            goto l248
                        }
                    }
                l249:
                    goto l247
                l248:
                    position, tokenIndex = position248, tokenIndex248
                }
                add(ruleexp, position240)
            }
            return true
        l239:
            position, tokenIndex = position239, tokenIndex239
            return false
        },
        /* 25 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
        nil,
        /* 26 basicString <- <(<('"' basicChar* '"')> Action18)> */
        nil,
        /* 27 basicChar <- <(basicUnescaped / escaped)> */
        func() bool {
            position253, tokenIndex253 := position, tokenIndex
            {
                position254 := position
                {
                    position255, tokenIndex255 := position, tokenIndex
                    {
                        position257 := position
                        {
                            switch buffer[position] {
                            case ' ', '!':
                                if c := buffer[position]; c < rune(' ') || c > rune('!') {
                                    goto l256
                                }
                                position++
                                break
                            case '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[':
                                if c := buffer[position]; c < rune('#') || c > rune('[') {
                                    goto l256
                                }
                                position++
                                break
                            default:
                                if c := buffer[position]; c < rune(']') || c > rune('\U0010ffff') {
                                    goto l256
                                }
                                position++
                                break
                            }
                        }

                        add(rulebasicUnescaped, position257)
                    }
                    goto l255
                l256:
                    position, tokenIndex = position255, tokenIndex255
                    {
                        position259 := position
                        if !_rules[ruleescape]() {
                            goto l253
                        }
                        {
                            switch buffer[position] {
                            case 'U':
                                if buffer[position] != rune('U') {
                                    goto l253
                                }
                                position++
                                if !_rules[rulehexQuad]() {
                                    goto l253
                                }
                                if !_rules[rulehexQuad]() {
                                    goto l253
                                }
                                break
                            case 'u':
                                if buffer[position] != rune('u') {
                                    goto l253
                                }
                                position++
                                if !_rules[rulehexQuad]() {
                                    goto l253
                                }
                                break
                            case '\\':
                                if buffer[position] != rune('\\') {
                                    goto l253
                                }
                                position++
                                break
                            case '/':
                                if buffer[position] != rune('/') {
                                    goto l253
                                }
                                position++
                                break
                            case '"':
                                if buffer[position] != rune('"') {
                                    goto l253
                                }
                                position++
                                break
                            case 'r':
                                if buffer[position] != rune('r') {
                                    goto l253
                                }
                                position++
                                break
                            case 'f':
                                if buffer[position] != rune('f') {
                                    goto l253
                                }
                                position++
                                break
                            case 'n':
                                if buffer[position] != rune('n') {
                                    goto l253
                                }
                                position++
                                break
                            case 't':
                                if buffer[position] != rune('t') {
                                    goto l253
                                }
                                position++
                                break
                            default:
                                if buffer[position] != rune('b') {
                                    goto l253
                                }
                                position++
                                break
                            }
                        }

                        add(ruleescaped, position259)
                    }
                }
            l255:
                add(rulebasicChar, position254)
            }
            return true
        l253:
            position, tokenIndex = position253, tokenIndex253
            return false
        },
        /* 28 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
        nil,
        /* 29 basicUnescaped <- <((&(' ' | '!') [ -!]) | (&('#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[') [#-[]) | (&(']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') []-\U0010ffff]))> */
        nil,
        /* 30 escape <- <'\\'> */
        func() bool {
            position263, tokenIndex263 := position, tokenIndex
            {
                position264 := position
                if buffer[position] != rune('\\') {
                    goto l263
                }
                position++
                add(ruleescape, position264)
            }
            return true
        l263:
            position, tokenIndex = position263, tokenIndex263
            return false
        },
        /* 31 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action19)> */
        nil,
        /* 32 mlBasicBody <- <((<(basicChar / newline)> Action20) / (escape newline wsnl))*> */
        nil,
        /* 33 literalString <- <('\'' <literalChar*> '\'' Action21)> */
        nil,
        /* 34 literalChar <- <((&('\t') '\t') | (&(' ' | '!' | '"' | '#' | '$' | '%' | '&') [ -&]) | (&('(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') [(-\U0010ffff]))> */
        nil,
        /* 35 mlLiteralString <- <('\'' '\'' '\'' <mlLiteralBody> ('\'' '\'' '\'') Action22)> */
        nil,
        /* 36 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
        nil,
        /* 37 mlLiteralChar <- <('\t' / [ -\U0010ffff])> */
        nil,
        /* 38 hexdigit <- <((&('a' | 'b' | 'c' | 'd' | 'e' | 'f') [a-f]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F') [A-F]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]))> */
        func() bool {
            position272, tokenIndex272 := position, tokenIndex
            {
                position273 := position
                {
                    switch buffer[position] {
                    case 'a', 'b', 'c', 'd', 'e', 'f':
                        if c := buffer[position]; c < rune('a') || c > rune('f') {
                            goto l272
                        }
                        position++
                        break
                    case 'A', 'B', 'C', 'D', 'E', 'F':
                        if c := buffer[position]; c < rune('A') || c > rune('F') {
                            goto l272
                        }
                        position++
                        break
                    default:
                        if c := buffer[position]; c < rune('0') || c > rune('9') {
                            goto l272
                        }
                        position++
                        break
                    }
                }

                add(rulehexdigit, position273)
            }
            return true
        l272:
            position, tokenIndex = position272, tokenIndex272
            return false
        },
        /* 39 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
        func() bool {
            position275, tokenIndex275 := position, tokenIndex
            {
                position276 := position
                if !_rules[rulehexdigit]() {
                    goto l275
                }
                if !_rules[rulehexdigit]() {
                    goto l275
                }
                if !_rules[rulehexdigit]() {
                    goto l275
                }
                if !_rules[rulehexdigit]() {
                    goto l275
                }
                add(rulehexQuad, position276)
            }
            return true
        l275:
            position, tokenIndex = position275, tokenIndex275
            return false
        },
        /* 40 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
        nil,
        /* 41 dateFullYear <- <digitQuad> */
        nil,
        /* 42 dateMonth <- <digitDual> */
        nil,
        /* 43 dateMDay <- <digitDual> */
        nil,
        /* 44 timeHour <- <digitDual> */
        func() bool {
            position281, tokenIndex281 := position, tokenIndex
            {
                position282 := position
                if !_rules[ruledigitDual]() {
                    goto l281
                }
                add(ruletimeHour, position282)
            }
            return true
        l281:
            position, tokenIndex = position281, tokenIndex281
            return false
        },
        /* 45 timeMinute <- <digitDual> */
        func() bool {
            position283, tokenIndex283 := position, tokenIndex
            {
                position284 := position
                if !_rules[ruledigitDual]() {
                    goto l283
                }
                add(ruletimeMinute, position284)
            }
            return true
        l283:
            position, tokenIndex = position283, tokenIndex283
            return false
        },
        /* 46 timeSecond <- <digitDual> */
        nil,
        /* 47 timeSecfrac <- <('.' digit+)> */
        nil,
        /* 48 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
        nil,
        /* 49 timeOffset <- <('Z' / timeNumoffset)> */
        nil,
        /* 50 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
        func() bool {
            position289, tokenIndex289 := position, tokenIndex
            {
                position290 := position
                if !_rules[ruletimeHour]() {
                    goto l289
                }
                if buffer[position] != rune(':') {
                    goto l289
                }
                position++
                if !_rules[ruletimeMinute]() {
                    goto l289
                }
                if buffer[position] != rune(':') {
                    goto l289
                }
                position++
                {
                    position291 := position
                    if !_rules[ruledigitDual]() {
                        goto l289
                    }
                    add(ruletimeSecond, position291)
                }
                {
                    position292, tokenIndex292 := position, tokenIndex
                    {
                        position294 := position
                        if buffer[position] != rune('.') {
                            goto l292
                        }
                        position++
                        if !_rules[ruledigit]() {
                            goto l292
                        }
                    l295:
                        {
                            position296, tokenIndex296 := position, tokenIndex
                            if !_rules[ruledigit]() {
                                goto l296
                            }
                            goto l295
                        l296:
                            position, tokenIndex = position296, tokenIndex296
                        }
                        add(ruletimeSecfrac, position294)
                    }
                    goto l293
                l292:
                    position, tokenIndex = position292, tokenIndex292
                }
            l293:
                add(rulepartialTime, position290)
            }
            return true
        l289:
            position, tokenIndex = position289, tokenIndex289
            return false
        },
        /* 51 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
        nil,
        /* 52 fullTime <- <(partialTime timeOffset?)> */
        nil,
        /* 53 datetime <- <((fullDate ('T' fullTime)?) / partialTime)> */
        nil,
        /* 54 digit <- <[0-9]> */
        func() bool {
            position300, tokenIndex300 := position, tokenIndex
            {
                position301 := position
                if c := buffer[position]; c < rune('0') || c > rune('9') {
                    goto l300
                }
                position++
                add(ruledigit, position301)
            }
            return true
        l300:
            position, tokenIndex = position300, tokenIndex300
            return false
        },
        /* 55 digitDual <- <(digit digit)> */
        func() bool {
            position302, tokenIndex302 := position, tokenIndex
            {
                position303 := position
                if !_rules[ruledigit]() {
                    goto l302
                }
                if !_rules[ruledigit]() {
                    goto l302
                }
                add(ruledigitDual, position303)
            }
            return true
        l302:
            position, tokenIndex = position302, tokenIndex302
            return false
        },
        /* 56 digitQuad <- <(digitDual digitDual)> */
        nil,
        /* 57 array <- <('[' Action23 wsnl arrayValues? wsnl ']')> */
        nil,
        /* 58 arrayValues <- <(val Action24 (wsnl comment? wsnl arraySep wsnl comment? wsnl val Action25)* wsnl arraySep? wsnl comment?)> */
        nil,
        /* 59 arraySep <- <','> */
        func() bool {
            position307, tokenIndex307 := position, tokenIndex
            {
                position308 := position
                if buffer[position] != rune(',') {
                    goto l307
                }
                position++
                add(rulearraySep, position308)
            }
            return true
        l307:
            position, tokenIndex = position307, tokenIndex307
            return false
        },
        /* 61 Action0 <- <{ _ = buffer }> */
        nil,
        nil,
        /* 63 Action1 <- <{ p.SetTableString(begin, end) }> */
        nil,
        /* 64 Action2 <- <{ p.AddLineCount(end - begin) }> */
        nil,
        /* 65 Action3 <- <{ p.AddLineCount(end - begin) }> */
        nil,
        /* 66 Action4 <- <{ p.AddKeyValue() }> */
        nil,
        /* 67 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
        nil,
        /* 68 Action6 <- <{ p.SetKey(p.buffer, begin, end) }> */
        nil,
        /* 69 Action7 <- <{ p.SetTime(begin, end) }> */
        nil,
        /* 70 Action8 <- <{ p.SetFloat64(begin, end) }> */
        nil,
        /* 71 Action9 <- <{ p.SetInt64(begin, end) }> */
        nil,
        /* 72 Action10 <- <{ p.SetString(begin, end) }> */
        nil,
        /* 73 Action11 <- <{ p.SetBool(begin, end) }> */
        nil,
        /* 74 Action12 <- <{ p.SetArray(begin, end) }> */
        nil,
        /* 75 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
        nil,
        /* 76 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
        nil,
        /* 77 Action15 <- <{ p.StartInlineTable() }> */
        nil,
        /* 78 Action16 <- <{ p.EndInlineTable() }> */
        nil,
        /* 79 Action17 <- <{ p.AddTableKey() }> */
        nil,
        /* 80 Action18 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
        nil,
        /* 81 Action19 <- <{ p.SetMultilineString() }> */
        nil,
        /* 82 Action20 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
        nil,
        /* 83 Action21 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
        nil,
        /* 84 Action22 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
        nil,
        /* 85 Action23 <- <{ p.StartArray() }> */
        nil,
        /* 86 Action24 <- <{ p.AddArrayVal() }> */
        nil,
        /* 87 Action25 <- <{ p.AddArrayVal() }> */
        nil,
    }
    p.rules = _rules
}