Method parseRuleRecursiveLeader

compiler/parser/parser.go:25184–25226

(rule *rule)

}

func (p *parser) parseRuleRecursiveLeader(rule *rule) (any, bool) {
	result, ok := p.getMemoized(rule)
	if ok {
		p.restore(result.end)
		return result.v, result.b
	}

	if p.debug {
		defer p.out(p.in("recursive " + rule.name))
	}

	var (
		depth      = 0
		startMark  = p.pt
		lastResult = resultTuple{nil, false, startMark}
		lastErrors = *p.errs
	)

	for {
		lastState := p.cloneState()
		p.setMemoized(startMark, rule, lastResult)
		val, ok := p.parseRule(rule)
		endMark := p.pt
		if p.debug {
			p.printIndent("RECURSIVE", fmt.Sprintf(
				"Rule %s depth %d: %t -> %s",
				rule.name, depth, ok, string(p.sliceFrom(startMark))))
		}
		if (!ok) || (endMark.offset <= lastResult.end.offset && depth != 0) {
			p.restoreState(lastState)
			*p.errs = lastErrors
			break
		}
		lastResult = resultTuple{val, ok, endMark}
		lastErrors = *p.errs
		p.restore(startMark)
		depth++
	}

	p.restore(lastResult.end)
	p.setMemoized(startMark, rule, lastResult)
	return lastResult.v, lastResult.b
}

func (p *parser) parseRuleRecursiveNoLeader(rule *rule) (any, bool) {
	return p.parseRule(rule)