public Lexer(AmbiguityResolverEnum ambiguityResolver, Func <T> nil,
Dictionary <Regex, Action <ILexerArg <T> > > handlers)
{
_ambiguityResolver = ambiguityResolver;
_nil = nil;
_handlers = handlers;
}
public LexerBuilderHandlers(AmbiguityResolverEnum ambiguityResolver, Func <T> nil)
{
_ambiguityResolver = ambiguityResolver;
_nil
= nil;
_handlers = new Dictionary <Regex, Action <ILexerArg <T> > >();
}
private static KeyValuePair <Regex, Action <ILexerArg <T> > > ResolveHandler(
AmbiguityResolverEnum ambiguityResolverEnum, string buffer, char next, T lastToken,
// ReSharper disable once ParameterTypeCanBeEnumerable.Local
List <KeyValuePair <Regex, Action <ILexerArg <T> > > > handlers)
{
switch (ambiguityResolverEnum)
{
case AmbiguityResolverEnum.FirstMatch:
return(handlers.First());
case AmbiguityResolverEnum.LastMatch:
return(handlers.Last());
case AmbiguityResolverEnum.LongestMatch:
var handlerAny = handlers
.Select(x => new
{
Handler = x,
Factory = ProbeFactory.New <string>()
})
.Select(x => new
{
// ReSharper disable once AccessToModifiedClosure
x.Factory, x.Handler, Arg = new LexerArg <T>(buffer, next, lastToken,
// Test should not be able to stop the parser
() => { },
(a, b) => x.Factory.Instance.SetValue(a),
_ => { },
_ => { }
)
})
.Select(x =>
{
var result = new
{
x.Factory,
x.Handler,
x.Arg,
Probe = x.Factory.Build()
};
result.Handler.Value(x.Arg);
return(result);
})
.Select(x =>
{
var result = new
{
x.Probe,
x.Handler
};
x.Probe.Trigger();
return(result);
})
.Where(x => x.Probe.Resolved)
.OrderBy(x => x.Probe.Value.Length)
.LastOrDefault();
return(handlerAny?.Handler ?? ResolveHandler(AmbiguityResolverEnum.FirstMatch, buffer, next,
lastToken, handlers));
default:
throw new ArgumentOutOfRangeException();
}
}
public LexerBuilderWithNilNode(AmbiguityResolverEnum ambiguityResolver)
{
_ambiguityResolver = ambiguityResolver;
}
public ILexerBuilderWithNilNode <T> WithAmbiguityResolverEnum(AmbiguityResolverEnum ambiguityResolver)
{
return(new LexerBuilderWithNilNode <T>(ambiguityResolver));
}
