/// <summary> /// Memoize the result of a production at a given index. /// </summary> /// <param name="expansion">The production expansion.</param> /// <param name="index">The input position.</param> /// <param name="item">The result of the parse.</param> public void Memoize(Expansion expansion, int index, MatchItem <TInput, TResult> item) { Dictionary <int, Dictionary <int, MatchItem <TInput, TResult> > > expansion_dict; if (!memo_table.TryGetValue(expansion.Name, out expansion_dict)) { expansion_dict = new Dictionary <int, Dictionary <int, MatchItem <TInput, TResult> > >(); memo_table.Add(expansion.Name, expansion_dict); } Dictionary <int, MatchItem <TInput, TResult> > rule_dict; if (!expansion_dict.TryGetValue(expansion.Num, out rule_dict)) { rule_dict = new Dictionary <int, MatchItem <TInput, TResult> >(); expansion_dict.Add(expansion.Num, rule_dict); } rule_dict[index] = item; }
/// <summary> /// Call a grammar production, using memoization and handling left-recursion. /// </summary> /// <param name="memo">The memo for the current match.</param> /// <param name="ruleName">The name of the production.</param> /// <param name="index">The current index in the input stream.</param> /// <param name="production">The production itself.</param> /// <param name="args">Arguments to the production (can be null).</param> /// <returns>The result of the production at the given input index.</returns> protected MatchItem <TInput, TResult> _MemoCall ( MatchState <TInput, TResult> memo, string ruleName, int index, Action <MatchState <TInput, TResult>, int, IEnumerable <MatchItem <TInput, TResult> > > production, IEnumerable <MatchItem <TInput, TResult> > args ) { MatchItem <TInput, TResult> result; var expansion = new Expansion { Name = args == null ? ruleName : ruleName + string.Join(", ", args.Select(arg => arg.ToString()).ToArray()), Num = 0 }; // if we have a memo record, use that if (memo.TryGetMemo(expansion, index, out result)) { memo.Results.Push(result); return(result); } // if we are not handling left recursion, just call the production directly. if (!HandleLeftRecursion || Terminals.Contains(ruleName)) { production(memo, index, args); result = memo.Results.Peek(); memo.Memoize(expansion, index, result); if (result == null) { memo.AddError(index, () => "expected " + ruleName); } return(result); } // check for left-recursion LRRecord <MatchItem <TInput, TResult> > record; if (memo.TryGetLRRecord(expansion, index, out record)) { record.LRDetected = true; var involved = memo.CallStack .TakeWhile(rec => rec.CurrentExpansion.Name != expansion.Name) .Select(rec => rec.CurrentExpansion.Name); if (record.InvolvedRules != null) { record.InvolvedRules.UnionWith(involved); } else { record.InvolvedRules = new HashSet <string>(involved); } if (!memo.TryGetMemo(record.CurrentExpansion, index, out result)) { throw new MatcherException(index, "Problem with expansion " + record.CurrentExpansion); } memo.Results.Push(result); } // no lr information else { record = new LRRecord <MatchItem <TInput, TResult> >(); record.LRDetected = false; record.NumExpansions = 1; record.CurrentExpansion = new Expansion { Name = expansion.Name, Num = record.NumExpansions }; record.CurrentNextIndex = -1; memo.Memoize(record.CurrentExpansion, index, null); memo.StartLRRecord(expansion, index, record); memo.CallStack.Push(record); while (true) { production(memo, index, args); result = memo.Results.Pop(); // do we need to keep trying the expansions? if (record.LRDetected && result != null && result.NextIndex > record.CurrentNextIndex) { record.NumExpansions = record.NumExpansions + 1; record.CurrentExpansion = new Expansion { Name = expansion.Name, Num = record.NumExpansions }; record.CurrentNextIndex = result != null ? result.NextIndex : 0; memo.Memoize(record.CurrentExpansion, index, result); record.CurrentResult = result; } // we are done trying to expand else { if (record.LRDetected) { result = record.CurrentResult; } memo.ForgetLRRecord(expansion, index); memo.Results.Push(result); // if we are not involved in any left-recursion expansions above us, memoize memo.CallStack.Pop(); bool found_lr = memo.CallStack.Any(rec => rec.InvolvedRules != null && rec.InvolvedRules.Contains(expansion.Name)); if (!found_lr) { memo.Memoize(expansion, index, result); } if (result == null) { memo.AddError(index, () => "expected " + expansion.Name); } break; } } } return(result); }