func()

in json/parse.go [176:254]

• 60 lines of code
• 24 McCabe index (conditional complexity)

func (p *Parser) feedUntil(b []byte) (int, bool, error) {
	var (
		err      error
		reported bool
		orig     = b
	)

	for !reported && len(b) > 0 {
		switch p.currentState {
		case failedState:
			if p.err == nil {
				p.err = errors.New("invalid parser state")
			}
			return 0, false, p.err
		case startState:
			b, reported, err = p.stepStart(b)

		case dictState:
			b, reported, err = p.stepDict(b, true)

		case dictNextFieldState:
			b, reported, err = p.stepDict(b, false)

		case dictFieldState:
			b, err = p.stepDictKey(b)

		case dictFieldValueSep:
			if b = trimLeft(b); len(b) > 0 {
				if b[0] != ':' {
					err = errExpectColon
				}
				b = b[1:]
				p.currentState = dictFieldValue
			}

		case dictFieldValue:
			b, reported, err = p.stepValue(b, dictFieldStateEnd)

		case dictFieldStateEnd:
			b, reported, err = p.stepDictValueEnd(b)

		case arrState:
			b, reported, err = p.stepArray(b, true)

		case arrStateValue:
			b, _, err = p.stepValue(b, arrStateNext)

		case arrStateNext:
			b, reported, err = p.stepArrValueEnd(b)

		case nullState:
			b, reported, err = p.stepNULL(b)

		case trueState:
			b, reported, err = p.stepTRUE(b)

		case falseState:
			b, reported, err = p.stepFALSE(b)

		case stringState:
			b, reported, err = p.stepString(b)

		case numberState:
			b, reported, err = p.stepNumber(b)

		default:
			return 0, false, errFailing
		}

		if err != nil {
			break
		}

		reported = reported && len(p.states) == 0
	}

	consumed := len(orig) - len(b)
	return consumed, reported, err
}