func()

in parser.go [279:475]

• 163 lines of code
• 36 McCabe index (conditional complexity)

func (hyperkvrcvr *hyperkvParserImpl) Parse(hyperkvlex hyperkvLexer) int {
	var hyperkvn int
	var hyperkvVAL hyperkvSymType
	var hyperkvDollar []hyperkvSymType
	_ = hyperkvDollar // silence set and not used
	hyperkvS := hyperkvrcvr.stack[:]

	Nerrs := 0   /* number of errors */
	Errflag := 0 /* error recovery flag */
	hyperkvstate := 0
	hyperkvrcvr.char = -1
	hyperkvtoken := -1 // hyperkvrcvr.char translated into internal numbering
	defer func() {
		// Make sure we report no lookahead when not parsing.
		hyperkvstate = -1
		hyperkvrcvr.char = -1
		hyperkvtoken = -1
	}()
	hyperkvp := -1
	goto hyperkvstack

ret0:
	return 0

ret1:
	return 1

hyperkvstack:
	/* put a state and value onto the stack */
	if hyperkvDebug >= 4 {
		__yyfmt__.Printf("char %v in %v\n", hyperkvTokname(hyperkvtoken), hyperkvStatname(hyperkvstate))
	}

	hyperkvp++
	if hyperkvp >= len(hyperkvS) {
		nyys := make([]hyperkvSymType, len(hyperkvS)*2)
		copy(nyys, hyperkvS)
		hyperkvS = nyys
	}
	hyperkvS[hyperkvp] = hyperkvVAL
	hyperkvS[hyperkvp].yys = hyperkvstate

hyperkvnewstate:
	hyperkvn = int(hyperkvPact[hyperkvstate])
	if hyperkvn <= hyperkvFlag {
		goto hyperkvdefault /* simple state */
	}
	if hyperkvrcvr.char < 0 {
		hyperkvrcvr.char, hyperkvtoken = hyperkvlex1(hyperkvlex, &hyperkvrcvr.lval)
	}
	hyperkvn += hyperkvtoken
	if hyperkvn < 0 || hyperkvn >= hyperkvLast {
		goto hyperkvdefault
	}
	hyperkvn = int(hyperkvAct[hyperkvn])
	if int(hyperkvChk[hyperkvn]) == hyperkvtoken { /* valid shift */
		hyperkvrcvr.char = -1
		hyperkvtoken = -1
		hyperkvVAL = hyperkvrcvr.lval
		hyperkvstate = hyperkvn
		if Errflag > 0 {
			Errflag--
		}
		goto hyperkvstack
	}

hyperkvdefault:
	/* default state action */
	hyperkvn = int(hyperkvDef[hyperkvstate])
	if hyperkvn == -2 {
		if hyperkvrcvr.char < 0 {
			hyperkvrcvr.char, hyperkvtoken = hyperkvlex1(hyperkvlex, &hyperkvrcvr.lval)
		}

		/* look through exception table */
		xi := 0
		for {
			if hyperkvExca[xi+0] == -1 && int(hyperkvExca[xi+1]) == hyperkvstate {
				break
			}
			xi += 2
		}
		for xi += 2; ; xi += 2 {
			hyperkvn = int(hyperkvExca[xi+0])
			if hyperkvn < 0 || hyperkvn == hyperkvtoken {
				break
			}
		}
		hyperkvn = int(hyperkvExca[xi+1])
		if hyperkvn < 0 {
			goto ret0
		}
	}
	if hyperkvn == 0 {
		/* error ... attempt to resume parsing */
		switch Errflag {
		case 0: /* brand new error */
			hyperkvlex.Error(hyperkvErrorMessage(hyperkvstate, hyperkvtoken))
			Nerrs++
			if hyperkvDebug >= 1 {
				__yyfmt__.Printf("%s", hyperkvStatname(hyperkvstate))
				__yyfmt__.Printf(" saw %s\n", hyperkvTokname(hyperkvtoken))
			}
			fallthrough

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

			/* find a state where "error" is a legal shift action */
			for hyperkvp >= 0 {
				hyperkvn = int(hyperkvPact[hyperkvS[hyperkvp].yys]) + hyperkvErrCode
				if hyperkvn >= 0 && hyperkvn < hyperkvLast {
					hyperkvstate = int(hyperkvAct[hyperkvn]) /* simulate a shift of "error" */
					if int(hyperkvChk[hyperkvstate]) == hyperkvErrCode {
						goto hyperkvstack
					}
				}

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

		case 3: /* no shift yet; clobber input char */
			if hyperkvDebug >= 2 {
				__yyfmt__.Printf("error recovery discards %s\n", hyperkvTokname(hyperkvtoken))
			}
			if hyperkvtoken == hyperkvEofCode {
				goto ret1
			}
			hyperkvrcvr.char = -1
			hyperkvtoken = -1
			goto hyperkvnewstate /* try again in the same state */
		}
	}

	/* reduction by production hyperkvn */
	if hyperkvDebug >= 2 {
		__yyfmt__.Printf("reduce %v in:\n\t%v\n", hyperkvn, hyperkvStatname(hyperkvstate))
	}

	hyperkvnt := hyperkvn
	hyperkvpt := hyperkvp
	_ = hyperkvpt // guard against "declared and not used"

	hyperkvp -= int(hyperkvR2[hyperkvn])
	// hyperkvp is now the index of $0. Perform the default action. Iff the
	// reduced production is ε, $1 is possibly out of range.
	if hyperkvp+1 >= len(hyperkvS) {
		nyys := make([]hyperkvSymType, len(hyperkvS)*2)
		copy(nyys, hyperkvS)
		hyperkvS = nyys
	}
	hyperkvVAL = hyperkvS[hyperkvp+1]

	/* consult goto table to find next state */
	hyperkvn = int(hyperkvR1[hyperkvn])
	hyperkvg := int(hyperkvPgo[hyperkvn])
	hyperkvj := hyperkvg + hyperkvS[hyperkvp].yys + 1

	if hyperkvj >= hyperkvLast {
		hyperkvstate = int(hyperkvAct[hyperkvg])
	} else {
		hyperkvstate = int(hyperkvAct[hyperkvj])
		if int(hyperkvChk[hyperkvstate]) != -hyperkvn {
			hyperkvstate = int(hyperkvAct[hyperkvg])
		}
	}
	// dummy call; replaced with literal code
	switch hyperkvnt {

	case 1:
		hyperkvDollar = hyperkvS[hyperkvpt-1 : hyperkvpt+1]
//line kvp.y:70
		{
			hyperkvVAL.entries = make([]*HyperkvItem, 0)
		}
	case 2:
		hyperkvDollar = hyperkvS[hyperkvpt-2 : hyperkvpt+1]
//line kvp.y:74
		{
			hyperkvVAL.entries = append(hyperkvDollar[2].entries, hyperkvDollar[1].entry)
			hyperkvlex.(*hyperkvLexerImpl).Result = hyperkvVAL.entries
		}
	case 3:
		hyperkvDollar = hyperkvS[hyperkvpt-4 : hyperkvpt+1]
//line kvp.y:81
		{
			hyperkvVAL.entry = &HyperkvItem{Key: hyperkvDollar[1].content, Value: hyperkvDollar[3].content}
		}
	}
	goto hyperkvstack /* stack new state and value */
}