public ParserResult <IEnumerable <O>, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
List <O> list = new List <O>();
while (true)
{
try
{
if (input.Available)
{
ParserResult <O, C> result = parser.Parse(ref input, context);
list.Add(result.Result);
context = result.Context;
}
else
{
break;
}
}
catch (ParserException <I> e)
{
if (loopToEnd)
{
throw;
}
else
{
break;
}
}
}
return(new ParserResult <IEnumerable <O>, C>(list, context));
}
public ParserResult <Pair <A, B>, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
ICloneableEnumerator <I> temp = input.CloneEnumerator();
var resultA = a.Parse(ref temp, context);
var resultB = b.Parse(ref temp, resultA.Context);
input = temp;
return(new ParserResult <Pair <A, B>, C>(new Pair <A, B>(resultA.Result, resultB.Result), resultB.Context));
}
public ParserResult <O, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
try
{
return(parser.Parse(ref input, context));
}
catch (ParserException <I> e)
{
return(handler(e));
}
}
public ParserResult <Lexer <I> .Token, C> Parse(ref ICloneableEnumerator <Lexer <I> .Token> input, C context)
{
if (input.Available && input.Current.Tag.CompareTo(value) == 0)
{
Lexer <I> .Token token = input.Current;
input.MoveNext();
return(new ParserResult <Lexer <I> .Token, C>(token, context));
}
else
{
throw new ParserException <Lexer <I> .Token>("此处需要" + name + "。", input);
}
}
public ParserResult <Lexer <I> .Token, C> Parse(ref ICloneableEnumerator <Lexer <I> .Token> input, C context)
{
if (input.Available)
{
string inputValue = input.Current.Value;
string value = values.Where(s => inputValue == s).FirstOrDefault();
if (value != null)
{
Lexer <I> .Token token = input.Current;
input.MoveNext();
return(new ParserResult <Lexer <I> .Token, C>(token, context));
}
}
throw new ParserException <Lexer <I> .Token>("此处需要" + name + "。", input);
}
public virtual O Parse(string input)
{
if (lexer == null)
{
Initialize(out lexer, out parser);
}
ICloneableEnumerator <Lexer <I> .Token> tokens = lexer.Parse(input).Where(TokenFilter).GetCloneableEnumerable().CreateCloneableEnumerator();
tokens.MoveNext();
ParserResult <O, C> result = parser.Parse(ref tokens, CreateContext());
if (tokens.Available)
{
throw new ParserException <Lexer <I> .Token>("存在没分析完的字符串。", tokens);
}
else
{
return(result.Result);
}
}
public ParserResult <O, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
try
{
return(a.Parse(ref input, context));
}
catch (ParserException <I> eA)
{
try
{
return(b.Parse(ref input, context));
}
catch (ParserException <I> eB)
{
if (eA.Input.CompareTo(eB.Input) < 0)
{
throw;
}
}
throw;
}
}
public ParserException(string message, ICloneableEnumerator <T> input)
: base(message)
{
this.Input = input;
}
public int CompareTo(ICloneableEnumerator <T> other)
{
return(index.CompareTo(((ListEnumerator <T>)other).index));
}
public ParserResult <O, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
return(parser.Parse(ref input, context));
}
public ParserResult <O, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
return(new ParserResult <O, C>(value, context));
}
public ParserResult <B, C> Parse(ref ICloneableEnumerator <I> input, C context)
{
ParserResult <A, C> result = parser.Parse(ref input, context);
return(new ParserResult <B, C>(converter(result.Result), result.Context));
}
