#pragma warning disable 0219 /// <summary> /// Matches any input. /// </summary> /// <param name="memo">Memo.</param> /// <param name="index">Index.</param> protected MatchItem <TInput, TResult> _ParseAny(Memo <TInput, TResult> memo, ref int index) { if (!(memo.InputString != null && index >= memo.InputString.Length)) { try { var _temp = memo.InputList != null ? memo.InputList[index] : memo.InputEnumerable.ElementAt(index); var result = new MatchItem <TInput, TResult> { StartIndex = index, NextIndex = index + 1, InputEnumerable = memo.InputEnumerable, }; ++index; memo.Results.Push(result); return(result); } catch { } } memo.Results.Push(null); memo.AddError(index, () => "unexpected end of file"); return(null); }
/// <summary> /// Try to match the input. /// </summary> /// <param name="input">The input to be matched.</param> /// <param name="production">The top-level grammar production (rule) of the generated parser class to use.</param> /// <returns>The result of the match.</returns> public virtual MatchResult <TInput, TResult> GetMatch(IEnumerable <TInput> input, Action <Memo <TInput, TResult>, int, IEnumerable <MatchItem <TInput, TResult> > > production) { var memo = new Memo <TInput, TResult>(input); MatchItem <TInput, TResult> result = null; if (BeforeMatch != null) { BeforeMatch(memo, input, production); } try { if (Terminals == null) { Terminals = new HashSet <string>(); } result = _MemoCall(memo, production.Method.Name, 0, production, null); } catch (MatcherException me) { memo.ClearErrors(); memo.AddError(me.Index, me.Message); } catch (Exception e) { memo.ClearErrors(); memo.AddError(0, e.Message #if DEBUG + "\n" + e.StackTrace #endif ); } memo.ClearMemoTable(); // allow memo tables to be gc'd var match_result = result != null ? new MatchResult <TInput, TResult>(this, memo, true, result.StartIndex, result.NextIndex, result.Results, memo.LastError, memo.LastErrorIndex) : new MatchResult <TInput, TResult>(this, memo, false, -1, -1, null, memo.LastError, memo.LastErrorIndex); if (AfterMatch != null) { AfterMatch(match_result); } return(match_result); }
#pragma warning restore 0219 /// <summary> /// Matches any input in an argument stream. /// </summary> /// <param name="memo">Memo.</param> /// <param name="item_index">Item index.</param> /// <param name="input_index">Input index.</param> /// <param name="args">Argument stream.</param> protected MatchItem <TInput, TResult> _ParseAnyArgs(Memo <TInput, TResult> memo, ref int item_index, ref int input_index, IEnumerable <MatchItem <TInput, TResult> > args) { if (args != null) { try { if (input_index == 0) { var _temp = args.ElementAt(item_index); ++item_index; memo.ArgResults.Push(_temp); return(_temp); } } catch { } } memo.ArgResults.Push(null); memo.AddError(input_index, () => "not enough arguments"); return(null); }
/// <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 ( Memo <TInput, TResult> memo, string ruleName, int index, Action <Memo <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); }