// Code generated by 'egg -o ./internal/parser/parser.go -package parser -start Config config.ebnf', DO NOT EDIT.

// Parser generated from config.ebnf.

package parser

import (
	"errors"
	"fmt"
	"go/token"
	"strconv"
	"unicode"
	"unicode/utf8"

	"modernc.org/scanner"
)

var _ = unicode.MaxRune

// Symbols
const (
	TOK_EOF     = Symbol(0)  // EOF
	TOK_003d    = Symbol(1)  // '='
	boolean     = Symbol(2)  // boolean
	br          = Symbol(3)  // br
	lbrace      = Symbol(4)  // lbrace
	number      = Symbol(5)  // number
	rbrace      = Symbol(6)  // rbrace
	str         = Symbol(7)  // str
	white_space = Symbol(8)  // white_space
	word        = Symbol(9)  // word
	Config      = Symbol(10) // Config
	Doc         = Symbol(11) // Doc
	Stmt        = Symbol(12) // Stmt
	Assignment  = Symbol(13) // Assignment
	Command     = Symbol(14) // Command
	Values      = Symbol(15) // Values
	Value       = Symbol(16) // Value
	Body        = Symbol(17) // Body
	Word        = Symbol(18) // Word
	Number      = Symbol(19) // Number
	Boolean     = Symbol(20) // Boolean
	String      = Symbol(21) // String
)

const SymbolNames = "EOF'='booleanbrlbracenumberrbracestrwhite_spacewordConfigDocStmtAssignmentCommandValuesValueBodyWordNumberBooleanString"

var SymbolIndex = [...]uint8{0, 3, 6, 13, 15, 21, 27, 33, 36, 47, 51, 57, 60, 64, 74, 81, 87, 92, 96, 100, 106, 113, 119}

func (s Symbol) String() string {
	idx := int(s) - 0
	if s < 0 || idx >= len(SymbolIndex)-1 {
		return "Symbol(" + strconv.FormatInt(int64(s), 10) + ")"
	}
	return SymbolNames[SymbolIndex[idx]:SymbolIndex[idx+1]]
}

var errorSets = [...][]Symbol{
	{String, Boolean, Number, Word, Body, Value, Values, word, str, number, lbrace, br, boolean, TOK_003d},
	{TOK_003d},
	{String, Boolean, Number, Word, Value, word, str, number, lbrace, br, boolean},
	{String, Boolean, Number, Word, Value, word, str, number, boolean},
	{String, Boolean, Number, Word, word, str, number, boolean},
	{word, str, number, boolean},
	{boolean},
	{lbrace, br},
	{br},
	{lbrace},
	{number},
	{Word, Stmt, word, rbrace},
	{rbrace},
	{str},
	{Word, Stmt, word},
	{Word, word},
	{word},
}

type Parser struct {
	cache     [][]int32
	eof       bool
	errBudget int
	id        rune // from scanSep, valid if .n != 0
	n         int  // from scanSep, valid if != 0
	off       int
	sc        *scanner.RecScanner
	src       []byte
	tok       scanner.Token // current lookahead
	tokIndex  int32         // For scanner.Token(tokIndex)
}

type Symbol int32

// scan recognizes longest UTF-8 lexemes. Lower IDs take precedence on same length.
//
//	id   0: $
//	id   1: =
//	id   2: (true|false)
//	id   3: (;)
//	id   4: (\{)
//	id   5: (-?[0-9]+(\.[0-9]+)?)
//	id   6: (\})
//	id   7: (("[^"]*")|('[^']*')|(`)(([^\x60]))*(`))
//	id   8: ( |\t|\r|\n|#.*)
//	id   9: ([a-zA-Z_][a-zA-Z0-9_]*)
//
// ID == -1 is returned when no lexeme was recognized.
func (*Parser) scan(s []byte) (id, length int) {
	const endOfText = 0x110000
	var pos, pos0, width, width1 int
	id = -1
	var r, r1 rune
	_ = pos0
	_ = r
	_ = r1
	_ = width1
	step := func(pos int) (r rune, n int) {
		if pos < len(s) {
			c := s[pos]
			if c < utf8.RuneSelf {
				return rune(c), 1
			}
			return utf8.DecodeRune(s[pos:])
		}
		return endOfText, 0
	}
	move := func() {
		pos += width
		if r, width = r1, width1; r != endOfText {
			r1, width1 = step(pos + width)
		}
	}
	accept := func(x rune) bool {
		if r == x {
			move()
			return true
		}
		return false
	}
	_ = accept
	accept2 := func(x rune) bool {
		if r <= x {
			move()
			return true
		}
		return false
	}
	_ = accept2
	r, r1 = endOfText, endOfText
	width, width1 = 0, 0
	r, width = step(pos)
	if r != endOfText {
		r1, width1 = step(pos + width)
	}
	if accept('\t') {
		goto l37
	}
	if accept('\n') {
		goto l39
	}
	if accept('\r') {
		goto l41
	}
	if accept(' ') {
		goto l43
	}
	if accept('"') {
		goto l45
	}
	if accept('#') {
		goto l57
	}
	if accept('\'') {
		goto l65
	}
	if accept('-') {
		goto l77
	}
	if accept(';') {
		goto l93
	}
	if accept('=') {
		goto l95
	}
	if accept('`') {
		goto l105
	}
	if accept('f') {
		goto l117
	}
	if accept('t') {
		goto l145
	}
	if accept('{') {
		goto l167
	}
	if accept('}') {
		goto l169
	}
	if r < '0' {
		goto l30out
	}
	if accept2('9') {
		goto l80
	}
l30out:
	if r < 'A' {
		goto l32out
	}
	if accept2('Z') {
		goto l97
	}
	if accept('_') {
		goto l97
	}
	if r < 'a' {
		goto l32out
	}
	if accept2('e') {
		goto l97
	}
	if r < 'g' {
		goto l32out
	}
	if accept2('s') {
		goto l97
	}
	if r < 'u' {
		goto l32out
	}
	if accept2('z') {
		goto l97
	}
l32out:
	if r == endOfText {
		goto l171
	}
	return id, length
l37:
	id, length = 8, pos
	return id, length
l39:
	id, length = 8, pos
	return id, length
l41:
	id, length = 8, pos
	return id, length
l43:
	id, length = 8, pos
	return id, length
l45:
	if accept('"') {
		goto l50
	}
	if accept2('!') {
		goto l52
	}
	if r < '#' {
		goto l47out
	}
	if accept2('\U0010ffff') {
		goto l52
	}
l47out:
	return id, length
l50:
	id, length = 7, pos
	return id, length
l52:
	if accept('"') {
		goto l50
	}
	if accept2('!') {
		goto l52
	}
	if r < '#' {
		goto l54out
	}
	if accept2('\U0010ffff') {
		goto l52
	}
l54out:
	return id, length
l57:
	id, length = 8, pos
	if accept2('\t') {
		goto l61
	}
	if r < '\v' {
		goto l58out
	}
	if accept2('\U0010ffff') {
		goto l61
	}
l58out:
	return id, length
l61:
	id, length = 8, pos
	if accept2('\t') {
		goto l61
	}
	if r < '\v' {
		goto l62out
	}
	if accept2('\U0010ffff') {
		goto l61
	}
l62out:
	return id, length
l65:
	if accept('\'') {
		goto l70
	}
	if accept2('&') {
		goto l72
	}
	if r < '(' {
		goto l67out
	}
	if accept2('\U0010ffff') {
		goto l72
	}
l67out:
	return id, length
l70:
	id, length = 7, pos
	return id, length
l72:
	if accept('\'') {
		goto l70
	}
	if accept2('&') {
		goto l72
	}
	if r < '(' {
		goto l74out
	}
	if accept2('\U0010ffff') {
		goto l72
	}
l74out:
	return id, length
l77:
	if r < '0' {
		goto l77out
	}
	if accept2('9') {
		goto l80
	}
l77out:
	return id, length
l80:
	id, length = 5, pos
	if accept('.') {
		goto l86
	}
	if r < '0' {
		goto l83out
	}
	if accept2('9') {
		goto l80
	}
l83out:
	return id, length
l86:
	if r < '0' {
		goto l86out
	}
	if accept2('9') {
		goto l89
	}
l86out:
	return id, length
l89:
	id, length = 5, pos
	if r < '0' {
		goto l90out
	}
	if accept2('9') {
		goto l89
	}
l90out:
	return id, length
l93:
	id, length = 3, pos
	return id, length
l95:
	id, length = 1, pos
	return id, length
l97:
	id, length = 9, pos
	if r < '0' {
		goto l98out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l98out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l98out
	}
	if accept2('z') {
		goto l101
	}
l98out:
	return id, length
l101:
	id, length = 9, pos
	if r < '0' {
		goto l102out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l102out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l102out
	}
	if accept2('z') {
		goto l101
	}
l102out:
	return id, length
l105:
	if accept('`') {
		goto l110
	}
	if accept2('_') {
		goto l112
	}
	if r < 'a' {
		goto l107out
	}
	if accept2('\U0010ffff') {
		goto l112
	}
l107out:
	return id, length
l110:
	id, length = 7, pos
	return id, length
l112:
	if accept('`') {
		goto l110
	}
	if accept2('_') {
		goto l112
	}
	if r < 'a' {
		goto l114out
	}
	if accept2('\U0010ffff') {
		goto l112
	}
l114out:
	return id, length
l117:
	id, length = 9, pos
	if accept('a') {
		goto l123
	}
	if r < '0' {
		goto l120out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l120out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'b' {
		goto l120out
	}
	if accept2('z') {
		goto l101
	}
l120out:
	return id, length
l123:
	id, length = 9, pos
	if accept('l') {
		goto l129
	}
	if r < '0' {
		goto l126out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l126out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l126out
	}
	if accept2('k') {
		goto l101
	}
	if r < 'm' {
		goto l126out
	}
	if accept2('z') {
		goto l101
	}
l126out:
	return id, length
l129:
	id, length = 9, pos
	if accept('s') {
		goto l135
	}
	if r < '0' {
		goto l132out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l132out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l132out
	}
	if accept2('r') {
		goto l101
	}
	if r < 't' {
		goto l132out
	}
	if accept2('z') {
		goto l101
	}
l132out:
	return id, length
l135:
	id, length = 9, pos
	if accept('e') {
		goto l141
	}
	if r < '0' {
		goto l138out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l138out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l138out
	}
	if accept2('d') {
		goto l101
	}
	if r < 'f' {
		goto l138out
	}
	if accept2('z') {
		goto l101
	}
l138out:
	return id, length
l141:
	id, length = 2, pos
	if r < '0' {
		goto l142out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l142out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l142out
	}
	if accept2('z') {
		goto l101
	}
l142out:
	return id, length
l145:
	id, length = 9, pos
	if accept('r') {
		goto l151
	}
	if r < '0' {
		goto l148out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l148out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l148out
	}
	if accept2('q') {
		goto l101
	}
	if r < 's' {
		goto l148out
	}
	if accept2('z') {
		goto l101
	}
l148out:
	return id, length
l151:
	id, length = 9, pos
	if accept('u') {
		goto l157
	}
	if r < '0' {
		goto l154out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l154out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l154out
	}
	if accept2('t') {
		goto l101
	}
	if r < 'v' {
		goto l154out
	}
	if accept2('z') {
		goto l101
	}
l154out:
	return id, length
l157:
	id, length = 9, pos
	if accept('e') {
		goto l163
	}
	if r < '0' {
		goto l160out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l160out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l160out
	}
	if accept2('d') {
		goto l101
	}
	if r < 'f' {
		goto l160out
	}
	if accept2('z') {
		goto l101
	}
l160out:
	return id, length
l163:
	id, length = 2, pos
	if r < '0' {
		goto l164out
	}
	if accept2('9') {
		goto l101
	}
	if r < 'A' {
		goto l164out
	}
	if accept2('Z') {
		goto l101
	}
	if accept('_') {
		goto l101
	}
	if r < 'a' {
		goto l164out
	}
	if accept2('z') {
		goto l101
	}
l164out:
	return id, length
l167:
	id, length = 4, pos
	return id, length
l169:
	id, length = 6, pos
	return id, length
l171:
	id, length = 0, pos
	return id, length
}

// Scan is used internally from Parse.
func (p *Parser) Scan() (r scanner.Token) {
	return p.sc.Scan()
}

// init initalizes 'p' with content in 'src', assuming it comes from 'name'.
// 'src' becomes "owned" by 'p'. init invalidates any pre-existing ASTs produced by 'p'. Mutating
// 'src' invalidates the current AST returned from any parsing function called after init.
func (p *Parser) init(name string, src []byte) (err error) {
	p.eof = false
	p.errBudget = 10
	p.n = 0
	p.off = 0
	p.src = src
	p.tok = scanner.Token{}
	p.tokIndex = 0
	p.sc = scanner.NewRecScanner(name, p.src, p.scan, int(white_space))
	return nil
}

// Assignment grammar:
//
//	# Statements
//	Assignment      = "=" Values br .
//
//	State 0
//		on  '='
//			shift and goto state 1
//	State 1
//		on  boolean, number, str, word, Value, Word, Number, Boolean, String
//			call Values and goto state 2
//	State 2
//		on  br
//			shift and goto state 3
//	State 3
//		Accept
//
// Assignment is used internally from Parse.
func (p *Parser) Assignment() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Assignment), 0)
	// state0:
	accept, errorSet = false, 1
	switch Symbol(p.tok.Ch) {
	case TOK_003d:
		r = append(r, p.shift())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = false, 3
	switch Symbol(p.tok.Ch) {
	case boolean, number, str, word, Value, Word, Number, Boolean, String:
		r = p.add(r, p.Values())
		goto state2
	}
	return p.stop(r, accept, errorSet)
state2:
	accept, errorSet = false, 8
	switch Symbol(p.tok.Ch) {
	case br:
		r = append(r, p.shift())
		goto state3
	}
	return p.stop(r, accept, errorSet)
state3:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

// Body grammar:
//
//	Body            = lbrace [ Doc ] rbrace .
//
//	State 0
//		on  lbrace
//			shift and goto state 1
//	State 1
//		on  rbrace
//			shift and goto state 2
//		on  word, Stmt, Word
//			call Doc and goto state 3
//	State 2
//		Accept
//	State 3
//		on  rbrace
//			shift and goto state 2
//
// Body is used internally from Parse.
func (p *Parser) Body() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Body), 0)
	// state0:
	accept, errorSet = false, 9
	switch Symbol(p.tok.Ch) {
	case lbrace:
		r = append(r, p.shift())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = false, 11
	switch Symbol(p.tok.Ch) {
	case rbrace:
		r = append(r, p.shift())
		goto state2
	case word, Stmt, Word:
		r = p.add(r, p.Doc())
		goto state3
	}
	return p.stop(r, accept, errorSet)
state2:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
state3:
	accept, errorSet = false, 12
	switch Symbol(p.tok.Ch) {
	case rbrace:
		r = append(r, p.shift())
		goto state2
	}
	return p.stop(r, accept, errorSet)
}

// Boolean grammar:
//
//	Boolean         = boolean .
//
//	State 0
//		on  boolean
//			shift and goto state 1
//	State 1
//		Accept
//
// Boolean is used internally from Parse.
func (p *Parser) Boolean() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Boolean), 0)
	// state0:
	accept, errorSet = false, 6
	switch Symbol(p.tok.Ch) {
	case boolean:
		r = append(r, p.shift())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

// Command grammar:
//
//	Command         = [Values] ( Body | br ) .
//
//	State 0
//		on  br
//			shift and goto state 1
//		on  boolean, number, str, word, Value, Word, Number, Boolean, String
//			call Values and goto state 2
//		on  lbrace
//			call Body and goto state 1
//	State 1
//		Accept
//	State 2
//		on  br
//			shift and goto state 1
//		on  lbrace
//			call Body and goto state 1
//
// Command is used internally from Parse.
func (p *Parser) Command() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Command), 0)
	// state0:
	accept, errorSet = false, 2
	switch Symbol(p.tok.Ch) {
	case br:
		r = append(r, p.shift())
		goto state1
	case boolean, number, str, word, Value, Word, Number, Boolean, String:
		r = p.add(r, p.Values())
		goto state2
	case lbrace:
		r = p.add(r, p.Body())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
state2:
	accept, errorSet = false, 7
	switch Symbol(p.tok.Ch) {
	case br:
		r = append(r, p.shift())
		goto state1
	case lbrace:
		r = p.add(r, p.Body())
		goto state1
	}
	return p.stop(r, accept, errorSet)
}

// Config grammar:
//
//	Config          = Doc .
//
//	State 0
//		on  word, Stmt, Word
//			call Doc and goto state 1
//	State 1
//		Accept
//
// Config is used internally from Parse.
func (p *Parser) Config() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Config), 0)
	// state0:
	accept, errorSet = false, 14
	switch Symbol(p.tok.Ch) {
	case word, Stmt, Word:
		r = p.add(r, p.Doc())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	if accept = accept && p.eof; accept {
		r = append(r, p.shift())
	}
	r[1] = int32(len(r) - 2)
	if !accept {
		p.err(p.tok.Position(), "%q [%s]: expected %v", p.tok.Src(), Symbol(p.tok.Ch), errorSets[errorSet])
	}
	return r
}

// Doc grammar:
//
//	Doc             = Stmt { Stmt } .
//
//	State 0
//		on  word, Word
//			call Stmt and goto state 1
//	State 1
//		Accept
//		on  word, Word
//			call Stmt and goto state 1
//
// Doc is used internally from Parse.
func (p *Parser) Doc() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Doc), 0)
	// state0:
	accept, errorSet = false, 15
	switch Symbol(p.tok.Ch) {
	case word, Word:
		r = p.add(r, p.Stmt())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 15
	switch Symbol(p.tok.Ch) {
	case word, Word:
		r = p.add(r, p.Stmt())
		goto state1
	}
	return p.stop(r, accept, errorSet)
}

// Number grammar:
//
//	Number          = number .
//
//	State 0
//		on  number
//			shift and goto state 1
//	State 1
//		Accept
//
// Number is used internally from Parse.
func (p *Parser) Number() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Number), 0)
	// state0:
	accept, errorSet = false, 10
	switch Symbol(p.tok.Ch) {
	case number:
		r = append(r, p.shift())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

// Stmt grammar:
//
//	Stmt            = Word (Assignment | Command) .
//
//	State 0
//		on  word
//			call Word and goto state 1
//	State 1
//		on  '='
//			call Assignment and goto state 2
//		on  boolean, br, lbrace, number, str, word, Values, Value, Body, Word, Number, Boolean, String
//			call Command and goto state 2
//	State 2
//		Accept
//
// Stmt is used internally from Parse.
func (p *Parser) Stmt() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Stmt), 0)
	// state0:
	accept, errorSet = false, 16
	switch Symbol(p.tok.Ch) {
	case word:
		r = p.add(r, p.Word())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = false, 0
	switch Symbol(p.tok.Ch) {
	case TOK_003d:
		r = p.add(r, p.Assignment())
		goto state2
	case boolean, br, lbrace, number, str, word, Values, Value, Body, Word, Number, Boolean, String:
		r = p.add(r, p.Command())
		goto state2
	}
	return p.stop(r, accept, errorSet)
state2:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

// String grammar:
//
//	String          = str .
//
//	State 0
//		on  str
//			shift and goto state 1
//	State 1
//		Accept
//
// String is used internally from Parse.
func (p *Parser) String() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(String), 0)
	// state0:
	accept, errorSet = false, 13
	switch Symbol(p.tok.Ch) {
	case str:
		r = append(r, p.shift())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

// Value grammar:
//
//	Value           = Word | String | Number | Boolean .
//
//	State 0
//		on  word
//			call Word and goto state 1
//		on  number
//			call Number and goto state 1
//		on  boolean
//			call Boolean and goto state 1
//		on  str
//			call String and goto state 1
//	State 1
//		Accept
//
// Value is used internally from Parse.
func (p *Parser) Value() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Value), 0)
	// state0:
	accept, errorSet = false, 5
	switch Symbol(p.tok.Ch) {
	case word:
		r = p.add(r, p.Word())
		goto state1
	case number:
		r = p.add(r, p.Number())
		goto state1
	case boolean:
		r = p.add(r, p.Boolean())
		goto state1
	case str:
		r = p.add(r, p.String())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

// Values grammar:
//
//	# Value types
//	Values          = Value {Value} .
//
//	State 0
//		on  boolean, number, str, word, Word, Number, Boolean, String
//			call Value and goto state 1
//	State 1
//		Accept
//		on  boolean, number, str, word, Word, Number, Boolean, String
//			call Value and goto state 1
//
// Values is used internally from Parse.
func (p *Parser) Values() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Values), 0)
	// state0:
	accept, errorSet = false, 4
	switch Symbol(p.tok.Ch) {
	case boolean, number, str, word, Word, Number, Boolean, String:
		r = p.add(r, p.Value())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 4
	switch Symbol(p.tok.Ch) {
	case boolean, number, str, word, Word, Number, Boolean, String:
		r = p.add(r, p.Value())
		goto state1
	}
	return p.stop(r, accept, errorSet)
}

// Word grammar:
//
//	# Atoms
//	Word            = word .
//
//	State 0
//		on  word
//			shift and goto state 1
//	State 1
//		Accept
//
// Word is used internally from Parse.
func (p *Parser) Word() (r []int32) {
	accept, errorSet := false, 0
	r = append(p.get(), -int32(Word), 0)
	// state0:
	accept, errorSet = false, 16
	switch Symbol(p.tok.Ch) {
	case word:
		r = append(r, p.shift())
		goto state1
	}
	return p.stop(r, accept, errorSet)
state1:
	accept, errorSet = true, 0
	return p.stop(r, accept, errorSet)
}

func (p *Parser) shift() (r int32) {
	r = p.tokIndex
	if !p.eof {
		p.tok = p.Scan()
		p.tokIndex++
		p.eof = p.tok.Ch == rune(TOK_EOF)
	}
	return r
}

func (p *Parser) get() (r []int32) {
	if n := len(p.cache); n != 0 {
		r = p.cache[n-1][:0]
		p.cache = p.cache[:n-1]
	}
	return r
}

func (p *Parser) add(r, s []int32) (t []int32) {
	p.cache = append(p.cache, s)
	return append(r, s...)
}

func (p *Parser) stop(r []int32, accept bool, errorSet int) []int32 {
	r[1] = int32(len(r) - 2)
	if !accept {
		p.err(p.tok.Position(), "%q [%s]: expected %v", p.tok.Src(), Symbol(p.tok.Ch), errorSets[errorSet])
	}
	return r
}

// EOF reports whether the parser lookahead token is EOF.
func (p *Parser) EOF() bool {
	return p.eof
}

// Token returns the n-th token in 'p'. Token panics if 'n' is out of range.
func (p *Parser) Token(n int32) (r scanner.Token) {
	return p.sc.Token(int(n))
}

// Parse parses 'src'. 'src' becomes "owned" by the parser and must not be
// mutated afterwards.
func (p *Parser) Parse(name string, src []byte) (ast []int32, err error) {
	if err = p.init(name, src); err != nil {
		return nil, err
	}

	defer func() {
		switch e := recover(); x := e.(type) {
		case nil:
			// ok
		case scanner.ErrList:
			err = x
		case error:
			err = errors.Join(err, x)
		default:
			err = errors.Join(err, fmt.Errorf("%v", x))
		}
	}()

	p.tok = p.Scan()
	ast = p.Config()
	return ast, p.sc.Err()
}

func (p *Parser) err0(pos token.Position, s string, args ...any) {
	p.sc.AddErr(pos, s, args...)
	if p.errBudget--; p.errBudget == 0 {
		p.sc.AddErr(pos, "too many errors")
	}
}

func (p *Parser) err(pos token.Position, s string, args ...any) {
	p.err0(pos, s, args...)
	p.shift()
	if p.eof {
		panic(p.sc.Err())
	}
}