compile_parser.go

// Code generated by goyacc -p compile -v /dev/null -o compile_parser.go compile_parser.y. DO NOT EDIT.

//line compile_parser.y:2
package goeval

import __yyfmt__ "fmt"

//line compile_parser.y:2

//line compile_parser.y:6
type compileSymType struct {
	yys   int
	name  string
	node  exprNode
	nodes []exprNode
}

const C_VALUE = 57346
const C_EQ = 57347
const C_NEQ = 57348
const C_GTE = 57349
const C_LTE = 57350
const C_RE = 57351
const C_NRE = 57352
const C_AND = 57353
const C_OR = 57354
const C_NC = 57355
const C_IN = 57356
const C_IDENTIFIER = 57357
const C_UMINUS = 57358

var compileToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"C_VALUE",
	"C_EQ",
	"C_NEQ",
	"C_GTE",
	"C_LTE",
	"C_RE",
	"C_NRE",
	"C_AND",
	"C_OR",
	"C_NC",
	"C_IN",
	"C_IDENTIFIER",
	"'+'",
	"'-'",
	"'*'",
	"'/'",
	"'%'",
	"'<'",
	"'>'",
	"'?'",
	"':'",
	"'='",
	"'('",
	"')'",
	"','",
	"'['",
	"']'",
	"'!'",
	"C_UMINUS",
}

var compileStatenames = [...]string{}

const compileEofCode = 1
const compileErrCode = 2
const compileInitialStackSize = 16

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

const compilePrivate = 57344

const compileLast = 120

var compileAct = [...]int8{
	35, 2, 3, 34, 64, 4, 63, 76, 32, 33,
	74, 77, 64, 43, 44, 45, 46, 75, 64, 47,
	48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	58, 59, 60, 61, 62, 73, 64, 7, 36, 15,
	65, 10, 11, 67, 66, 1, 69, 68, 9, 0,
	6, 27, 28, 29, 30, 31, 24, 25, 0, 12,
	26, 0, 8, 0, 5, 72, 16, 17, 18, 19,
	20, 21, 78, 7, 22, 23, 0, 27, 28, 29,
	30, 31, 24, 25, 9, 40, 26, 0, 0, 37,
	13, 14, 13, 14, 0, 12, 42, 0, 8, 41,
	39, 0, 15, 38, 15, 71, 70, 13, 14, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
}

var compilePact = [...]int16{
	33, -32768, 96, 61, -32768, 33, 33, -32768, 33, 12,
	74, 70, 33, 33, 33, 33, 33, 33, 33, 33,
	33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
	33, 33, -32768, -32768, -24, 96, 33, -32768, 69, 33,
	-32768, 69, 33, 79, 16, 16, 81, 35, 35, 35,
	35, 35, 35, 35, 35, -32768, -32768, -32768, -32768, -32768,
	-32768, -32768, -32768, -32768, 33, 8, -20, -10, -23, -16,
	-32768, 33, 96, -32768, -32768, -32768, -32768, -32768, -32768,
}

var compilePgo = [...]int8{
	0, 45, 0, 5, 2, 42, 41, 3,
}

var compileR1 = [...]int8{
	0, 1, 3, 3, 3, 3, 3, 6, 6, 6,
	6, 5, 5, 5, 5, 7, 7, 7, 4, 4,
	4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
	4, 4, 4, 4, 4, 4, 4, 2, 2, 2,
	2,
}

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

var compileChk = [...]int16{
	-32768, -1, -2, -4, -3, 31, 17, 4, 29, 15,
	-6, -5, 26, 11, 12, 23, 5, 6, 7, 8,
	9, 10, 13, 14, 21, 22, 25, 16, 17, 18,
	19, 20, -4, -4, -7, -2, 26, 15, 29, 26,
	15, 29, 26, -2, -2, -2, -2, -4, -4, -4,
	-4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
	-4, -4, -4, 30, 28, -7, -3, -7, -3, -7,
	27, 24, -2, 27, 30, 27, 30, 27, -2,
}

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

var compileTok1 = [...]int8{
	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, 31, 3, 3, 3, 20, 3, 3,
	26, 27, 18, 16, 28, 17, 3, 19, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 24, 3,
	21, 25, 22, 23, 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, 29, 3, 30,
}

var compileTok2 = [...]int8{
	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
	12, 13, 14, 15, 32,
}

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

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

//line yaccpar:1

/*	parser for yacc output	*/

var (
	compileDebug        = 0
	compileErrorVerbose = false
)

type compileLexer interface {
	Lex(lval *compileSymType) int
	Error(s string)
}

type compileParser interface {
	Parse(compileLexer) int
	Lookahead() int
}

type compileParserImpl struct {
	lval  compileSymType
	stack [compileInitialStackSize]compileSymType
	char  int
}

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

func compileNewParser() compileParser {
	return &compileParserImpl{}
}

const compileFlag = -32768

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

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

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

	if !compileErrorVerbose {
		return "syntax error"
	}

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

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

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

	// Look for shiftable tokens.
	base := int(compilePact[state])
	for tok := TOKSTART; tok-1 < len(compileToknames); tok++ {
		if n := base + tok; n >= 0 && n < compileLast && int(compileChk[int(compileAct[n])]) == tok {
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}
	}

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

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

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

func compilelex1(lex compileLexer, lval *compileSymType) (char, token int) {
	token = 0
	char = lex.Lex(lval)
	if char <= 0 {
		token = int(compileTok1[0])
		goto out
	}
	if char < len(compileTok1) {
		token = int(compileTok1[char])
		goto out
	}
	if char >= compilePrivate {
		if char < compilePrivate+len(compileTok2) {
			token = int(compileTok2[char-compilePrivate])
			goto out
		}
	}
	for i := 0; i < len(compileTok3); i += 2 {
		token = int(compileTok3[i+0])
		if token == char {
			token = int(compileTok3[i+1])
			goto out
		}
	}

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

func compileParse(compilelex compileLexer) int {
	return compileNewParser().Parse(compilelex)
}

func (compilercvr *compileParserImpl) Parse(compilelex compileLexer) int {
	var compilen int
	var compileVAL compileSymType
	var compileDollar []compileSymType
	_ = compileDollar // silence set and not used
	compileS := compilercvr.stack[:]

	Nerrs := 0   /* number of errors */
	Errflag := 0 /* error recovery flag */
	compilestate := 0
	compilercvr.char = -1
	compiletoken := -1 // compilercvr.char translated into internal numbering
	defer func() {
		// Make sure we report no lookahead when not parsing.
		compilestate = -1
		compilercvr.char = -1
		compiletoken = -1
	}()
	compilep := -1
	goto compilestack

ret0:
	return 0

ret1:
	return 1

compilestack:
	/* put a state and value onto the stack */
	if compileDebug >= 4 {
		__yyfmt__.Printf("char %v in %v\n", compileTokname(compiletoken), compileStatname(compilestate))
	}

	compilep++
	if compilep >= len(compileS) {
		nyys := make([]compileSymType, len(compileS)*2)
		copy(nyys, compileS)
		compileS = nyys
	}
	compileS[compilep] = compileVAL
	compileS[compilep].yys = compilestate

compilenewstate:
	compilen = int(compilePact[compilestate])
	if compilen <= compileFlag {
		goto compiledefault /* simple state */
	}
	if compilercvr.char < 0 {
		compilercvr.char, compiletoken = compilelex1(compilelex, &compilercvr.lval)
	}
	compilen += compiletoken
	if compilen < 0 || compilen >= compileLast {
		goto compiledefault
	}
	compilen = int(compileAct[compilen])
	if int(compileChk[compilen]) == compiletoken { /* valid shift */
		compilercvr.char = -1
		compiletoken = -1
		compileVAL = compilercvr.lval
		compilestate = compilen
		if Errflag > 0 {
			Errflag--
		}
		goto compilestack
	}

compiledefault:
	/* default state action */
	compilen = int(compileDef[compilestate])
	if compilen == -2 {
		if compilercvr.char < 0 {
			compilercvr.char, compiletoken = compilelex1(compilelex, &compilercvr.lval)
		}

		/* look through exception table */
		xi := 0
		for {
			if compileExca[xi+0] == -1 && int(compileExca[xi+1]) == compilestate {
				break
			}
			xi += 2
		}
		for xi += 2; ; xi += 2 {
			compilen = int(compileExca[xi+0])
			if compilen < 0 || compilen == compiletoken {
				break
			}
		}
		compilen = int(compileExca[xi+1])
		if compilen < 0 {
			goto ret0
		}
	}
	if compilen == 0 {
		/* error ... attempt to resume parsing */
		switch Errflag {
		case 0: /* brand new error */
			compilelex.Error(compileErrorMessage(compilestate, compiletoken))
			Nerrs++
			if compileDebug >= 1 {
				__yyfmt__.Printf("%s", compileStatname(compilestate))
				__yyfmt__.Printf(" saw %s\n", compileTokname(compiletoken))
			}
			fallthrough

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

			/* find a state where "error" is a legal shift action */
			for compilep >= 0 {
				compilen = int(compilePact[compileS[compilep].yys]) + compileErrCode
				if compilen >= 0 && compilen < compileLast {
					compilestate = int(compileAct[compilen]) /* simulate a shift of "error" */
					if int(compileChk[compilestate]) == compileErrCode {
						goto compilestack
					}
				}

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

		case 3: /* no shift yet; clobber input char */
			if compileDebug >= 2 {
				__yyfmt__.Printf("error recovery discards %s\n", compileTokname(compiletoken))
			}
			if compiletoken == compileEofCode {
				goto ret1
			}
			compilercvr.char = -1
			compiletoken = -1
			goto compilenewstate /* try again in the same state */
		}
	}

	/* reduction by production compilen */
	if compileDebug >= 2 {
		__yyfmt__.Printf("reduce %v in:\n\t%v\n", compilen, compileStatname(compilestate))
	}

	compilent := compilen
	compilept := compilep
	_ = compilept // guard against "declared and not used"

	compilep -= int(compileR2[compilen])
	// compilep is now the index of $0. Perform the default action. Iff the
	// reduced production is ε, $1 is possibly out of range.
	if compilep+1 >= len(compileS) {
		nyys := make([]compileSymType, len(compileS)*2)
		copy(nyys, compileS)
		compileS = nyys
	}
	compileVAL = compileS[compilep+1]

	/* consult goto table to find next state */
	compilen = int(compileR1[compilen])
	compileg := int(compilePgo[compilen])
	compilej := compileg + compileS[compilep].yys + 1

	if compilej >= compileLast {
		compilestate = int(compileAct[compileg])
	} else {
		compilestate = int(compileAct[compilej])
		if int(compileChk[compilestate]) != -compilen {
			compilestate = int(compileAct[compileg])
		}
	}
	// dummy call; replaced with literal code
	switch compilent {

	case 1:
		compileDollar = compileS[compilept-1 : compilept+1]
//line compile_parser.y:25
		{
			compilelex.(*compileLexerAdapter).answer = compileDollar[1].node
			compileVAL.node = compileDollar[1].node
			return 0
		}
	case 2:
		compileDollar = compileS[compilept-1 : compilept+1]
//line compile_parser.y:33
		{
			compileVAL.node = compileDollar[1].node
		}
	case 3:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:37
		{
			compileVAL.node = arrayNode{items: compileDollar[2].nodes}
		}
	case 4:
		compileDollar = compileS[compilept-4 : compilept+1]
//line compile_parser.y:41
		{
			compileVAL.node = functionNode{name: compileDollar[1].name, args: compileDollar[3].nodes}
		}
	case 7:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:50
		{
			compileVAL.node = compileDollar[2].node
		}
	case 8:
		compileDollar = compileS[compilept-2 : compilept+1]
//line compile_parser.y:54
		{
			compileVAL.node = selectNameNode{base: compileDollar[1].node, key: compileDollar[2].name}
		}
	case 9:
		compileDollar = compileS[compilept-4 : compilept+1]
//line compile_parser.y:58
		{
			compileVAL.node = selectIndexExpr(compileDollar[1].node, compileDollar[3].node)
		}
	case 10:
		compileDollar = compileS[compilept-4 : compilept+1]
//line compile_parser.y:62
		{
			compileVAL.node = callNode{base: compileDollar[1].node, args: compileDollar[3].nodes}
		}
	case 11:
		compileDollar = compileS[compilept-1 : compilept+1]
//line compile_parser.y:68
		{
			compileVAL.node = variableNode{name: compileDollar[1].name}
		}
	case 12:
		compileDollar = compileS[compilept-2 : compilept+1]
//line compile_parser.y:72
		{
			compileVAL.node = selectNameNode{base: compileDollar[1].node, key: compileDollar[2].name}
		}
	case 13:
		compileDollar = compileS[compilept-4 : compilept+1]
//line compile_parser.y:76
		{
			compileVAL.node = selectIndexExpr(compileDollar[1].node, compileDollar[3].node)
		}
	case 14:
		compileDollar = compileS[compilept-4 : compilept+1]
//line compile_parser.y:80
		{
			compileVAL.node = callNode{base: compileDollar[1].node, args: compileDollar[3].nodes}
		}
	case 15:
		compileDollar = compileS[compilept-0 : compilept+1]
//line compile_parser.y:85
		{
			compileVAL.nodes = nil
		}
	case 16:
		compileDollar = compileS[compilept-1 : compilept+1]
//line compile_parser.y:89
		{
			compileVAL.nodes = []exprNode{compileDollar[1].node}
		}
	case 17:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:93
		{
			compileVAL.nodes = append(compileVAL.nodes, compileDollar[3].node)
		}
	case 19:
		compileDollar = compileS[compilept-2 : compilept+1]
//line compile_parser.y:99
		{
			compileVAL.node = unaryNode{op: "!", x: compileDollar[2].node}
		}
	case 20:
		compileDollar = compileS[compilept-2 : compilept+1]
//line compile_parser.y:102
		{
			compileVAL.node = unaryNode{op: "-", x: compileDollar[2].node}
		}
	case 21:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:105
		{
			compileVAL.node = binaryNode{op: opEq, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 22:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:108
		{
			compileVAL.node = binaryNode{op: opNeq, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 23:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:111
		{
			compileVAL.node = binaryNode{op: opGte, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 24:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:114
		{
			compileVAL.node = binaryNode{op: opLte, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 25:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:117
		{
			compileVAL.node = binaryNode{op: opRe, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 26:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:120
		{
			compileVAL.node = binaryNode{op: opNre, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 27:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:123
		{
			compileVAL.node = binaryNode{op: opNc, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 28:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:126
		{
			compileVAL.node = binaryNode{op: opIn, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 29:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:129
		{
			compileVAL.node = binaryNode{op: opLt, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 30:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:132
		{
			compileVAL.node = binaryNode{op: opGt, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 31:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:135
		{
			compileVAL.node = binaryNode{op: opMatch, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 32:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:138
		{
			compileVAL.node = binaryNode{op: opAdd, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 33:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:141
		{
			compileVAL.node = binaryNode{op: opSub, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 34:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:144
		{
			compileVAL.node = binaryNode{op: opMulti, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 35:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:147
		{
			compileVAL.node = binaryNode{op: opDiv, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 36:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:150
		{
			compileVAL.node = binaryNode{op: opMod, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 38:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:157
		{
			compileVAL.node = binaryNode{op: opAnd, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 39:
		compileDollar = compileS[compilept-3 : compilept+1]
//line compile_parser.y:160
		{
			compileVAL.node = binaryNode{op: opOr, left: compileDollar[1].node, right: compileDollar[3].node}
		}
	case 40:
		compileDollar = compileS[compilept-5 : compilept+1]
//line compile_parser.y:163
		{
			compileVAL.node = ternaryNode{cond: compileDollar[1].node, truthy: compileDollar[3].node, falsy: compileDollar[5].node}
		}
	}
	goto compilestack /* stack new state and value */
}