github.com/mithrandie/csvq@v1.18.1/lib/json/path_parser.go

// Code generated by goyacc -p jp -o lib/json/path_parser.go -v lib/json/path_parser.output lib/json/path_parser.y. DO NOT EDIT.

//line lib/json/path_parser.y:2
package json

import __yyfmt__ "fmt"

//line lib/json/path_parser.y:2

//line lib/json/path_parser.y:5
type jpSymType struct {
	yys        int
	expression PathExpression
	member     ObjectPath
	token      PathToken
}

const OBJECT_PATH = 57346

var jpToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"OBJECT_PATH",
	"'.'",
}

var jpStatenames = [...]string{}

const jpEofCode = 1
const jpErrCode = 2
const jpInitialStackSize = 16

//line lib/json/path_parser.y:40

func ParsePath(src string) (PathExpression, error) {
	l := new(PathLexer)
	l.Init(src)
	jpParse(l)
	return l.path, l.err
}

//line yacctab:1
var jpExca = [...]int{
	-1, 1,
	1, -1,
	-2, 0,
}

const jpPrivate = 57344

const jpLast = 7

var jpAct = [...]int{
	4, 2, 3, 1, 0, 0, 5,
}

var jpPact = [...]int{
	-2, -1000, -1000, -5, -2, -1000,
}

var jpPgo = [...]int{
	0, 3, 1,
}

var jpR1 = [...]int{
	0, 1, 1, 2, 2,
}

var jpR2 = [...]int{
	0, 0, 1, 1, 3,
}

var jpChk = [...]int{
	-1000, -1, -2, 4, 5, -2,
}

var jpDef = [...]int{
	1, -2, 2, 3, 0, 4,
}

var jpTok1 = [...]int{
	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 5,
}

var jpTok2 = [...]int{
	2, 3, 4,
}

var jpTok3 = [...]int{
	0,
}

var jpErrorMessages = [...]struct {
	state int
	token int
	msg   string
}{}

//line yaccpar:1

/*	parser for yacc output	*/

var (
	jpDebug        = 0
	jpErrorVerbose = false
)

type jpLexer interface {
	Lex(lval *jpSymType) int
	Error(s string)
}

type jpParser interface {
	Parse(jpLexer) int
	Lookahead() int
}

type jpParserImpl struct {
	lval  jpSymType
	stack [jpInitialStackSize]jpSymType
	char  int
}

func (p *jpParserImpl) Lookahead() int {
	return p.char
}

func jpNewParser() jpParser {
	return &jpParserImpl{}
}

const jpFlag = -1000

func jpTokname(c int) string {
	if c >= 1 && c-1 < len(jpToknames) {
		if jpToknames[c-1] != "" {
			return jpToknames[c-1]
		}
	}
	return __yyfmt__.Sprintf("tok-%v", c)
}

func jpStatname(s int) string {
	if s >= 0 && s < len(jpStatenames) {
		if jpStatenames[s] != "" {
			return jpStatenames[s]
		}
	}
	return __yyfmt__.Sprintf("state-%v", s)
}

func jpErrorMessage(state, lookAhead int) string {
	const TOKSTART = 4

	if !jpErrorVerbose {
		return "syntax error"
	}

	for _, e := range jpErrorMessages {
		if e.state == state && e.token == lookAhead {
			return "syntax error: " + e.msg
		}
	}

	res := "syntax error: unexpected " + jpTokname(lookAhead)

	// To match Bison, suggest at most four expected tokens.
	expected := make([]int, 0, 4)

	// Look for shiftable tokens.
	base := jpPact[state]
	for tok := TOKSTART; tok-1 < len(jpToknames); tok++ {
		if n := base + tok; n >= 0 && n < jpLast && jpChk[jpAct[n]] == tok {
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}
	}

	if jpDef[state] == -2 {
		i := 0
		for jpExca[i] != -1 || jpExca[i+1] != state {
			i += 2
		}

		// Look for tokens that we accept or reduce.
		for i += 2; jpExca[i] >= 0; i += 2 {
			tok := jpExca[i]
			if tok < TOKSTART || jpExca[i+1] == 0 {
				continue
			}
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}

		// If the default action is to accept or reduce, give up.
		if jpExca[i+1] != 0 {
			return res
		}
	}

	for i, tok := range expected {
		if i == 0 {
			res += ", expecting "
		} else {
			res += " or "
		}
		res += jpTokname(tok)
	}
	return res
}

func jplex1(lex jpLexer, lval *jpSymType) (char, token int) {
	token = 0
	char = lex.Lex(lval)
	if char <= 0 {
		token = jpTok1[0]
		goto out
	}
	if char < len(jpTok1) {
		token = jpTok1[char]
		goto out
	}
	if char >= jpPrivate {
		if char < jpPrivate+len(jpTok2) {
			token = jpTok2[char-jpPrivate]
			goto out
		}
	}
	for i := 0; i < len(jpTok3); i += 2 {
		token = jpTok3[i+0]
		if token == char {
			token = jpTok3[i+1]
			goto out
		}
	}

out:
	if token == 0 {
		token = jpTok2[1] /* unknown char */
	}
	if jpDebug >= 3 {
		__yyfmt__.Printf("lex %s(%d)\n", jpTokname(token), uint(char))
	}
	return char, token
}

func jpParse(jplex jpLexer) int {
	return jpNewParser().Parse(jplex)
}

func (jprcvr *jpParserImpl) Parse(jplex jpLexer) int {
	var jpn int
	var jpVAL jpSymType
	var jpDollar []jpSymType
	_ = jpDollar // silence set and not used
	jpS := jprcvr.stack[:]

	Nerrs := 0   /* number of errors */
	Errflag := 0 /* error recovery flag */
	jpstate := 0
	jprcvr.char = -1
	jptoken := -1 // jprcvr.char translated into internal numbering
	defer func() {
		// Make sure we report no lookahead when not parsing.
		jpstate = -1
		jprcvr.char = -1
		jptoken = -1
	}()
	jpp := -1
	goto jpstack

ret0:
	return 0

ret1:
	return 1

jpstack:
	/* put a state and value onto the stack */
	if jpDebug >= 4 {
		__yyfmt__.Printf("char %v in %v\n", jpTokname(jptoken), jpStatname(jpstate))
	}

	jpp++
	if jpp >= len(jpS) {
		nyys := make([]jpSymType, len(jpS)*2)
		copy(nyys, jpS)
		jpS = nyys
	}
	jpS[jpp] = jpVAL
	jpS[jpp].yys = jpstate

jpnewstate:
	jpn = jpPact[jpstate]
	if jpn <= jpFlag {
		goto jpdefault /* simple state */
	}
	if jprcvr.char < 0 {
		jprcvr.char, jptoken = jplex1(jplex, &jprcvr.lval)
	}
	jpn += jptoken
	if jpn < 0 || jpn >= jpLast {
		goto jpdefault
	}
	jpn = jpAct[jpn]
	if jpChk[jpn] == jptoken { /* valid shift */
		jprcvr.char = -1
		jptoken = -1
		jpVAL = jprcvr.lval
		jpstate = jpn
		if Errflag > 0 {
			Errflag--
		}
		goto jpstack
	}

jpdefault:
	/* default state action */
	jpn = jpDef[jpstate]
	if jpn == -2 {
		if jprcvr.char < 0 {
			jprcvr.char, jptoken = jplex1(jplex, &jprcvr.lval)
		}

		/* look through exception table */
		xi := 0
		for {
			if jpExca[xi+0] == -1 && jpExca[xi+1] == jpstate {
				break
			}
			xi += 2
		}
		for xi += 2; ; xi += 2 {
			jpn = jpExca[xi+0]
			if jpn < 0 || jpn == jptoken {
				break
			}
		}
		jpn = jpExca[xi+1]
		if jpn < 0 {
			goto ret0
		}
	}
	if jpn == 0 {
		/* error ... attempt to resume parsing */
		switch Errflag {
		case 0: /* brand new error */
			jplex.Error(jpErrorMessage(jpstate, jptoken))
			Nerrs++
			if jpDebug >= 1 {
				__yyfmt__.Printf("%s", jpStatname(jpstate))
				__yyfmt__.Printf(" saw %s\n", jpTokname(jptoken))
			}
			fallthrough

		case 1, 2: /* incompletely recovered error ... try again */
			Errflag = 3

			/* find a state where "error" is a legal shift action */
			for jpp >= 0 {
				jpn = jpPact[jpS[jpp].yys] + jpErrCode
				if jpn >= 0 && jpn < jpLast {
					jpstate = jpAct[jpn] /* simulate a shift of "error" */
					if jpChk[jpstate] == jpErrCode {
						goto jpstack
					}
				}

				/* the current p has no shift on "error", pop stack */
				if jpDebug >= 2 {
					__yyfmt__.Printf("error recovery pops state %d\n", jpS[jpp].yys)
				}
				jpp--
			}
			/* there is no state on the stack with an error shift ... abort */
			goto ret1

		case 3: /* no shift yet; clobber input char */
			if jpDebug >= 2 {
				__yyfmt__.Printf("error recovery discards %s\n", jpTokname(jptoken))
			}
			if jptoken == jpEofCode {
				goto ret1
			}
			jprcvr.char = -1
			jptoken = -1
			goto jpnewstate /* try again in the same state */
		}
	}

	/* reduction by production jpn */
	if jpDebug >= 2 {
		__yyfmt__.Printf("reduce %v in:\n\t%v\n", jpn, jpStatname(jpstate))
	}

	jpnt := jpn
	jppt := jpp
	_ = jppt // guard against "declared and not used"

	jpp -= jpR2[jpn]
	// jpp is now the index of $0. Perform the default action. Iff the
	// reduced production is ε, $1 is possibly out of range.
	if jpp+1 >= len(jpS) {
		nyys := make([]jpSymType, len(jpS)*2)
		copy(nyys, jpS)
		jpS = nyys
	}
	jpVAL = jpS[jpp+1]

	/* consult goto table to find next state */
	jpn = jpR1[jpn]
	jpg := jpPgo[jpn]
	jpj := jpg + jpS[jpp].yys + 1

	if jpj >= jpLast {
		jpstate = jpAct[jpg]
	} else {
		jpstate = jpAct[jpj]
		if jpChk[jpstate] != -jpn {
			jpstate = jpAct[jpg]
		}
	}
	// dummy call; replaced with literal code
	switch jpnt {

	case 1:
		jpDollar = jpS[jppt-0 : jppt+1]
//line lib/json/path_parser.y:20
		{
			jpVAL.expression = ObjectPath{}
			jplex.(*PathLexer).path = jpVAL.expression
		}
	case 2:
		jpDollar = jpS[jppt-1 : jppt+1]
//line lib/json/path_parser.y:25
		{
			jpVAL.expression = jpDollar[1].member
			jplex.(*PathLexer).path = jpVAL.expression
		}
	case 3:
		jpDollar = jpS[jppt-1 : jppt+1]
//line lib/json/path_parser.y:32
		{
			jpVAL.member = ObjectPath{Name: jpDollar[1].token.Literal}
		}
	case 4:
		jpDollar = jpS[jppt-3 : jppt+1]
//line lib/json/path_parser.y:36
		{
			jpVAL.member = ObjectPath{Name: jpDollar[1].token.Literal, Child: jpDollar[3].member}
		}
	}
	goto jpstack /* stack new state and value */
}