public static void OneOfTest()
{
CharParserTest(CharParsers.OneOf("0123456789"),
200, 1000000);
// 61.08 sec. (maxItemCount = 1,000,000)
}
private static void charTest(string testName, Func <char, bool> predicate, int times, int maxItemCount, string inputText)
{
Console.WriteLine(testName);
CharParsersPerformanceTests.CharParserTest(CharParsers.Satisfy(predicate),
times, maxItemCount, inputText);
Console.WriteLine();
}
public static void ManyCharsTest()
{
CharParserTest(CharParsers.Many1(CharParsers.AnyChar),
200, 1000000);
// 17.97 sec. (maxItemCount = 1,000,000)
// 37.55 sec. (maxItemCount = 2,000,000)
}
private static void testBacktracking()
{
var letExpr = stringParser("let");
var identifier = CharParsers.Many1(CharParsers.Satisfy(c => char.IsLetter(c)));
var expr = CharParsers.Choice(letExpr, identifier);
displayResult(runParser(expr, "lexical"));
}
public T RunParser <T>(Func <State <Unit>, Primitives.Reply <T, Unit> > parser, string text)
{
var f = FuncConvert.ToFSharpFunc <State <Unit>, Primitives.Reply <T, Unit> >(s => parser(s));
var r = CharParsers.run <T>(f, text);
if (r.IsSuccess)
{
return(((CharParsers.ParserResult <T, Unit> .Success)r).Item1);
}
return(default(T));
}
private Parser <char, string> createParser(BasePattern pattern)
{
if (pattern == null)
{
throw new ArgumentNullException("pattern.", "Pattern is null when creating match parser.");
}
switch (pattern.Type)
{
case PatternType.Group:
return(from vs in
CharParsers.Sequence(((GroupPattern)pattern).Patterns
.Select(p => createParser(p)))
select vs.JoinStrings());
case PatternType.Quantifier:
QuantifierPattern quant = (QuantifierPattern)pattern;
return(from vs in CharParsers.Count(quant.MinOccurrences,
quant.MaxOccurrences,
createParser(quant.ChildPattern))
select vs.JoinStrings());
case PatternType.Alternation:
return(CharParsers.Choice(((AlternationPattern)pattern).Alternatives
.Select(p => createParser(p))
.ToArray()));
case PatternType.String:
return(CharParsers.String(((StringPattern)pattern).Value));
case PatternType.Char:
return(from c in CharParsers.Satisfy(((CharPattern)pattern).IsMatch)
select new string(c, 1));
default:
throw new ApplicationException(
string.Format("ExplicitDFAMatcher: unrecognized pattern type ({0}).",
pattern.GetType().Name));
}
}
private static void testBacktracking2()
{
var alternatives = CharParsers.Choice(
stringParser("a"),
stringParser("ab")
);
var pattern = from ss in CharParsers.Sequence(new[]
{
alternatives,
stringParser("bbb"),
stringParser("c")
})
select ss.SelectMany(s => s);
displayResult(runParser(pattern, "abbbc"));
displayResult(runParser(pattern, "abbbbc"));
}
private static Parser <char, IEnumerable <char> > stringParser(string s)
{
return(CharParsers.Sequence(s.Select(c => CharParsers.Char(c))));
}
