/// <summary> /// Inner parse method /// </summary> /// <param name="scanner">scanner</param> /// <returns>the match</returns> protected override ParserMatch ParseMain(IScanner scanner) { long offset = scanner.Offset; ParserMatch m = FirstParser.Parse(scanner); if (!m.Success) { scanner.Seek(offset); return(m); } while (!scanner.AtEnd) { offset = scanner.Offset; ParserMatch b = SecondParser.Parse(scanner); if (!b.Success) { scanner.Seek(offset); return(m); } ParserMatch a = FirstParser.Parse(scanner); if (!a.Success) { scanner.Seek(offset); return(m); } m.Concat(b); m.Concat(a); } return(m); }
public override SyntaxTreeNode Parse(string text) { var firstResult = FirstParser.Parse(text); if (firstResult is null) { return(null); } var secondResult = SecondParser.Parse(firstResult.Rest); if (secondResult is null) { return(null); } var children = new List <SyntaxTreeNode> { firstResult, secondResult }; // [todo] change it on concatination var parsedText = secondResult.Rest != string.Empty ? text.Replace(secondResult.Rest, "") : text; return(new SyntaxTreeNode(parsedText, secondResult.Rest, this, children)); }
/// <summary> /// Inner parse method /// </summary> /// <param name="scanner">scanner</param> /// <returns>the match</returns> protected override ParserMatch ParseMain(IScanner scanner) { // save scanner state long offset = scanner.Offset; // apply the first parser ParserMatch m = FirstParser.Parse(scanner); // if m1 successful, do m2 if (m.Success) { ParserMatch m2 = SecondParser.Parse(scanner); if (m2.Success) { m.Concat(m2); } else { m = ParserMatch.CreateFailureMatch(scanner, offset); } } // restoring parser failed, rewind scanner if (!m.Success) { scanner.Seek(offset); } return(m); }
/// <summary> /// Inner parse method /// </summary> /// <param name="scanner">scanner</param> /// <returns>the match</returns> protected override ParserMatch ParseMain(IScanner scanner) { // save scanner state long offset = scanner.Offset; // apply the first parser ParserMatch m = FirstParser.Parse(scanner); // if m1 successful, do m2 if (m.Success) { return(m); } // not found try the next scanner.Seek(offset); // apply the second parser m = SecondParser.Parse(scanner); if (m.Success) { return(m); } scanner.Seek(offset); return(ParserMatch.CreateFailureMatch(scanner)); }
public override Parser <TInput> VisitFirst(FirstParser <TInput> parser) { if (state.State == 0) { state.State = 1; return(parser.Parsers[0]); } else if (state.LastResult < 0) { if (state.LastResult < state.BestFailedResult) { state.BestFailedResult = state.LastResult; } if (state.State < parser.Parsers.Count) { var next = parser.Parsers[state.State]; state.State++; return(next); } else { state.InputLength = state.BestFailedResult; return(null); } } else { state.InputLength = state.LastResult; return(null); } }
public override void InitGrammar(Grammar grammar, string ruleName) { Grammar = grammar; RuleName = ruleName; FirstParser.InitGrammar(grammar, ruleName); SecondParser.InitGrammar(grammar, ruleName); }
public void Parse_Test() { var parser = new FirstParser <char, char>(new[] { Match('a'), Match('X'), Match('1') }); parser.CanMatch("a").Should().BeTrue(); parser.CanMatch("X").Should().BeTrue(); parser.CanMatch("1").Should().BeTrue(); parser.CanMatch("b").Should().BeFalse(); }
private void BtnMargeClick(object sender, EventArgs e) { listPreview.Items.Clear(); var listMergedQuote = QuoteParseManager.Merge(listResultContent.Items.Cast <string>().ToList()); if (rbtnFirstParserSaveFormat.Checked) { ListStringMergedQuotes = SecondParser.QuoteListToString(listMergedQuote).ToArray(); } if (rbtnSecondParserSaveFormat.Checked) { ListStringMergedQuotes = FirstParser.QuoteListToString(listMergedQuote).ToArray(); } listPreview.Items.AddRange(ListStringMergedQuotes); }
/// <summary> /// Inner parse method /// </summary> /// <param name="scanner">scanner</param> /// <returns>the match</returns> protected override ParserMatch ParseMain(IScanner scanner) { long offset = scanner.Offset; ParserMatch m = FirstParser.Parse(scanner); if (m.Success) { StringScanner firstMatch = new StringScanner(m.Value); ParserMatch m2 = SecondParser.Parse(firstMatch); if (m2.Success) { return(m); } } scanner.Seek(offset); return(ParserMatch.CreateFailureMatch(scanner)); }
private bool Accept <TInput, TOutput>(FirstParser <TInput, TOutput> p, BnfStringifyVisitor state) { var children = p.GetChildren().ToList(); if (children.Count == 1) { state.Append(children[0]); return(true); } state.Append("(", children[0]); for (int i = 1; i <= children.Count - 1; i++) { state.Append(" | ", children[i]); } state.Append(')'); return(true); }
/// <summary> /// Inner parse method /// </summary> /// <param name="scanner">scanner</param> /// <returns>the match</returns> protected override ParserMatch ParseMain(Scanners.IScanner scanner) { ParserMatch m = FirstParser.TryAccept(scanner); if (!m.Success) { return(m); } // doing difference ParserMatch d = SecondParser.TryAccept(scanner); if (d.Success) { if (d.Length >= m.Length) { return(ParserMatch.CreateFailureMatch(scanner, m.Offset, 0)); } } // ok FirstParser.Parse(scanner); return(m); }
public override Parser <TInput> VisitFirst(FirstParser <TInput> parser) { if (state.State == 0) { state.State = 1; state.NextOutputStart = state.OutputStart; return(parser.Parsers[0]); } else if (state.LastResult < 0) { if (state.LastResult < state.BestFailedResult) { state.BestFailedResult = state.LastResult; } output.SetCount(state.OriginalOutputCount); if (state.State < parser.Parsers.Count) { var next = parser.Parsers[state.State]; state.State++; state.NextOutputStart = state.OutputStart; return(next); } else { state.InputLength = state.BestFailedResult; return(null); } } else { state.InputLength = state.LastResult; return(null); } }
/// <summary> /// Inner parse method /// match (first but not second) or (second but not first) /// </summary> /// <param name="scanner">scanner</param> /// <returns>the match</returns> protected override ParserMatch ParseMain(Scanners.IScanner scanner) { long startOffset = scanner.Offset; ParserMatch m1 = FirstParser.Parse(scanner); long offset1 = scanner.Offset; scanner.Seek(startOffset); ParserMatch m2 = SecondParser.Parse(scanner); if (m1.Success && !m2.Success) { scanner.Seek(offset1); return(m1); } if (m2.Success && !m1.Success) { return(m2); } scanner.Seek(startOffset); return(ParserMatch.CreateFailureMatch(scanner)); }
public override int VisitFirst(FirstParser <TInput> parser, int start) { return(VisitFirst(parser.Parsers, start)); }
public override SyntaxTreeNode Parse(string text) { var pResult = FirstParser.Parse(text) ?? SecondParser.Parse(text); return(pResult); }
public override void VisitFirst(FirstParser <TInput> parser) { WriteAlternation(parser.Parsers); }
public override Parser <TInput> VisitFirst(FirstParser <TInput> parser) { return(NextBest(parser.Parsers)); }