internal sealed override InternalResult <R> Parse(IParseState <TToken> state) { var consumedInput = false; var result1 = _p1.Parse(state); consumedInput = consumedInput || result1.ConsumedInput; if (!result1.Success) { state.Error = state.Error.WithExpected(Expected); return(InternalResult.Failure <R>( consumedInput )); } var result2 = _p2.Parse(state); consumedInput = consumedInput || result2.ConsumedInput; if (!result2.Success) { state.Error = state.Error.WithExpected(Expected); return(InternalResult.Failure <R>( consumedInput )); } return(InternalResult.Success <R>(_func( result1.Value, result2.Value ), consumedInput)); }
internal override InternalResult <U> Parse(IParseState <TToken> state) { var result1 = _parser.Parse(state); if (!result1.Success) { // state.Error set by _parser return(InternalResult.Failure <U>(result1.ConsumedInput)); } var z = _func(_seed(), result1.Value); var consumedInput = result1.ConsumedInput; var result = _parser.Parse(state); while (result.Success) { if (!result.ConsumedInput) { throw new InvalidOperationException("Many() used with a parser which consumed no input"); } consumedInput = true; z = _func(z, result.Value); result = _parser.Parse(state); } if (result.ConsumedInput) // the most recent parser failed after consuming input { // state.Error set by _parser return(InternalResult.Failure <U>(true)); } return(InternalResult.Success <U>(z, consumedInput)); }
internal sealed override InternalResult <R> Parse(ref ParseState <TToken> state) { var consumedInput = false; var result1 = _p1.Parse(ref state); consumedInput = consumedInput || result1.ConsumedInput; if (!result1.Success) { return(InternalResult.Failure <R>(consumedInput)); } var result2 = _p2.Parse(ref state); consumedInput = consumedInput || result2.ConsumedInput; if (!result2.Success) { return(InternalResult.Failure <R>(consumedInput)); } var result3 = _p3.Parse(ref state); consumedInput = consumedInput || result3.ConsumedInput; if (!result3.Success) { return(InternalResult.Failure <R>(consumedInput)); } return(InternalResult.Success <R>(_func( result1.Value, result2.Value, result3.Value ), consumedInput)); }
internal sealed override InternalResult <Unit> Parse(ref ParseState <TToken> state) { var startingPosition = state.SourcePos; var token = state.HasCurrent ? Maybe.Just(state.Current) : Maybe.Nothing <TToken>(); state.BeginExpectedTran(); var result = _parser.Parse(ref state); state.EndExpectedTran(false); if (result.Success) { state.Error = new InternalError <TToken>( token, false, startingPosition, null ); return(InternalResult.Failure <Unit>(result.ConsumedInput)); } return(InternalResult.Success( Unit.Value, result.ConsumedInput )); }
internal sealed override InternalResult <TToken> Parse(ref ParseState <TToken> state) { if (!state.HasCurrent) { state.Error = new InternalError <TToken>( Maybe.Nothing <TToken>(), true, state.SourcePos, null ); state.AddExpected(Expected); return(InternalResult.Failure <TToken>(false)); } var token = state.Current; if (!EqualityComparer <TToken> .Default.Equals(token, _token)) { state.Error = new InternalError <TToken>( Maybe.Just(token), false, state.SourcePos, null ); state.AddExpected(Expected); return(InternalResult.Failure <TToken>(false)); } state.Advance(); return(InternalResult.Success <TToken>(token, true)); }
internal sealed override InternalResult <TToken> Parse(IParseState <TToken> state) { var x = state.Peek(); if (!x.HasValue) { state.Error = new ParseError <TToken>( x, true, Expected, state.SourcePos, null ); return(InternalResult.Failure <TToken>(false)); } var val = x.GetValueOrDefault(); if (!_predicate(val)) { state.Error = new ParseError <TToken>( x, false, Expected, state.SourcePos, null ); return(InternalResult.Failure <TToken>(false)); } state.Advance(); return(InternalResult.Success <TToken>(val, true)); }
internal sealed override InternalResult <TToken> Parse(ref ParseState <TToken> state) { if (!state.HasCurrent) { state.Error = new InternalError <TToken>( Maybe.Nothing <TToken>(), true, state.SourcePos, null ); return(InternalResult.Failure <TToken>(false)); } var token = state.Current; if (!_predicate(token)) { state.Error = new InternalError <TToken>( Maybe.Just(token), false, state.SourcePos, null ); return(InternalResult.Failure <TToken>(false)); } state.Advance(); return(InternalResult.Success <TToken>(token, true)); }
internal sealed override InternalResult <Unit> Parse(ref ParseState <TToken> state) { var startingLocation = state.Location; var token = state.HasCurrent ? Maybe.Just(state.Current) : Maybe.Nothing <TToken>(); state.PushBookmark(); // make sure we don't throw out the buffer, we may need it to compute a SourcePos state.BeginExpectedTran(); var result = _parser.Parse(ref state); state.EndExpectedTran(false); state.PopBookmark(); if (result.Success) { state.Error = new InternalError <TToken>( token, false, startingLocation, null ); return(InternalResult.Failure <Unit>(result.ConsumedInput)); } return(InternalResult.Success( Unit.Value, result.ConsumedInput )); }
private InternalResult <IEnumerable <T> > Rest(Parser <TToken, T> parser, ref ParseState <TToken> state, List <T> ts, bool consumedInput) { state.BeginExpectedTran(); var result = parser.Parse(ref state); while (result.Success) { state.EndExpectedTran(false); if (!result.ConsumedInput) { throw new InvalidOperationException("Many() used with a parser which consumed no input"); } consumedInput = true; ts.Add(result.Value); state.BeginExpectedTran(); result = parser.Parse(ref state); } state.EndExpectedTran(result.ConsumedInput); if (result.ConsumedInput) // the most recent parser failed after consuming input { // state.Error set by parser return(InternalResult.Failure <IEnumerable <T> >(true)); } return(InternalResult.Success <IEnumerable <T> >(ts, consumedInput)); }
internal override InternalResult <T> Parse(IParseState <TToken> state) { state.PushBookmark(); var result = _parser.Parse(state); if (result.Success) { state.Rewind(); return(InternalResult.Success <T>(result.Value, false)); } state.PopBookmark(); return(result); }
internal sealed override InternalResult <Unit> Parse(ref ParseState <TToken> state) { if (state.HasCurrent) { state.Error = new InternalError <TToken>( Maybe.Just(state.Current), false, state.SourcePos, null ); state.AddExpected(new Expected <TToken>()); return(InternalResult.Failure <Unit>(false)); } return(InternalResult.Success(Unit.Value, false)); }
internal sealed override InternalResult <TEnumerable> Parse(ref ParseState <TToken> state) { var span = state.LookAhead(_valueTokens.Length); // span.Length <= _valueTokens.Length var errorPos = -1; for (var i = 0; i < span.Length; i++) { if (!EqualityComparer <TToken> .Default.Equals(span[i], _valueTokens[i])) { errorPos = i; break; } } if (errorPos != -1) { // strings didn't match state.Advance(errorPos); state.Error = new InternalError <TToken>( Maybe.Just(span[errorPos]), false, state.Location, null ); state.AddExpected(new Expected <TToken>(_valueTokens)); return(InternalResult.Failure <TEnumerable>(errorPos > 0)); } if (span.Length < _valueTokens.Length) { // strings matched but reached EOF state.Advance(span.Length); state.Error = new InternalError <TToken>( Maybe.Nothing <TToken>(), true, state.Location, null ); state.AddExpected(new Expected <TToken>(_valueTokens)); return(InternalResult.Failure <TEnumerable>(span.Length > 0)); } // OK state.Advance(_valueTokens.Length); return(InternalResult.Success <TEnumerable>(_value, _valueTokens.Length > 0)); }
internal sealed override InternalResult <string> Parse(ref ParseState <char> state) { var span = state.LookAhead(_value.Length); // span.Length <= _valueTokens.Length var errorPos = -1; for (var i = 0; i < span.Length; i++) { if (!char.ToLowerInvariant(span[i]).Equals(char.ToLowerInvariant(_value[i]))) { errorPos = i; break; } } if (errorPos != -1) { // strings didn't match state.Advance(errorPos); state.Error = new InternalError <char>( Maybe.Just(span[errorPos]), false, state.Location, null ); state.AddExpected(Expected); return(InternalResult.Failure <string>(errorPos > 0)); } if (span.Length < _value.Length) { // strings matched but reached EOF state.Advance(span.Length); state.Error = new InternalError <char>( Maybe.Nothing <char>(), true, state.Location, null ); state.AddExpected(Expected); return(InternalResult.Failure <string>(span.Length > 0)); } // OK state.Advance(_value.Length); return(InternalResult.Success <string>(span.ToString(), _value.Length > 0)); }
internal sealed override InternalResult <Unit> Parse(ref ParseState <TToken> state) { var result = state.Peek(); if (result.HasValue) { state.Error = new ParseError <TToken>( result, false, Expected, state.SourcePos, null ); return(InternalResult.Failure <Unit>(false)); } return(InternalResult.Success(Unit.Value, false)); }
internal override InternalResult <IEnumerable <T> > Parse(ref ParseState <TToken> state) { var result = _parser.Parse(ref state); if (!result.Success) { // state.Error set by _parser return(InternalResult.Failure <IEnumerable <T> >(result.ConsumedInput)); } var ts = new List <T> { result.Value }; var consumedInput = result.ConsumedInput; while (true) { state.BeginExpectedTran(); var sepResult = _separator.Parse(ref state); state.EndExpectedTran(!sepResult.Success && sepResult.ConsumedInput); consumedInput = consumedInput || sepResult.ConsumedInput; if (!sepResult.Success) { if (sepResult.ConsumedInput) { // state.Error set by _separator return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } return(InternalResult.Success <IEnumerable <T> >(ts, consumedInput)); } state.BeginExpectedTran(); var itemResult = _parser.Parse(ref state); state.EndExpectedTran(!itemResult.Success && itemResult.ConsumedInput); consumedInput = consumedInput || itemResult.ConsumedInput; if (!itemResult.Success) { if (itemResult.ConsumedInput) { // state.Error set by _parser return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } return(InternalResult.Success <IEnumerable <T> >(ts, consumedInput)); } ts.Add(itemResult.Value); } }
internal sealed override InternalResult <R> Parse(IParseState <TToken> state) { var result = _parser.Parse(state); if (!result.Success) { // state.Error set by _parser return(InternalResult.Failure <R>(result.ConsumedInput)); } var nextParser = _func(result.Value); var result2 = nextParser.Parse(state); if (!result2.Success) { // state.Error set by nextParser return(InternalResult.Failure <R>(result.ConsumedInput || result2.ConsumedInput)); } return(InternalResult.Success <R>(_result(result.Value, result2.Value), result.ConsumedInput || result2.ConsumedInput)); }
public override InternalResult <U> Parse(ref ParseState <TToken> state) { var result1 = _parser.Parse(ref state); if (!result1.Success) { // state.Error set by _parser return(InternalResult.Failure <U>(result1.ConsumedInput)); } var chainer = _factory(); chainer.Apply(result1.Value); var consumedInput = result1.ConsumedInput; state.BeginExpectedTran(); var result = _parser.Parse(ref state); while (result.Success) { state.EndExpectedTran(false); if (!result.ConsumedInput) { chainer.OnError(); throw new InvalidOperationException("Many() used with a parser which consumed no input"); } consumedInput = true; chainer.Apply(result.Value); state.BeginExpectedTran(); result = _parser.Parse(ref state); } state.EndExpectedTran(result.ConsumedInput); if (result.ConsumedInput) // the most recent parser failed after consuming input { // state.Error set by _parser chainer.OnError(); return(InternalResult.Failure <U>(true)); } var z = chainer.GetResult(); return(InternalResult.Success <U>(z, consumedInput)); }
internal sealed override InternalResult <IEnumerable <T> > Parse(IParseState <TToken> state) { var consumedInput = false; var ts = new T[_parsers.Length]; var i = 0; foreach (var p in _parsers) { var result = p.Parse(state); consumedInput = consumedInput || result.ConsumedInput; if (!result.Success) { state.Error = state.Error.WithExpected(Expected); return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } ts[i] = result.Value; i++; } return(InternalResult.Success <IEnumerable <T> >(ts, consumedInput)); }
internal override InternalResult <Unit> Parse(ref ParseState <char> state) { var startingLoc = state.Location; var chunk = state.LookAhead(32); while (chunk.Length > 0) { for (var i = 0; i < chunk.Length; i++) { if (!char.IsWhiteSpace(chunk[i])) { state.Advance(i); return(InternalResult.Success(Unit.Value, state.Location > startingLoc)); } } state.Advance(chunk.Length); chunk = state.LookAhead(32); } return(InternalResult.Success(Unit.Value, state.Location > startingLoc)); }
internal override InternalResult <string> Parse(ref ParseState <TToken> state) { var consumedInput = false; var builder = new InplaceStringBuilder(_count); for (var _ = 0; _ < _count; _++) { var result = _parser.Parse(ref state); consumedInput = consumedInput || result.ConsumedInput; if (!result.Success) { return(InternalResult.Failure <string>(consumedInput)); } builder.Append(result.Value); } return(InternalResult.Success(builder.ToString(), consumedInput)); }
internal override InternalResult <string> Parse(IParseState <TToken> state) { var consumedInput = false; var builder = new PooledStringBuilder(_count); for (var _ = 0; _ < _count; _++) { var result = _parser.Parse(state); consumedInput = consumedInput || result.ConsumedInput; if (!result.Success) { state.Error = state.Error.WithExpected(Expected); return(InternalResult.Failure <string>(consumedInput)); } builder.Append(result.Value); } return(InternalResult.Success(builder.GetStringAndClear(), consumedInput)); }
internal sealed override InternalResult <string> Parse(IParseState <char> state) { var consumedInput = false; var builder = new PooledStringBuilder(_value.Length); foreach (var c in _value) { var result = state.Peek(); if (!result.HasValue) { state.Error = new ParseError <char>( result, true, Expected, state.SourcePos, null ); return(InternalResult.Failure <string>(consumedInput)); } var token = result.GetValueOrDefault(); if (char.ToLowerInvariant(token) != c) { state.Error = new ParseError <char>( result, false, Expected, state.SourcePos, null ); return(InternalResult.Failure <string>(consumedInput)); } consumedInput = true; builder.Append(token); state.Advance(); } return(InternalResult.Success <string>(builder.GetStringAndClear(), consumedInput)); }
internal sealed override InternalResult <string> Parse(ref ParseState <char> state) { var consumedInput = false; var builder = new InplaceStringBuilder(_value.Length); foreach (var c in _value) { if (!state.HasCurrent) { state.Error = new InternalError <char>( Maybe.Nothing <char>(), true, state.SourcePos, null ); state.AddExpected(Expected); return(InternalResult.Failure <string>(consumedInput)); } var token = state.Current; if (char.ToLowerInvariant(token) != char.ToLowerInvariant(c)) { state.Error = new InternalError <char>( Maybe.Just(token), false, state.SourcePos, null ); state.AddExpected(Expected); return(InternalResult.Failure <string>(consumedInput)); } consumedInput = true; builder.Append(token); state.Advance(); } return(InternalResult.Success <string>(builder.ToString(), consumedInput)); }
internal override InternalResult <U> Parse(ref ParseState <TToken> state) { var start = state.Location; state.PushBookmark(); // don't discard input buffer var result = _parser.Parse(ref state); if (!result.Success) { state.PopBookmark(); return(InternalResult.Failure <U>(result.ConsumedInput)); } var delta = state.Location - start; var val = _selector(state.LookBehind(delta), result.Value); state.PopBookmark(); return(InternalResult.Success <U>(val, result.ConsumedInput)); }
internal sealed override InternalResult <IEnumerable <T> > Parse(ref ParseState <TToken> state) { var consumedInput = false; var ts = new T[_parsers.Length]; for (var i = 0; i < _parsers.Length; i++) { var p = _parsers[i]; var result = p.Parse(ref state); consumedInput = consumedInput || result.ConsumedInput; if (!result.Success) { return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } ts[i] = result.Value; } return(InternalResult.Success <IEnumerable <T> >(ts, consumedInput)); }
internal override InternalResult <IEnumerable <T> > Parse(ref ParseState <TToken> state) { var ts = _keepResults ? new List <T>() : null; var firstTime = true; var consumedInput = false; InternalResult <U> terminatorResult; do { var itemResult = _parser.Parse(ref state); consumedInput = consumedInput || itemResult.ConsumedInput; if (!itemResult.Success) { if (itemResult.ConsumedInput) { // state.Error set by _parser return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } state.Error = state.Error.WithExpected(firstTime ? Expected : Round2Expected); return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } if (!itemResult.ConsumedInput) { throw new InvalidOperationException("Until() used with a parser which consumed no input"); } ts?.Add(itemResult.Value); terminatorResult = _terminator.Parse(ref state); if (terminatorResult.ConsumedInput && !terminatorResult.Success) { // state.Error set by _terminator return(InternalResult.Failure <IEnumerable <T> >(consumedInput)); } firstTime = false; } while (!terminatorResult.Success); return(InternalResult.Success <IEnumerable <T> >(ts, consumedInput)); }
internal sealed override InternalResult <Unit> Parse(IParseState <TToken> state) { var startingPosition = state.SourcePos; var token = state.Peek(); var result = _parser.Parse(state); if (result.Success) { state.Error = new ParseError <TToken>( token, false, null, startingPosition, null ); return(InternalResult.Failure <Unit>(result.ConsumedInput)); } return(InternalResult.Success( Unit.Value, result.ConsumedInput )); }
internal sealed override InternalResult <TEnumerable> Parse(IParseState <TToken> state) { var consumedInput = false; foreach (var x in _valueTokens) { var result = state.Peek(); if (!result.HasValue) { state.Error = new ParseError <TToken>( result, true, Expected, state.SourcePos, null ); return(InternalResult.Failure <TEnumerable>(consumedInput)); } TToken token = result.GetValueOrDefault(); if (!EqualityComparer <TToken> .Default.Equals(token, x)) { state.Error = new ParseError <TToken>( result, false, Expected, state.SourcePos, null ); return(InternalResult.Failure <TEnumerable>(consumedInput)); } consumedInput = true; state.Advance(); } return(InternalResult.Success <TEnumerable>(_value, consumedInput)); }
internal sealed override InternalResult <T> Parse(IParseState <TToken> state) => InternalResult.Success <T>(_value, false);
internal override InternalResult <SourcePos> Parse(IParseState <TToken> state) => InternalResult.Success(state.SourcePos, false);