public override ParserMatch TryMatch(IScanner scan)
{
int offset = scan.Offset;
var m = new ParserMatch(this, scan, offset, -1);
while (!scan.EndOfInput)
{
offset = scan.Offset;
var a = LeftParser.Parse(scan);
if (!a.Success)
{
scan.Seek(offset);
return m;
}
var b = RightParser.Parse(scan);
if (!b.Success)
{
scan.Seek(offset);
return m;
}
m.AddSubmatch(a);
m.AddSubmatch(b);
}
return m;
}
/// <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 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)
{
return(m);
}
// not found
scanner.Seek(offset);
// apply the second parser
m = this.SecondParser.Parse(scanner);
if (m.Success)
{
return(m);
}
scanner.Seek(offset);
return(scanner.NoMatch);
}
/// <summary>
/// Post parse event caller
/// </summary>
/// <param name="match"></param>
/// <param name="scan"></param>
public virtual void OnPostParse(ParserMatch match, IScanner scan)
{
if (PostParse != null)
{
PostParse(this, new PostParseEventArgs(match, this, scan));
}
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
long offset = scanner.Offset;
int len = 0;
if (scanner.Peek() == '\r') // CR
{
scanner.Read();
++len;
}
if (scanner.Peek() == '\n') // LF
{
scanner.Read();
++len;
}
if (len > 0)
{
ParserMatch m = ParserMatch.CreateSuccessfulMatch(scanner, offset, len);
return(m);
}
scanner.Seek(offset);
return(ParserMatch.CreateFailureMatch(scanner));
}
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);
}
/// <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);
}
/// <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 void NoMatch()
{
StringScanner scanner = new StringScanner(Text);
ParserMatch m = scanner.NoMatch;
Assert.IsTrue(!m.Success);
}
public bool ValidateSimpleCollationRules(string rules, out string message)
{
_currentCollationElement = new StringBuilder();
_currentCollationLines = new Queue <string>();
_currentCollationGroups = new Queue <string>();
_currentCollationElements = new Queue <string>();
_usedCollationElements = new List <string>();
StringScanner sc = new StringScanner(rules);
message = null;
try
{
ParserMatch match = _collationRules.Parse(sc);
if (!match.Success || !sc.AtEnd)
{
message = "Invalid simple rules.";
return(false);
}
}
catch (ParserErrorException e)
{
string errString = sc.InputString.Split(new char[] { '\n' })[e.ParserError.Line - 1];
int startingPos = Math.Max((int)e.ParserError.Column - 2, 0);
errString = errString.Substring(startingPos, Math.Min(10, errString.Length - startingPos));
message = String.Format("{0}: '{1}'", e.ParserError.ErrorText, errString);
return(false);
}
catch (Exception e)
{
message = e.Message;
return(false);
}
return(true);
}
public override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
long offset = scanner.Offset;
ParserMatch m = this.FirstParser.Parse(scanner);
long goodOffset = scanner.Offset;
if (!m.Success)
{
scanner.Seek(offset);
return(scanner.NoMatch);
}
// doing difference
scanner.Seek(offset);
ParserMatch d = this.SecondParser.Parse(scanner);
if (d.Success)
{
scanner.Seek(offset);
return(scanner.NoMatch);
}
// ok
scanner.Seek(goodOffset);
return(m);
}
public void InputMatchesFirstParserDoesNotMatchSecondParser_ScanPosition_ForwardByMatchLength()
{
IScanner digit = new StringScanner("1 hello");
ParserMatch match = this._LetterOrDigitButNotLetterDifferenceParser.Parse(digit);
Assert.AreEqual(1, match.Length);
Assert.AreEqual(1, digit.Offset);
}
public void EmptyMatch()
{
StringScanner scanner = new StringScanner(Text);
ParserMatch m = scanner.EmptyMatch;
Assert.IsTrue(m.Success);
Assert.IsTrue(m.Empty);
}
public void EmptyMatch()
{
IScanner scanner = Provider.NewScanner;
ParserMatch m = ParserMatch.CreateSuccessfulEmptyMatch(scanner);
Assert.IsTrue(m.Success);
Assert.IsTrue(m.Empty);
}
private static char MatchChar(ParserMatch parserMatch)
{
if (parserMatch.Success)
{
return('/');
}
return('#');
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
if (scanner.AtEnd)
{
return(ParserMatch.CreateSuccessfulEmptyMatch(scanner));
}
return(ParserMatch.CreateFailureMatch(scanner));
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException("scanner");
}
return(ParserMatch.CreateFailureMatch(scanner));
}
public void PositiveFailure()
{
RepetitionParser rp = +Parser;
string s = "b";
StringScanner scan = new StringScanner(s);
ParserMatch m = rp.Parse(scan);
Assert.IsTrue(!m.Success);
}
/// <summary>
/// Construct a new event argument instance
/// </summary>
/// <param name="match"></param>
/// <param name="result"></param>
public ActionEventArgs(ParserMatch match, object result)
{
this.Match = match ?? throw new ArgumentNullException(nameof(match));
if (!match.Success)
{
this.Match = null;
throw new ArgumentException(nameof(match) + " is not successfull");
}
this.Result = result;
}
public void NegateFailParse()
{
IScanner scanner = Provider.Scanner;
NegatableParser parser = -Prims.CharOf(MatchedChar);
ParserMatch m = parser.Parse(scanner);
Assert.IsTrue(!m.Success);
Assert.AreEqual(scanner.Offset, 0);
}
public void FailParse()
{
IScanner scanner = Provider.NewScanner;
CharParser parser = Prims.Ch(NonMatchedChar);
ParserMatch m = parser.Parse(scanner);
Assert.IsFalse(m.Success);
Assert.AreEqual(scanner.Offset, 0);
}
public void NegateFailParse()
{
IScanner scanner = Provider.NewScanner;
NegatableParser parser = ~Prims.Ch(MatchedChar);
ParserMatch m = parser.Parse(scanner);
Assert.IsFalse(m.Success);
Assert.AreEqual(scanner.Offset, 0);
}
public void FailParse()
{
IScanner scanner = Provider.Scanner;
StringParser parser = Prims.StringOf(NonMatchedString);
ParserMatch m = parser.Parse(scanner);
Assert.IsTrue(!m.Success);
Assert.AreEqual(scanner.Offset, 0);
}
public void FailParse()
{
IScanner scanner = Provider.NewScanner;
StringParser parser = Prims.Str(NonMatchedString);
ParserMatch m = parser.Parse(scanner);
Assert.IsFalse(m.Success);
Assert.AreEqual(0, scanner.Offset);
}
public void NoMatchMatch()
{
Rule d = Rule.AssignParser(null, Prims.Digit);
AlternativeParser rp = d | d | d;
IScanner scan = Provider.Scanner;
ParserMatch m = rp.Parse(scan);
Assert.IsTrue(!m.Success);
Assert.AreEqual(scan.Offset, 0);
}
public void Match_Length_0()
{
while (!scanner.AtEnd)
{
scanner.Read();
}
ParserMatch match = Prims.End.Parse(this.scanner);
Assert.AreEqual(0, match.Length);
}
public void AtEnd_Succeeds()
{
while (!scanner.AtEnd)
{
scanner.Read();
}
ParserMatch match = Prims.End.Parse(this.scanner);
Assert.IsTrue(match.Success);
}
public void Match_Position_AtEnd()
{
while (!scanner.AtEnd)
{
scanner.Read();
}
ParserMatch match = Prims.End.Parse(this.scanner);
Assert.AreEqual(scanner.Offset, match.Offset);
}
public void FailureSecond()
{
IScanner scanner = Provider.Scanner;
SequenceParser parser = new SequenceParser(First, Second2);
ParserMatch m = parser.Parse(scanner);
Assert.IsTrue(!m.Success);
Assert.AreEqual(scanner.Offset, 0);
}
public void OptionalSuccess0()
{
RepetitionParser rp = !Parser;
string s = "";
StringScanner scan = new StringScanner(s);
ParserMatch m = rp.Parse(scan);
Assert.IsTrue(m.Success);
Assert.IsTrue(m.Empty);
}
/// <summary>
/// Constructs a post parse event args
/// </summary>
/// <param name="match"></param>
/// <param name="parser"></param>
/// <param name="scanner"></param>
public PostParseEventArgs(ParserMatch match, NonTerminalParser parser, IScanner scanner)
{
if (match == null)
throw new ArgumentNullException("match");
if (parser == null)
throw new ArgumentNullException("parser");
if (scanner == null)
throw new ArgumentNullException("scanner");
m_Match = match;
m_Parser = parser;
m_Scanner = scanner;
}
public override ParserMatch TryMatch(IScanner scan)
{
if (Parser == this) return scan.NoMatch;
// save scanner state
int offset = scan.Offset;
var m = new ParserMatch(this, scan, 0, 0); // empty match with this parser
// execution bound
int count = 0;
// lower bound, minimum number of executions
while (count < LowerBound && !scan.EndOfInput)
{
var m_temp = Parser.Parse(scan);
if (!m_temp.Success) break; // stop if not successful
count++;
m.AddSubmatch(m_temp);
}
if (count == LowerBound)
{
while (count < UpperBound && !scan.EndOfInput)
{
var m_temp = Parser.Parse(scan);
if (!m_temp.Success) break; // stop if not successful
count++;
m.AddSubmatch(m_temp);
}
}
else
{
m = scan.NoMatch;
}
if (m == null) m = scan.NoMatch;
// restoring parser failed, rewind scanner
if (!m.Success) scan.Seek(offset);
return m;
}
public void A_parser_match_with_a_parser_and_scanner()
{
parser = new LiteralString("hello");
scanner = new ScanStrings("Hello world");
subject = new ParserMatch(parser, scanner, 0, 0);
}
public void Creating_a_parser_match_with_no_parser_is_accepted()
{
var match = new ParserMatch(null, scanner, 0, 0);
Assert.That(match.SourceParser, Is.Null);
}
