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);
