/// <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);
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
// save scanner state
long startOffset = scanner.Offset;
ParserMatch m = ParserMatch.CreateSuccessfulEmptyMatch(scanner);
ParserMatch m_temp;
// execution bound
int count = 0;
// lower bound, minimum number of executions
while (count < LowerBound && !scanner.AtEnd)
{
m_temp = Parser.Parse(scanner);
// stop if not successful
if (!m_temp.Success)
{
break;
}
// increment count and update full match
++count;
m.Concat(m_temp);
}
if (count == LowerBound)
{
while (count < UpperBound && !scanner.AtEnd)
{
m_temp = Parser.Parse(scanner);
// stop if not successful
if (!m_temp.Success)
{
break;
}
// increment count
++count;
m.Concat(m_temp);
}
}
else
{
m = ParserMatch.CreateFailureMatch(scanner, startOffset);
}
// restoring parser failed, rewind scanner
if (!m.Success)
{
scanner.Seek(startOffset);
}
return(m);
}
public override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
long offset = scanner.Offset;
ParserMatch a = null, b = null;
ParserMatch m = this.FirstParser.Parse(scanner);
if (!m.Success)
{
scanner.Seek(offset);
return(scanner.NoMatch);
}
while (!scanner.AtEnd)
{
offset = scanner.Offset;
b = this.SecondParser.Parse(scanner);
if (!b.Success)
{
scanner.Seek(offset);
return(m);
}
a = this.FirstParser.Parse(scanner);
if (!a.Success)
{
scanner.Seek(offset);
return(m);
}
m.Concat(b);
m.Concat(a);
}
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)
{
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);
}
public override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
// save scanner state
long offset = scanner.Offset;
// apply the first parser
ParserMatch m = this.FirstParser.Parse(scanner);
// if m1 successful, do m2
if (m.Success)
{
ParserMatch m2 = this.SecondParser.Parse(scanner);
if (m2.Success)
{
m.Concat(m2);
}
else
{
m = scanner.NoMatch;
}
}
// restoring parser failed, rewind scanner
if (!m.Success)
{
scanner.Seek(offset);
}
return(m);
}
public void Concat()
{
IScanner scanner = Provider.NewScanner;
scanner.Read();
long startOffset1 = scanner.Offset;
scanner.Read();
long endOffset1 = scanner.Offset;
ParserMatch match1 = ParserMatch.CreateSuccessfulMatch(scanner, startOffset1, endOffset1);
long startOffset2 = scanner.Offset;
scanner.Read();
scanner.Read();
long endOffset2 = scanner.Offset;
ParserMatch match2 = ParserMatch.CreateSuccessfulMatch(scanner, startOffset2, endOffset2);
match1.Concat(match2);
Assert.AreEqual(startOffset1, match1.Offset);
Assert.AreEqual(endOffset2 - startOffset1, match1.Length);
Assert.IsFalse(match1.Empty);
}
public override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
long offset = scanner.Offset;
ParserMatch m = this.FirstParser.Parse(scanner);
if (m.Success)
{
ParserMatch m2 = this.SecondParser.Parse(scanner);
if (m2.Success)
{
m.Concat(m2);
return(m);
}
}
else
{
scanner.Seek(offset);
m = this.SecondParser.Parse(scanner);
if (m.Success)
{
ParserMatch m2 = this.FirstParser.Parse(scanner);
if (m2.Success)
{
m.Concat(m2);
return(m);
}
}
}
scanner.Seek(offset);
return(scanner.NoMatch);
}
public void Concat_MatchOntoEmpty_Match()
{
IScanner scanner = Provider.NewScanner;
scanner.Read();
ParserMatch emptyMatch = ParserMatch.CreateSuccessfulEmptyMatch(scanner);
long startOffset = scanner.Offset;
scanner.Read();
long endOffset = scanner.Offset;
ParserMatch match = ParserMatch.CreateSuccessfulMatch(scanner, startOffset, endOffset);
emptyMatch.Concat(match);
Assert.AreEqual(startOffset, emptyMatch.Offset);
Assert.AreEqual(endOffset - startOffset, emptyMatch.Length);
Assert.IsFalse(emptyMatch.Empty);
}