public ParseResult <string> TryParse(CharParserContext context, int off, int len) { if (len < target.Length) { return(new ParseFailure <string>(off, "Expected \"" + target + "\", found EOF")); } else { string text = context.Text; if (Utility.IsValidRange(text, off, len)) { string inputRegion = text.Substring(off, target.Length); if (string.Compare(inputRegion, target, style) == 0) { return(new ParseSuccess <string>(off, target.Length, inputRegion)); } else { return(new ParseFailure <string>(off, "Expected \"" + target + "\"")); } } else { return(new ParseFailure <string>(off, "Invalid range")); } } }
public ParseResult <T> TryParse(CharParserContext context, int off, int len) { ParseFailure <T> error = null; foreach (ICharParser <T> subParser in subParsers) { ParseResult <T> pr = context.TryParseAt(subParser, off, len); if (pr is ParseSuccess <T> ) { return(pr); } else { ParseFailure <T> pf = (ParseFailure <T>)pr; if (error == null) { error = pf; } else { error = new ParseFailure <T>(error.Errors.AddRange(pf.Errors)); } } } System.Diagnostics.Debug.Assert(error != null); return(error); }
public ParseResult <TOut> TryParse(CharParserContext context, int off, int len) { ParseResult <TIn> pr1 = context.TryParseAt(subParser, off, len); return(pr1.Visit <ParseResult <TOut> > ( success => { Option <TOut> conversionResult = conversionFunc(success.Value); if (conversionResult.HasValue) { return new ParseSuccess <TOut>(success.Position, success.Length, conversionResult.Value); } else { return new ParseFailure <TOut>(success.Position, failureMessage); } }, failure => { return new ParseFailure <TOut>(failure.Errors); } )); }
public ParseResult <T> TryParse(CharParserContext context, int off, int len) { if (SubParser == null) { return(new ParseFailure <T>(off, "Reference to parser not initialized")); } else { return(context.TryParseAt(SubParser, off, len)); } }
public ParseResult <string> TryParse(CharParserContext context, int off, int len) { if (Utility.IsValidRange(context.Text, off, len)) { return(new ParseSuccess <string>(off, 0, string.Empty)); } else { return(new ParseFailure <string>(off, "Invalid range")); } }
public ParseResult <Match> TryParse(CharParserContext context, int off, int len) { Match m = regex.Match(context.Text, off, len); if (m.Success && m.Index == off) { return(new ParseSuccess <Match>(m.Index, m.Length, m)); } else { return(new ParseFailure <Match>(off, failureMessage ?? $"Failed to parse {regex.ToString().Quoted()}")); } }
public ParseResult <ImmutableList <T> > TryParse(CharParserContext context, int off, int len) { int pos = off; ImmutableList <T> results = ImmutableList <T> .Empty; if (repeating) { ParseResult <T> pr; while (true) { pr = context.TryParseAt(subParser, pos, len - (pos - off)); if (pr is ParseFailure <T> ) { break; } ParseSuccess <T> ps = (ParseSuccess <T>)pr; pos += ps.Length; results = results.Add(ps.Value); } if (!optional && results.Count == 0) { return(new ParseFailure <ImmutableList <T> >(((ParseFailure <T>)pr).Errors)); } else { return(new ParseSuccess <ImmutableList <T> >(off, pos - off, results)); } } else if (optional) { ParseResult <T> pr = context.TryParseAt(subParser, off, len); return(pr.Visit <ParseResult <ImmutableList <T> > > ( success => { return new ParseSuccess <ImmutableList <T> >(success.Position, success.Length, ImmutableList <T> .Empty.Add(success.Value)); }, failure => { return new ParseSuccess <ImmutableList <T> >(off, 0, ImmutableList <T> .Empty); } )); } else { throw new InvalidOperationException("Neither optional nor repeating"); } }
public ParseResult <Nothing> TryParse(CharParserContext context, int pos, int len) { if (Utility.IsValidRange(context.Text, pos, len)) { if (len == 0) { return(new ParseSuccess <Nothing>(pos, 0, Nothing.Value)); } else { return(new ParseFailure <Nothing>(pos, "EOF expected")); } } else { return(new ParseFailure <Nothing>(pos, "Invalid range")); } }
public ParseResult <ImmutableList <T> > TryParse(CharParserContext context, int off, int len) { int pos = off; ImmutableList <T> results = ImmutableList <T> .Empty; foreach (ICharParser <T> subParser in subParsers) { ParseResult <T> subResult = context.TryParseAt(subParser, pos, len - (pos - off)); if (subResult is ParseSuccess <T> ) { var subSuccess = (ParseSuccess <T>)subResult; pos += subSuccess.Length; results = results.Add(subSuccess.Value); } else { var subFailure = (ParseFailure <T>)subResult; return(new ParseFailure <ImmutableList <T> >(subFailure.Errors)); } } return(new ParseSuccess <ImmutableList <T> >(off, pos - off, results)); }
public ParseResult <TOut> TryParse(CharParserContext context, int off, int len) { ParseResult <TIn> pr1 = context.TryParseAt(subParser, off, len); return(pr1.Visit <ParseResult <TOut> > ( success => { try { TOut conversionResult = conversionFunc(success.Value); return new ParseSuccess <TOut>(success.Position, success.Length, conversionResult); } catch (Exception exc) { return new ParseFailure <TOut>(success.Position, failureMessage ?? exc.ToString()); } }, failure => { return new ParseFailure <TOut>(failure.Errors); } )); }
public static ParseResult <V> TryParse <V>(ICharParser <V> parser, string text) { CharParserContext cpc = new CharParserContext(text); return(cpc.TryParseAt(parser, 0, text.Length)); }