expr.go

// Code generated by goyacc -o expr.go -p expr expr.y. DO NOT EDIT.

//line expr.y:2
package calcu

import __yyfmt__ "fmt"

//line expr.y:2

func setErr(exprlex exprLexer, err error) int {
	exprlex.(*lexer).setErr(err)
	return 1
}

func setRoot(exprlex exprLexer, node Node) {
	exprlex.(*lexer).setRoot(node)
}

//line expr.y:15
type exprSymType struct {
	yys   int
	token int
	str   string

	list *List
	node Node
}

const IDENT = 57346
const NUM = 57347
const UNIT = 57348
const LITERALSTR = 57349
const LITERALMV = 57350

var exprToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"IDENT",
	"NUM",
	"UNIT",
	"LITERALSTR",
	"LITERALMV",
	"'+'",
	"'-'",
	"'*'",
	"'/'",
	"'='",
	"'('",
	"')'",
	"';'",
	"','",
}

var exprStatenames = [...]string{}

const exprEofCode = 1
const exprErrCode = 2
const exprInitialStackSize = 16

//line expr.y:156

//line yacctab:1
var exprExca = [...]int8{
	-1, 1,
	1, -1,
	-2, 0,
	-1, 22,
	14, 16,
	-2, 7,
}

const exprPrivate = 57344

const exprLast = 60

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

var exprPact = [...]int16{
	32, -1000, -14, -15, -6, 10, -1000, -1000, -1, 41,
	-1000, 7, -1000, 47, -1000, 19, -1000, -1000, 34, 34,
	47, -1000, -1000, -1000, 27, 34, 34, 34, 34, -1000,
	6, -1000, -1000, 0, 0, -1000, -1000, -1000,
}

var exprPgo = [...]int8{
	0, 52, 50, 0, 33, 5, 47, 40,
}

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

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

var exprChk = [...]int16{
	-1000, -7, -4, -6, -1, 4, 16, 16, 14, 13,
	15, -2, -5, -3, 7, 5, 8, 4, 14, 10,
	-3, -4, 4, 15, 17, 9, 10, 11, 12, 6,
	-3, -3, -5, -3, -3, -3, -3, 15,
}

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

var exprTok1 = [...]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, 3, 3, 3, 3, 3, 3, 3,
	14, 15, 11, 9, 17, 10, 3, 12, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 16,
	3, 13,
}

var exprTok2 = [...]int8{
	2, 3, 4, 5, 6, 7, 8,
}

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

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

//line yaccpar:1

/*	parser for yacc output	*/

var (
	exprDebug        = 0
	exprErrorVerbose = false
)

type exprLexer interface {
	Lex(lval *exprSymType) int
	Error(s string)
}

type exprParser interface {
	Parse(exprLexer) int
	Lookahead() int
}

type exprParserImpl struct {
	lval  exprSymType
	stack [exprInitialStackSize]exprSymType
	char  int
}

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

func exprNewParser() exprParser {
	return &exprParserImpl{}
}

const exprFlag = -1000

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

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

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

	if !exprErrorVerbose {
		return "syntax error"
	}

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

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

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

	// Look for shiftable tokens.
	base := int(exprPact[state])
	for tok := TOKSTART; tok-1 < len(exprToknames); tok++ {
		if n := base + tok; n >= 0 && n < exprLast && int(exprChk[int(exprAct[n])]) == tok {
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}
	}

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

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

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

func exprlex1(lex exprLexer, lval *exprSymType) (char, token int) {
	token = 0
	char = lex.Lex(lval)
	if char <= 0 {
		token = int(exprTok1[0])
		goto out
	}
	if char < len(exprTok1) {
		token = int(exprTok1[char])
		goto out
	}
	if char >= exprPrivate {
		if char < exprPrivate+len(exprTok2) {
			token = int(exprTok2[char-exprPrivate])
			goto out
		}
	}
	for i := 0; i < len(exprTok3); i += 2 {
		token = int(exprTok3[i+0])
		if token == char {
			token = int(exprTok3[i+1])
			goto out
		}
	}

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

func exprParse(exprlex exprLexer) int {
	return exprNewParser().Parse(exprlex)
}

func (exprrcvr *exprParserImpl) Parse(exprlex exprLexer) int {
	var exprn int
	var exprVAL exprSymType
	var exprDollar []exprSymType
	_ = exprDollar // silence set and not used
	exprS := exprrcvr.stack[:]

	Nerrs := 0   /* number of errors */
	Errflag := 0 /* error recovery flag */
	exprstate := 0
	exprrcvr.char = -1
	exprtoken := -1 // exprrcvr.char translated into internal numbering
	defer func() {
		// Make sure we report no lookahead when not parsing.
		exprstate = -1
		exprrcvr.char = -1
		exprtoken = -1
	}()
	exprp := -1
	goto exprstack

ret0:
	return 0

ret1:
	return 1

exprstack:
	/* put a state and value onto the stack */
	if exprDebug >= 4 {
		__yyfmt__.Printf("char %v in %v\n", exprTokname(exprtoken), exprStatname(exprstate))
	}

	exprp++
	if exprp >= len(exprS) {
		nyys := make([]exprSymType, len(exprS)*2)
		copy(nyys, exprS)
		exprS = nyys
	}
	exprS[exprp] = exprVAL
	exprS[exprp].yys = exprstate

exprnewstate:
	exprn = int(exprPact[exprstate])
	if exprn <= exprFlag {
		goto exprdefault /* simple state */
	}
	if exprrcvr.char < 0 {
		exprrcvr.char, exprtoken = exprlex1(exprlex, &exprrcvr.lval)
	}
	exprn += exprtoken
	if exprn < 0 || exprn >= exprLast {
		goto exprdefault
	}
	exprn = int(exprAct[exprn])
	if int(exprChk[exprn]) == exprtoken { /* valid shift */
		exprrcvr.char = -1
		exprtoken = -1
		exprVAL = exprrcvr.lval
		exprstate = exprn
		if Errflag > 0 {
			Errflag--
		}
		goto exprstack
	}

exprdefault:
	/* default state action */
	exprn = int(exprDef[exprstate])
	if exprn == -2 {
		if exprrcvr.char < 0 {
			exprrcvr.char, exprtoken = exprlex1(exprlex, &exprrcvr.lval)
		}

		/* look through exception table */
		xi := 0
		for {
			if exprExca[xi+0] == -1 && int(exprExca[xi+1]) == exprstate {
				break
			}
			xi += 2
		}
		for xi += 2; ; xi += 2 {
			exprn = int(exprExca[xi+0])
			if exprn < 0 || exprn == exprtoken {
				break
			}
		}
		exprn = int(exprExca[xi+1])
		if exprn < 0 {
			goto ret0
		}
	}
	if exprn == 0 {
		/* error ... attempt to resume parsing */
		switch Errflag {
		case 0: /* brand new error */
			exprlex.Error(exprErrorMessage(exprstate, exprtoken))
			Nerrs++
			if exprDebug >= 1 {
				__yyfmt__.Printf("%s", exprStatname(exprstate))
				__yyfmt__.Printf(" saw %s\n", exprTokname(exprtoken))
			}
			fallthrough

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

			/* find a state where "error" is a legal shift action */
			for exprp >= 0 {
				exprn = int(exprPact[exprS[exprp].yys]) + exprErrCode
				if exprn >= 0 && exprn < exprLast {
					exprstate = int(exprAct[exprn]) /* simulate a shift of "error" */
					if int(exprChk[exprstate]) == exprErrCode {
						goto exprstack
					}
				}

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

		case 3: /* no shift yet; clobber input char */
			if exprDebug >= 2 {
				__yyfmt__.Printf("error recovery discards %s\n", exprTokname(exprtoken))
			}
			if exprtoken == exprEofCode {
				goto ret1
			}
			exprrcvr.char = -1
			exprtoken = -1
			goto exprnewstate /* try again in the same state */
		}
	}

	/* reduction by production exprn */
	if exprDebug >= 2 {
		__yyfmt__.Printf("reduce %v in:\n\t%v\n", exprn, exprStatname(exprstate))
	}

	exprnt := exprn
	exprpt := exprp
	_ = exprpt // guard against "declared and not used"

	exprp -= int(exprR2[exprn])
	// exprp is now the index of $0. Perform the default action. Iff the
	// reduced production is ε, $1 is possibly out of range.
	if exprp+1 >= len(exprS) {
		nyys := make([]exprSymType, len(exprS)*2)
		copy(nyys, exprS)
		exprS = nyys
	}
	exprVAL = exprS[exprp+1]

	/* consult goto table to find next state */
	exprn = int(exprR1[exprn])
	exprg := int(exprPgo[exprn])
	exprj := exprg + exprS[exprp].yys + 1

	if exprj >= exprLast {
		exprstate = int(exprAct[exprg])
	} else {
		exprstate = int(exprAct[exprj])
		if int(exprChk[exprstate]) != -exprn {
			exprstate = int(exprAct[exprg])
		}
	}
	// dummy call; replaced with literal code
	switch exprnt {

	case 1:
		exprDollar = exprS[exprpt-0 : exprpt+1]
//line expr.y:36
		{
			setRoot(exprlex, nil)
		}
	case 2:
		exprDollar = exprS[exprpt-2 : exprpt+1]
//line expr.y:37
		{
			setRoot(exprlex, exprDollar[1].node)
		}
	case 3:
		exprDollar = exprS[exprpt-2 : exprpt+1]
//line expr.y:38
		{
			setRoot(exprlex, exprDollar[1].node)
		}
	case 4:
		exprDollar = exprS[exprpt-2 : exprpt+1]
//line expr.y:42
		{
			n, err := makeMeasureValue(exprDollar[1].str, exprDollar[2].str)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	case 5:
		exprDollar = exprS[exprpt-1 : exprpt+1]
//line expr.y:50
		{
			n, err := makeMeasureValueFromString(exprDollar[1].str)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	case 6:
		exprDollar = exprS[exprpt-1 : exprpt+1]
//line expr.y:58
		{
			n, err := makeUnitlessMeasureValue(exprDollar[1].str)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	case 7:
		exprDollar = exprS[exprpt-1 : exprpt+1]
//line expr.y:66
		{
			exprVAL.node = makeVariable(exprDollar[1].str)
		}
	case 8:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:70
		{
			exprVAL.node = makeBinaryExpr(exprDollar[1].node, exprDollar[3].node, "+")
		}
	case 9:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:74
		{
			exprVAL.node = makeBinaryExpr(exprDollar[1].node, exprDollar[3].node, "-")
		}
	case 10:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:78
		{
			exprVAL.node = makeBinaryExpr(exprDollar[1].node, exprDollar[3].node, "*")
		}
	case 11:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:82
		{
			exprVAL.node = makeBinaryExpr(exprDollar[1].node, exprDollar[3].node, "/")
		}
	case 12:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:86
		{
			exprVAL.node = makeParenExpr(exprDollar[2].node)
		}
	case 13:
		exprDollar = exprS[exprpt-2 : exprpt+1]
//line expr.y:90
		{
			exprVAL.node = makeUnaryExpr(exprDollar[2].node)
		}
	case 14:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:96
		{
			n, err := makeFuncCall(exprDollar[1].str)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	case 15:
		exprDollar = exprS[exprpt-4 : exprpt+1]
//line expr.y:104
		{
			n, err := makeFuncCall(exprDollar[1].str, exprDollar[3].list.elements...)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	case 17:
		exprDollar = exprS[exprpt-1 : exprpt+1]
//line expr.y:117
		{
			l := makeList()
			l.Append(exprDollar[1].node)
			exprVAL.list = l
		}
	case 18:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:123
		{
			exprVAL.list.Append(exprDollar[3].node)
		}
	case 19:
		exprDollar = exprS[exprpt-1 : exprpt+1]
//line expr.y:129
		{
			exprVAL.node = exprDollar[1].node
		}
	case 20:
		exprDollar = exprS[exprpt-1 : exprpt+1]
//line expr.y:133
		{
			exprVAL.node = makeLiteralString(exprDollar[1].str)
		}
	case 21:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:139
		{
			n, err := makeAssignment(exprDollar[1].str, exprDollar[3].node)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	case 22:
		exprDollar = exprS[exprpt-3 : exprpt+1]
//line expr.y:147
		{
			n, err := makeAssignment(exprDollar[1].str, exprDollar[3].node)
			if err != nil {
				return setErr(exprlex, err)
			}
			exprVAL.node = n
		}
	}
	goto exprstack /* stack new state and value */
}