public StatefullStackNode StartRecursionRuleCall(ParserNode.RecursiveParserNode source) { if (source == null) { throw new ArgumentNullException(); } return(new StatefullStackNode(this, -1, source)); }
/* * * private void SkipOmitPattern() * { * if (_omitRoot != null) * { * string spaces; * _currState.TryRunFsm(((ParserNode.FsmParserNode)((ParserNode.Sequence)_omitRoot).Childs[0]).Fsm, out spaces); * } * } * * void IParserNodeVisitor.VisitFsm(ParserNode.FsmParserNode fsmParserNode) * { * if (_currState.PrevNode == fsmParserNode.Parent) * { * this.SkipOmitPattern(); * * string text; * var from = _currState.Location; * if (_currState.TryRunFsm(fsmParserNode.Fsm, out text)) * { * var to = _currState.Location; * _currState = _currState.TerminalParsed(from, to, text).ExitNode(); * * this.SkipOmitPattern(); * } * else * { * _currState = _currState.TerminalFailed().ExitNode(); * } * } * else * { * throw new InvalidOperationException(); * } * } * */ void IParserNodeVisitor.VisitRecursive(ParserNode.RecursiveParserNode recursiveParserNode) { if (_currState.PrevNode == recursiveParserNode.Parent) { _currState = _currState.EnterNode(recursiveParserNode.Target); } else if (_currState.PrevNode == recursiveParserNode.Target) { _currState = _currState.ExitNode(); } else { throw new InvalidOperationException(); } }
private StatefullStackNode(StatefullStackNode prev, int childsCount, ParserNode.RecursiveParserNode source) { this.Prev = prev; this.ChildsCount = childsCount; this.RecursionSource = source; }
public void VisitRecursive(ParserNode.RecursiveParserNode recursiveParserNode) { this.LogLine("{0}", recursiveParserNode); _v.VisitRecursive(recursiveParserNode); }
void IRuleExpressionVisitor.VisitRuleUsage(RuleExpression.RuleUsage ruleUsage) { if (_currContext.invocationCount == 0) { // _log.WriteLine("entering from [{0}] to [{1}]", _currContext.rule == null ? "<NULL>" : _currContext.rule.Name, ruleUsage.RuleName).Push(); RuleExpression expr; if (_nav.TryEnterParameterContext(ruleUsage.RuleName, out expr)) { _currContext = _currContext.ForChildExpression(expr, _nav.CurrRuleInfo.Rule); } else { GrammarNavigator.RuleInfo ruleInfo; //if (!_nav.TryResolveRule(ruleUsage.RuleName, out ruleInfo)) if (!_nav.TryEnterRule(ruleUsage.RuleName, out ruleInfo)) { throw new InvalidOperationException(string.Format("Referenced rule [{0}] not found!", ruleUsage.RuleName)); } var rule = ruleInfo.IsExplicitRule ? ruleInfo.Rule : this.ExpandExtensibleRule(ruleInfo); RuleExpression expression; if (this.TryRewriteRecursionCalls(rule, out expression)) { ParserNode recursiveTargetNode; if (_cachedMaterializedRewritedRuleEnterByPath.TryGetValue(ruleInfo.NamePath, out recursiveTargetNode)) { _nav.Exit(); var node = new ParserNode.RecursiveParserNode(rule, ruleUsage); node.SetTarget(recursiveTargetNode); _currContext = _currContext.ForParentExpression(node); return; } } this.SetRuleParamsInfo(rule, ruleUsage); var entryContext = this.FindRuleRecursiveInvocationNode(rule, ruleUsage); if (entryContext != null) { //_log.WriteLine("recursively exiting from [{0}] to [{1}]", ruleUsage.RuleName, _currContext.rule.Name).Pop(); _nav.Exit(); var node = new ParserNode.RecursiveParserNode(rule, ruleUsage); _recursiveNodes.Add(node); _currContext = _currContext.ForParentExpression(node); } else { _currContext = _currContext.ForChildExpression(expression, rule); } // _nav.Enter(ruleUsage.RuleName); } } else if (_currContext.invocationCount == 1) { if (_currContext.childEntries.node == null || _currContext.childEntries.prev != null) { throw new InvalidOperationException(); } var ruleNamePath = _nav.CurrRuleInfo.NamePath; //_log.WriteLine("exiting from [{0}] to [{1}]", ruleUsage.RuleName, _currContext.rule.Name).Pop(); _nav.Exit(); var node = new ParserNode.RuleCall( _currContext.rule, _currContext.expression, _currContext.childEntries.node ); if (!_cachedMaterializedRewritedRuleEnterByPath.ContainsKey(ruleNamePath)) { _cachedMaterializedRewritedRuleEnterByPath.Add(ruleNamePath, node); } _currContext = _currContext.ForParentExpression(node); } else { throw new InvalidOperationException(); } }
void IParserNodeVisitor.VisitRecursive(ParserNode.RecursiveParserNode recursiveParserNode) { this.PrintNode(recursiveParserNode); }