public static Parser <TInput, T> Where <TInput, T>(this Parser <TInput, T> parser,
Predicate <T> predicate, string errorMessage = null)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(input =>
{
IParsingResult <TInput, T> result = parser(input);
if (result.Success)
{
if (!predicate(result.Value))
{
return new FailParsingResult <TInput, T>(input, new ParsingError()
{
Position = input.Position,
Message = errorMessage ?? "Condition fails",
Method = "Where<TInput, T>(Parser<TInput, T>, Predicate<T>, string)",
Type = typeof(T)
});
}
}
return result;
});
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
IParsingResult name = SimpleId.Parse(context);
if (name != null)
{
return(name);
}
if (context.Parser.VerifyString("on"))
{
IParsingResult operatorName = OperatorName.Parse(context);
if (operatorName != null)
{
IParsingResult arguments = TemplateArgs.Parse(context);
return(new Operator(operatorName, arguments));
}
context.Rewind(rewind);
return(null);
}
if (context.Parser.VerifyString("dn"))
{
return(DestructorName.Parse(context));
}
return(null);
}
public static Parser <TInput, T> Eof <TInput, T>(this Parser <TInput, T> parser,
string errorMessage = null)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
return(input =>
{
IParsingResult <TInput, T> result = parser(input);
if (result.Success)
{
if (!result.Input.Eof)
{
return new FailParsingResult <TInput, T>(input, new ParsingError()
{
Position = result.Input.Position,
Message = errorMessage ?? "End of input expected",
Method = "Eof<TInput, T>(Parser<TInput, T>, string)",
Type = typeof(T)
});
}
}
return result;
});
}
public void ParseCommonOptions_WithRequiredArguments_ReturnsSuccessfulResult()
{
using (TemporaryDirectoryFixture tempDirectory = new TemporaryDirectoryFixture())
{
// arrange
Option <CommonOptions> commonOptionsParser = new CommonOptionsParser();
var kmerFasta = tempDirectory.CreateFile("kmerv2.fa");
var filterBed = tempDirectory.GetFileLocation("filter.bed").Touch();
var output = tempDirectory.CreateSubdirectory("output");
var genome = tempDirectory.CreateSubdirectory("WholeGenomeFasta");
string[] stringInputArgument =
{
"-r", kmerFasta.ToString(), "-o", output.ToString(), "-g", genome.ToString(), "--filter-bed", filterBed.ToString()
};
// act
IParsingResult <CommonOptions> result = commonOptionsParser.Parse(stringInputArgument);
// assert
Assert.Equal("", result.ErrorMessage);
Assert.True(result.Success);
Assert.Equal(kmerFasta, result.Result.KmerFasta);
Assert.Equal(output, result.Result.OutputDirectory);
Assert.Equal(genome, result.Result.WholeGenomeFasta);
}
}
public static Parser <TInput, List <T> > Repeat <TInput, T>(
this Parser <TInput, T> parser, int times)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (times <= 0)
{
throw new ArgumentOutOfRangeException(nameof(times));
}
return(input =>
{
List <T> list = new List <T>();
IParserInput <TInput> next = input;
for (int i = 0; i < times; i++)
{
IParsingResult <TInput, T> result = parser(input);
if (!result.Success)
{
return new FailParsingResult <TInput, List <T> >(input, result.Error);
}
list.Add(result.Value);
next = result.Input;
}
return new SuccessParsingResult <TInput, List <T> >(list, next);
});
}
public bool Validate(out IParsingResult <TResult> failedResult, bool allowUnparsedArguments = false)
{
if (_failedResult != null)
{
failedResult = _failedResult;
return(false);
}
if (!allowUnparsedArguments && RemainingArgs.Any())
{
failedResult = ParsingResult <TResult> .FailedResult($"Error: found unexpected arguments '{string.Join(" ", RemainingArgs)}'");
return(false);
}
failedResult = null;
foreach (IParsingResult result in _results.Values)
{
if (result.Success)
{
continue;
}
failedResult = ParsingResult <TResult> .FailedResult(result.ErrorMessage);
return(false);
}
return(true);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("Ul"))
{
return(null);
}
IParsingResult signature = LambdaSig.Parse(context);
if (signature == null || !context.Parser.VerifyString("E"))
{
context.Rewind(rewind);
return(null);
}
int?number = context.Parser.ParseNumber();
if (!context.Parser.VerifyString("_"))
{
context.Rewind(rewind);
return(null);
}
return(new ClosureTypeName(signature, number));
}
public Ternary(IParsingResult operatorName, IParsingResult firstExpression, IParsingResult secondExpression, IParsingResult thirdExpression)
{
OperatorName = operatorName;
FirstExpression = firstExpression;
SecondExpression = secondExpression;
ThirdExpression = thirdExpression;
}
public bool AcceptsToken(ILexicalToken token, IParsingResult parsingResult)
{
// todo checks
var result = this.AcceptsTokenImpl(token, parsingResult);
return(result);
}
public static Parser <TInput, List <T> > AtLeastOnce <TInput, T, TSeparator>(
this Parser <TInput, T> parser, Parser <TInput, TSeparator> separatorParser)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (separatorParser == null)
{
throw new ArgumentNullException(nameof(separatorParser));
}
return(input =>
{
List <T> list = new List <T>();
IParsingResult <TInput, T> result = parser(input);
if (!result.Success)
{
return new FailParsingResult <TInput, List <T> >(input, result.Error);
}
while (result.Success)
{
list.Add(result.Value);
input = result.Input;
IParsingResult <TInput, TSeparator> dividerResult = separatorParser(input);
if (!dividerResult.Success)
{
return new SuccessParsingResult <TInput, List <T> >(list, input, dividerResult.Error);
}
result = parser(dividerResult.Input);
}
return new SuccessParsingResult <TInput, List <T> >(list, input, result.Error);
});
}
private static void ActMethod(ActionNode node, ILexicalToken token, IParsingResult parsingResult)
{
var cliResult = (CliParsingResult)parsingResult;
var thisNode = (TermNode)node;
cliResult.SetCommand(thisNode.Term);
}
private static void ActMethod(ActionNode node, ILexicalToken token, IParsingResult parsingResult)
{
var thisNode = (KeyValueNode)node;
var cliParsingResult = (CliParsingResult)parsingResult;
cliParsingResult.AddKeyValue(thisNode.Alias, token.ToString());
}
public void Demangle(DemanglingContext context)
{
// TODO: this needs more finesse.
IParsingResult arg = context.Stack.GetFunctionArg(Scope);
arg?.Demangle(context);
}
public static Parser <TInput, List <T> > Until <TInput, T, TParser>(
this Parser <TInput, T> parser, Parser <TInput, TParser> conditionParser)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
return(input =>
{
List <T> list = new List <T>();
IParsingResult <TInput, TParser> conditionResult = conditionParser(input);
IParserInput <TInput> next = input;
while (!conditionResult.Success)
{
IParsingResult <TInput, T> result = parser(next);
if (!result.Success)
{
return new FailParsingResult <TInput, List <T> >(input, result.Error);
}
list.Add(result.Value);
next = result.Input;
conditionResult = conditionParser(next);
}
return new SuccessParsingResult <TInput, List <T> >(list, next);
});
}
public static Parser <TInput, TResult> SelectMany <TInput, T, TOther, TResult>(
this Parser <TInput, T> parser, Func <T, Parser <TInput, TOther> > selectFunc,
Func <T, TOther, TResult> resultFunc)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (selectFunc == null)
{
throw new ArgumentNullException(nameof(selectFunc));
}
if (resultFunc == null)
{
throw new ArgumentNullException(nameof(resultFunc));
}
return(input =>
{
IParsingResult <TInput, T> result = parser(input);
if (result.Success)
{
IParsingResult <TInput, TOther> otherResult = selectFunc(result.Value)(result.Input);
if (otherResult.Success)
{
return new SuccessParsingResult <TInput, TResult>(
resultFunc(result.Value, otherResult.Value), otherResult.Input,
new ReadOnlyList <ParsingError>(result.Corrections.Concat(otherResult.Corrections).ToArray()));
}
return new FailParsingResult <TInput, TResult>(input, otherResult.Error);
}
return new FailParsingResult <TInput, TResult>(input, result.Error);
});
}
public static Parser <TInput, T> Or <TInput, T>(this Parser <TInput, T> parser,
Parser <TInput, T> other)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
return(input =>
{
IParsingResult <TInput, T> result = parser(input);
if (result.Success)
{
return result;
}
// loop for other parsers
IParsingResult <TInput, T> otherResult = other(input);
if (otherResult.Success)
{
return otherResult;
}
if (otherResult.Error.Position >= result.Error.Position)
{
result = otherResult;
}
// end of loop
return result;
});
}
public static Parser <TInput, List <T> > RequiredWhile <TInput, T, TPrefix>(
this Parser <TInput, T> parser, Parser <TInput, TPrefix> prefix)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (prefix == null)
{
throw new ArgumentNullException(nameof(prefix));
}
return(input =>
{
List <T> list = new List <T>();
IParserInput <TInput> next = input;
IParsingResult <TInput, TPrefix> prefixResult = prefix(input);
while (prefixResult.Success)
{
IParsingResult <TInput, T> result = parser(prefixResult.Input);
if (!result.Success)
{
return new FailParsingResult <TInput, List <T> >(input, result.Error);
}
list.Add(result.Value);
next = result.Input;
prefixResult = prefix(next);
}
return new SuccessParsingResult <TInput, List <T> >(list, next);
});
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("L"))
{
return(null);
}
IParsingResult type = Type.Parse(context);
if (type != null)
{
string literal = context.Parser.ParseUntil('E');
if (context.Parser.VerifyString("E"))
{
return(new Literal(type, literal));
}
context.Rewind(rewind);
return(null);
}
IParsingResult name = MangledName.Parse(context);
if (name != null && context.Parser.VerifyString("E"))
{
return(new External(name));
}
context.Rewind(rewind);
return(null);
}
public static IParsingResult <T> FailedResult <U>(IParsingResult <U> failedResult)
{
if (failedResult.Success)
{
throw new ArgumentException($"{nameof(failedResult)} must not be successful");
}
return(FailedResult(failedResult.ErrorMessage));
}
bool IResultCollection.Validate(out IParsingResult failedResult)
{
ParsingResult <TResult> failedResult2;
bool b = Validate(out failedResult2);
failedResult = failedResult2;
return(b);
}
public static IParsingResult <TInput, TResult> Value <TInput, T, TResult>(
this IParsingResult <TInput, T> result, TResult value)
{
if (result.Success)
{
return(new SuccessParsingResult <TInput, TResult>(value, result.Input, result.Corrections, result.Error));
}
return(new FailParsingResult <TInput, TResult>(result.Input, result.Corrections, result.Error));
}
public static IParsingResult <TInput, TResult> Select <TInput, T, TResult>(
this IParsingResult <TInput, T> result, Func <T, TResult> func)
{
if (result.Success)
{
return(new SuccessParsingResult <TInput, TResult>(func(result.Value), result.Input, result.Corrections, result.Error));
}
return(new FailParsingResult <TInput, TResult>(result.Input, result.Corrections, result.Error));
}
public static IParsingResult <TInput, T> Value <TInput, T>(
this IParsingResult <TInput, T> result, T value)
{
if (result.Success)
{
return(new SuccessParsingResult <TInput, T>(value, result.Input, result.Corrections));
}
return(result);
}
public static IParsingResult Parse(ParsingContext context)
{
IParsingResult name = UnresolvedType.Parse(context) ?? SimpleId.Parse(context);
if (name != null)
{
return(new DestructorName(name));
}
return(null);
}
public SuccessfulResultCollection(IOption option, IParsingResult result) :
this(new ResultCollection <object>(
new Dictionary <IOption, IParsingResult>
{
{
option, result
}
}))
{
}
private static void ActMethod(ActionNode node, ILexicalToken token, IParsingResult parsingResult)
{
var thisNode = (KeyNode)node;
var cliKeyToken = (CliKeyToken)token;
var cliParsingResult = (CliParsingResult)parsingResult;
// todo: obey 'IsUnique'
// do nothing, KeyValueNode will do its job
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("A"))
{
return(null);
}
int number;
IParsingResult type;
if (context.Parser.ParseNumber(out number))
{
Debug.Assert(number >= 0);
if (context.Parser.VerifyString("_"))
{
type = Parsers.Type.Parse(context);
if (type != null)
{
return(new DimensionNumber(number, type));
}
}
context.Rewind(rewind);
return(null);
}
IParsingResult expression = Expression.Parse(context);
if (expression != null)
{
if (context.Parser.VerifyString("_"))
{
type = Parsers.Type.Parse(context);
if (type != null)
{
return(new DimensionExpression(expression, type));
}
}
context.Rewind(rewind);
return(null);
}
if (context.Parser.VerifyString("_"))
{
type = Parsers.Type.Parse(context);
if (type != null)
{
return(new NoDimension(type));
}
}
context.Rewind(rewind);
return(null);
}
private static bool AcceptsMethod(ActionNode node, ILexicalToken token, IParsingResult parsingResult)
{
var thisNode = (TermNode)node;
if (token is CliWordToken cliWordToken)
{
return(cliWordToken.Text == thisNode.Term);
}
return(false);
}
private static bool AcceptsMethod(ActionNode node, ILexicalToken token, IParsingResult parsingResult)
{
var thisNode = (KeyValueNode)node;
if (token is TextToken textToken)
{
return(thisNode.AdditionalCheck?.Invoke(node, textToken, parsingResult) ?? true);
}
return(false);
}
private static bool AcceptsMethod(ActionNode node, ILexicalToken token, IParsingResult parsingResult)
{
var thisNode = (KeyNode)node;
if (token is CliKeyToken cliKeyToken)
{
return(thisNode.KeyValues.Contains(cliKeyToken.Text));
}
return(false);
}
