static void testParenthisis()
{
Tokenizer tg = new Tokenizer();
var pattern = "6*(3+5)-(5*(3-2));";
var watch = new Stopwatch();
watch.Start();
var t = 0;
for (int i = 0; i < 10000000; i++)
{
var reader = new SequenceReader <Token>(tg.Tokenize(pattern));
var builder = new AstNodeBuilder(reader, null, new string[] { ";" });
var result = builder.Build();
t += pattern.Length;
}
Console.WriteLine($"length is {t}");
Console.WriteLine($"top build spend:{watch.ElapsedMilliseconds} ");
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
var result = _parser.Parse(input, ctx);
return result.Success
? AstNodeBuilder.Success(ParserType.Optional, input, result.Match, new[] { result })
: AstNodeBuilder.Success(ParserType.Optional, input, 0);
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
return(AstNodeBuilder.Condition(
ParserType.Whitespace,
input.Length > 0 && char.IsWhiteSpace(input[0]),
input,
1));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
var children = new List <AstNode>();
var remaining = input;
AstNode childResult;
while ((childResult = _parser.Parse(remaining, ctx)).Success)
{
children.Add(childResult);
remaining = remaining.From(childResult.Match.Length);
}
return(AstNodeBuilder.Condition(ParserType.OneOrMore, children.Any(), input, input.Length - remaining.Length, children));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
foreach (var option in _options)
{
var result = option.Parse(input, ctx);
if (result.Success)
{
return(AstNodeBuilder.Success(ParserType.Choice, input, result.Match, new[] { result }));
}
}
return(AstNodeBuilder.Failure(ParserType.Choice, input));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
if (input.Length < _literal.Length)
{
return(AstNodeBuilder.Failure(ParserType.Terminal, input));
}
// ReSharper disable once LoopCanBeConvertedToQuery
for (var i = 0; i < _literal.Length; ++i)
{
if (char.ToUpperInvariant(input[i]) != _literal[i])
{
return(AstNodeBuilder.Failure(ParserType.Terminal, input));
}
}
return(AstNodeBuilder.Success(ParserType.Terminal, input, _literal.Length));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
var children = new List <AstNode>(_elements.Length);
var remaining = input;
foreach (var element in _elements)
{
var subResult = element.Parse(remaining, ctx);
if (!subResult.Success)
{
return(AstNodeBuilder.Failure(ParserType.Sequence, input));
}
children.Add(subResult);
remaining = remaining.From(subResult.Match.Length);
}
return(AstNodeBuilder.Success(ParserType.Sequence, input, input.Length - remaining.Length, children));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
return(AstNodeBuilder.Condition(ParserType.Any, input.Length > 0, input, 1));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
var result = _parser.Parse(input, ctx);
return(AstNodeBuilder.Condition(result.Type, result.Success, input, result.Match));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
return(AstNodeBuilder.Condition(ParserType.Lookahead, _parse.Parse(input, ctx).Success, input, 0));
}
protected override AstNode ParseImpl(Slice input, Context ctx)
{
return(AstNodeBuilder.Condition(ParserType.Range, input.Length > 0 && input[0] >= _from && input[0] <= _to, input, 1));
}
