Method parse_non_term

Source/3rdParty/yuescript/parser.cpp:932–1023

parse non-term rule.

// parse non-term rule.
bool _context::parse_non_term(rule& r) {
	// save the state of the rule
	rule::_state old_state = r.m_state;
	// restore the rule's state
	rule::_state_guard quard(old_state, &r.m_state);

	// success/failure result
	bool ok = false;

	// compute the new position
	size_t new_pos = m_pos.m_it - m_begin;

	// check if we have left recursion
	bool lr = new_pos == r.m_state.m_pos;

	// update the rule's state
	r.m_state.m_pos = new_pos;

	// handle the mode of the rule
	switch (r.m_state.m_mode) {
		// normal parse
		case rule::_PARSE:
			if (lr) {
				// first try to parse the rule by rejecting it, so alternative branches are examined
				r.m_state.m_mode = rule::_REJECT;
				ok = _parse_non_term(r);

				// if the first try is successful, try accepting the rule,
				// so other elements of the sequence are parsed
				if (ok) {
					r.m_state.m_mode = rule::_ACCEPT;

					// loop until no more parsing can be done
					for (;;) {
						// store the correct state, in order to backtrack if the call fails
						_state st(*this);

						// update the rule position to the current position,
						// because at this state the rule is resolving the left recursion
						r.m_state.m_pos = m_pos.m_it - m_begin;

						// if parsing fails, restore the last good state and stop
						if (!_parse_non_term(r)) {
							restore(st);
							break;
						}
					}

					// since the left recursion was resolved successfully,
					// return via a non-local exit
					throw _lr_ok(r.this_ptr());
				}
			} else {
				try {
					ok = _parse_non_term(r);
				} catch (const _lr_ok& ex) {
					// since left recursions may be mutual, we must test which rule's left recursion
					// was ended successfully