parser.go

// Code generated by goyacc -l -v  -o parser.go -p eskip parser.y. DO NOT EDIT.
//lint:file-ignore ST1016 This is a generated file.
//lint:file-ignore SA4006 This is a generated file.

package eskip

import __yyfmt__ "fmt"

import "strconv"

// conversion error ignored, tokenizer expression already checked format
func convertNumber(s string) float64 {
	n, _ := strconv.ParseFloat(s, 64)
	return n
}

type eskipSymType struct {
	yys         int
	token       string
	route       *parsedRoute
	routes      []*parsedRoute
	predicates  []*Predicate
	predicate   *Predicate
	filter      *Filter
	filters     []*Filter
	args        []interface{}
	arg         interface{}
	backend     string
	shunt       bool
	loopback    bool
	dynamic     bool
	lbBackend   bool
	numval      float64
	stringvals  []string
	lbAlgorithm string
	lbEndpoints []string
}

const and = 57346
const any = 57347
const arrow = 57348
const closeparen = 57349
const colon = 57350
const comma = 57351
const number = 57352
const openparen = 57353
const regexpliteral = 57354
const semicolon = 57355
const shunt = 57356
const loopback = 57357
const dynamic = 57358
const stringliteral = 57359
const symbol = 57360
const openarrow = 57361
const closearrow = 57362
const start_document = 57363
const start_predicates = 57364
const start_filters = 57365

var eskipToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"and",
	"any",
	"arrow",
	"closeparen",
	"colon",
	"comma",
	"number",
	"openparen",
	"regexpliteral",
	"semicolon",
	"shunt",
	"loopback",
	"dynamic",
	"stringliteral",
	"symbol",
	"openarrow",
	"closearrow",
	"start_document",
	"start_predicates",
	"start_filters",
}

var eskipStatenames = [...]string{}

const eskipEofCode = 1
const eskipErrCode = 2
const eskipInitialStackSize = 16

var eskipExca = [...]int8{
	-1, 1,
	1, -1,
	-2, 0,
}

const eskipPrivate = 57344

const eskipLast = 68

var eskipAct = [...]int8{
	48, 39, 17, 29, 38, 2, 3, 4, 32, 33,
	34, 31, 18, 36, 11, 55, 16, 43, 8, 42,
	50, 49, 13, 18, 41, 50, 13, 28, 44, 59,
	23, 45, 19, 24, 26, 15, 37, 30, 27, 12,
	24, 7, 53, 51, 52, 52, 56, 57, 23, 44,
	54, 21, 22, 20, 58, 46, 25, 21, 60, 9,
	35, 47, 40, 14, 10, 6, 5, 1,
}

var eskipPact = [...]int16{
	-16, -1000, 21, 17, 5, -1000, 19, -1000, -1000, 47,
	17, -1000, 22, -1000, 53, 29, 50, -1000, 23, 9,
	-6, 17, -1000, -1000, 7, 5, 7, -1000, 40, -1000,
	49, -1000, -1000, -1000, -1000, -1000, 3, -1000, 36, -1000,
	-1000, -1000, -1000, -1000, -1000, 35, -6, -5, 37, 38,
	-1000, -1000, 7, -1000, -1000, -1000, 12, 8, -1000, -1000,
	37,
}

var eskipPgo = [...]int8{
	0, 67, 66, 59, 16, 65, 41, 18, 64, 3,
	14, 4, 2, 1, 62, 0, 61, 60,
}

var eskipR1 = [...]int8{
	0, 1, 1, 1, 1, 1, 2, 2, 5, 5,
	5, 5, 7, 8, 6, 6, 3, 3, 10, 10,
	4, 4, 12, 11, 11, 11, 13, 13, 13, 15,
	15, 16, 16, 17, 9, 9, 9, 9, 9, 14,
}

var eskipR2 = [...]int8{
	0, 2, 1, 2, 1, 2, 1, 1, 0, 1,
	3, 2, 2, 2, 3, 5, 1, 3, 1, 4,
	1, 3, 4, 0, 1, 3, 1, 1, 1, 1,
	3, 1, 3, 3, 1, 1, 1, 1, 1, 1,
}

var eskipChk = [...]int16{
	-1000, -1, 21, 22, 23, -2, -5, -6, -7, -3,
	-8, -10, 18, 5, -3, 18, -4, -12, 18, 13,
	6, 4, -6, 8, 11, 6, 11, -7, 18, -9,
	-4, 17, 14, 15, 16, -17, 19, -10, -11, -13,
	-14, 17, 12, 10, -12, -11, 6, -16, -15, 18,
	17, 7, 9, 7, -9, 20, 9, 9, -13, 17,
	-15,
}

var eskipDef = [...]int8{
	0, -2, 8, 2, 4, 1, 6, 7, 9, 0,
	0, 16, 0, 18, 3, 0, 5, 20, 0, 11,
	0, 0, 12, 13, 23, 0, 23, 10, 0, 14,
	0, 34, 35, 36, 37, 38, 0, 17, 0, 24,
	26, 27, 28, 39, 21, 0, 0, 0, 31, 0,
	29, 19, 0, 22, 15, 33, 0, 0, 25, 30,
	32,
}

var eskipTok1 = [...]int8{
	1,
}

var eskipTok2 = [...]int8{
	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	22, 23,
}

var eskipTok3 = [...]int8{
	0,
}

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

/*	parser for yacc output	*/

var (
	eskipDebug        = 0
	eskipErrorVerbose = false
)

type eskipLexer interface {
	Lex(lval *eskipSymType) int
	Error(s string)
}

type eskipParser interface {
	Parse(eskipLexer) int
	Lookahead() int
}

type eskipParserImpl struct {
	lval  eskipSymType
	stack [eskipInitialStackSize]eskipSymType
	char  int
}

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

func eskipNewParser() eskipParser {
	return &eskipParserImpl{}
}

const eskipFlag = -1000

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

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

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

	if !eskipErrorVerbose {
		return "syntax error"
	}

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

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

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

	// Look for shiftable tokens.
	base := int(eskipPact[state])
	for tok := TOKSTART; tok-1 < len(eskipToknames); tok++ {
		if n := base + tok; n >= 0 && n < eskipLast && int(eskipChk[int(eskipAct[n])]) == tok {
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}
	}

	if eskipDef[state] == -2 {
		i := 0
		for eskipExca[i] != -1 || int(eskipExca[i+1]) != state {
			i += 2
		}

		// Look for tokens that we accept or reduce.
		for i += 2; eskipExca[i] >= 0; i += 2 {
			tok := int(eskipExca[i])
			if tok < TOKSTART || eskipExca[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 eskipExca[i+1] != 0 {
			return res
		}
	}

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

func eskiplex1(lex eskipLexer, lval *eskipSymType) (char, token int) {
	token = 0
	char = lex.Lex(lval)
	if char <= 0 {
		token = int(eskipTok1[0])
		goto out
	}
	if char < len(eskipTok1) {
		token = int(eskipTok1[char])
		goto out
	}
	if char >= eskipPrivate {
		if char < eskipPrivate+len(eskipTok2) {
			token = int(eskipTok2[char-eskipPrivate])
			goto out
		}
	}
	for i := 0; i < len(eskipTok3); i += 2 {
		token = int(eskipTok3[i+0])
		if token == char {
			token = int(eskipTok3[i+1])
			goto out
		}
	}

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

func eskipParse(eskiplex eskipLexer) int {
	return eskipNewParser().Parse(eskiplex)
}

func (eskiprcvr *eskipParserImpl) Parse(eskiplex eskipLexer) int {
	var eskipn int
	var eskipVAL eskipSymType
	var eskipDollar []eskipSymType
	_ = eskipDollar // silence set and not used
	eskipS := eskiprcvr.stack[:]

	Nerrs := 0   /* number of errors */
	Errflag := 0 /* error recovery flag */
	eskipstate := 0
	eskiprcvr.char = -1
	eskiptoken := -1 // eskiprcvr.char translated into internal numbering
	defer func() {
		// Make sure we report no lookahead when not parsing.
		eskipstate = -1
		eskiprcvr.char = -1
		eskiptoken = -1
	}()
	eskipp := -1
	goto eskipstack

ret0:
	return 0

ret1:
	return 1

eskipstack:
	/* put a state and value onto the stack */
	if eskipDebug >= 4 {
		__yyfmt__.Printf("char %v in %v\n", eskipTokname(eskiptoken), eskipStatname(eskipstate))
	}

	eskipp++
	if eskipp >= len(eskipS) {
		nyys := make([]eskipSymType, len(eskipS)*2)
		copy(nyys, eskipS)
		eskipS = nyys
	}
	eskipS[eskipp] = eskipVAL
	eskipS[eskipp].yys = eskipstate

eskipnewstate:
	eskipn = int(eskipPact[eskipstate])
	if eskipn <= eskipFlag {
		goto eskipdefault /* simple state */
	}
	if eskiprcvr.char < 0 {
		eskiprcvr.char, eskiptoken = eskiplex1(eskiplex, &eskiprcvr.lval)
	}
	eskipn += eskiptoken
	if eskipn < 0 || eskipn >= eskipLast {
		goto eskipdefault
	}
	eskipn = int(eskipAct[eskipn])
	if int(eskipChk[eskipn]) == eskiptoken { /* valid shift */
		eskiprcvr.char = -1
		eskiptoken = -1
		eskipVAL = eskiprcvr.lval
		eskipstate = eskipn
		if Errflag > 0 {
			Errflag--
		}
		goto eskipstack
	}

eskipdefault:
	/* default state action */
	eskipn = int(eskipDef[eskipstate])
	if eskipn == -2 {
		if eskiprcvr.char < 0 {
			eskiprcvr.char, eskiptoken = eskiplex1(eskiplex, &eskiprcvr.lval)
		}

		/* look through exception table */
		xi := 0
		for {
			if eskipExca[xi+0] == -1 && int(eskipExca[xi+1]) == eskipstate {
				break
			}
			xi += 2
		}
		for xi += 2; ; xi += 2 {
			eskipn = int(eskipExca[xi+0])
			if eskipn < 0 || eskipn == eskiptoken {
				break
			}
		}
		eskipn = int(eskipExca[xi+1])
		if eskipn < 0 {
			goto ret0
		}
	}
	if eskipn == 0 {
		/* error ... attempt to resume parsing */
		switch Errflag {
		case 0: /* brand new error */
			eskiplex.Error(eskipErrorMessage(eskipstate, eskiptoken))
			Nerrs++
			if eskipDebug >= 1 {
				__yyfmt__.Printf("%s", eskipStatname(eskipstate))
				__yyfmt__.Printf(" saw %s\n", eskipTokname(eskiptoken))
			}
			fallthrough

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

			/* find a state where "error" is a legal shift action */
			for eskipp >= 0 {
				eskipn = int(eskipPact[eskipS[eskipp].yys]) + eskipErrCode
				if eskipn >= 0 && eskipn < eskipLast {
					eskipstate = int(eskipAct[eskipn]) /* simulate a shift of "error" */
					if int(eskipChk[eskipstate]) == eskipErrCode {
						goto eskipstack
					}
				}

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

		case 3: /* no shift yet; clobber input char */
			if eskipDebug >= 2 {
				__yyfmt__.Printf("error recovery discards %s\n", eskipTokname(eskiptoken))
			}
			if eskiptoken == eskipEofCode {
				goto ret1
			}
			eskiprcvr.char = -1
			eskiptoken = -1
			goto eskipnewstate /* try again in the same state */
		}
	}

	/* reduction by production eskipn */
	if eskipDebug >= 2 {
		__yyfmt__.Printf("reduce %v in:\n\t%v\n", eskipn, eskipStatname(eskipstate))
	}

	eskipnt := eskipn
	eskippt := eskipp
	_ = eskippt // guard against "declared and not used"

	eskipp -= int(eskipR2[eskipn])
	// eskipp is now the index of $0. Perform the default action. Iff the
	// reduced production is ε, $1 is possibly out of range.
	if eskipp+1 >= len(eskipS) {
		nyys := make([]eskipSymType, len(eskipS)*2)
		copy(nyys, eskipS)
		eskipS = nyys
	}
	eskipVAL = eskipS[eskipp+1]

	/* consult goto table to find next state */
	eskipn = int(eskipR1[eskipn])
	eskipg := int(eskipPgo[eskipn])
	eskipj := eskipg + eskipS[eskipp].yys + 1

	if eskipj >= eskipLast {
		eskipstate = int(eskipAct[eskipg])
	} else {
		eskipstate = int(eskipAct[eskipj])
		if int(eskipChk[eskipstate]) != -eskipn {
			eskipstate = int(eskipAct[eskipg])
		}
	}
	// dummy call; replaced with literal code
	switch eskipnt {

	case 1:
		eskipDollar = eskipS[eskippt-2 : eskippt+1]
		{
			eskiplex.(*eskipLex).routes = eskipDollar[2].routes
		}
	case 2:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			// allow empty or comments only
			eskiplex.(*eskipLex).predicates = nil
		}
	case 3:
		eskipDollar = eskipS[eskippt-2 : eskippt+1]
		{
			eskiplex.(*eskipLex).predicates = eskipDollar[2].predicates
		}
	case 4:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			// allow empty or comments only
			eskiplex.(*eskipLex).filters = nil
		}
	case 5:
		eskipDollar = eskipS[eskippt-2 : eskippt+1]
		{
			eskiplex.(*eskipLex).filters = eskipDollar[2].filters
		}
	case 6:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.routes = eskipDollar[1].routes
		}
	case 7:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.routes = []*parsedRoute{eskipDollar[1].route}
		}
	case 9:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.routes = []*parsedRoute{eskipDollar[1].route}
		}
	case 10:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.routes = eskipDollar[1].routes
			eskipVAL.routes = append(eskipVAL.routes, eskipDollar[3].route)
		}
	case 11:
		eskipDollar = eskipS[eskippt-2 : eskippt+1]
		{
			eskipVAL.routes = eskipDollar[1].routes
		}
	case 12:
		eskipDollar = eskipS[eskippt-2 : eskippt+1]
		{
			eskipVAL.route = eskipDollar[2].route
			eskipVAL.route.id = eskipDollar[1].token
		}
	case 13:
		eskipDollar = eskipS[eskippt-2 : eskippt+1]
		{
			// match symbol and colon to get route id early even if route parsing fails later
			eskipVAL.token = eskipDollar[1].token
			eskiplex.(*eskipLex).lastRouteID = eskipDollar[1].token
		}
	case 14:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.route = &parsedRoute{
				predicates:  eskipDollar[1].predicates,
				backend:     eskipDollar[3].backend,
				shunt:       eskipDollar[3].shunt,
				loopback:    eskipDollar[3].loopback,
				dynamic:     eskipDollar[3].dynamic,
				lbBackend:   eskipDollar[3].lbBackend,
				lbAlgorithm: eskipDollar[3].lbAlgorithm,
				lbEndpoints: eskipDollar[3].lbEndpoints,
			}
			eskipDollar[1].predicates = nil
			eskipDollar[3].lbEndpoints = nil
		}
	case 15:
		eskipDollar = eskipS[eskippt-5 : eskippt+1]
		{
			eskipVAL.route = &parsedRoute{
				predicates:  eskipDollar[1].predicates,
				filters:     eskipDollar[3].filters,
				backend:     eskipDollar[5].backend,
				shunt:       eskipDollar[5].shunt,
				loopback:    eskipDollar[5].loopback,
				dynamic:     eskipDollar[5].dynamic,
				lbBackend:   eskipDollar[5].lbBackend,
				lbAlgorithm: eskipDollar[5].lbAlgorithm,
				lbEndpoints: eskipDollar[5].lbEndpoints,
			}
			eskipDollar[1].predicates = nil
			eskipDollar[3].filters = nil
			eskipDollar[5].lbEndpoints = nil
		}
	case 16:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.predicates = []*Predicate{eskipDollar[1].predicate}
		}
	case 17:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.predicates = eskipDollar[1].predicates
			eskipVAL.predicates = append(eskipVAL.predicates, eskipDollar[3].predicate)
		}
	case 18:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.predicate = &Predicate{"*", nil}
		}
	case 19:
		eskipDollar = eskipS[eskippt-4 : eskippt+1]
		{
			eskipVAL.predicate = &Predicate{eskipDollar[1].token, eskipDollar[3].args}
			eskipDollar[3].args = nil
		}
	case 20:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.filters = []*Filter{eskipDollar[1].filter}
		}
	case 21:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.filters = eskipDollar[1].filters
			eskipVAL.filters = append(eskipVAL.filters, eskipDollar[3].filter)
		}
	case 22:
		eskipDollar = eskipS[eskippt-4 : eskippt+1]
		{
			eskipVAL.filter = &Filter{
				Name: eskipDollar[1].token,
				Args: eskipDollar[3].args}
			eskipDollar[3].args = nil
		}
	case 24:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.args = []interface{}{eskipDollar[1].arg}
		}
	case 25:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.args = eskipDollar[1].args
			eskipVAL.args = append(eskipVAL.args, eskipDollar[3].arg)
		}
	case 26:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.arg = eskipDollar[1].numval
		}
	case 27:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.arg = eskipDollar[1].token
		}
	case 28:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.arg = eskipDollar[1].token
		}
	case 29:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.stringvals = []string{eskipDollar[1].token}
		}
	case 30:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.stringvals = eskipDollar[1].stringvals
			eskipVAL.stringvals = append(eskipVAL.stringvals, eskipDollar[3].token)
		}
	case 31:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.lbEndpoints = eskipDollar[1].stringvals
		}
	case 32:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.lbAlgorithm = eskipDollar[1].token
			eskipVAL.lbEndpoints = eskipDollar[3].stringvals
		}
	case 33:
		eskipDollar = eskipS[eskippt-3 : eskippt+1]
		{
			eskipVAL.lbAlgorithm = eskipDollar[2].lbAlgorithm
			eskipVAL.lbEndpoints = eskipDollar[2].lbEndpoints
		}
	case 34:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.backend = eskipDollar[1].token
			eskipVAL.shunt = false
			eskipVAL.loopback = false
			eskipVAL.dynamic = false
			eskipVAL.lbBackend = false
		}
	case 35:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.shunt = true
			eskipVAL.loopback = false
			eskipVAL.dynamic = false
			eskipVAL.lbBackend = false
		}
	case 36:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.shunt = false
			eskipVAL.loopback = true
			eskipVAL.dynamic = false
			eskipVAL.lbBackend = false
		}
	case 37:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.shunt = false
			eskipVAL.loopback = false
			eskipVAL.dynamic = true
			eskipVAL.lbBackend = false
		}
	case 38:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.shunt = false
			eskipVAL.loopback = false
			eskipVAL.dynamic = false
			eskipVAL.lbBackend = true
			eskipVAL.lbAlgorithm = eskipDollar[1].lbAlgorithm
			eskipVAL.lbEndpoints = eskipDollar[1].lbEndpoints
		}
	case 39:
		eskipDollar = eskipS[eskippt-1 : eskippt+1]
		{
			eskipVAL.numval = convertNumber(eskipDollar[1].token)
		}
	}
	goto eskipstack /* stack new state and value */
}