public override bool Parse(SyntacticState state)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
// null-coalescing-expression is required
if (!NullCoalescingExpression.S.Parse(state))
return false;
// if captured expression ends with "?"
LexicalEntry entry = state.GetInner(state.InnerPosition - 1);
if (state.GetOuter(entry) == "?")
{
// check whether "? and :" part goes after
bool full = ParseAll(
state,
QuestionTerminal.S,
Expression.S,
ColonTerminal.S,
Expression.S);
// if so, everything is OK
if (full)
{
state.AddBack(Key, innerIndex, outerIndex);
return true;
}
// if not, make another attempt to parse conditional expression
// handling null-coalescing-expression without trailing "?"
state.Reset(innerIndex, outerIndex);
// if we could do that, we can return
if (ParseAll(
state,
NullCoalescingExpressionShorten.S,
QuestionTerminal.S,
Expression.S,
ColonTerminal.S,
Expression.S))
{
return true;
}
// if not, parse initial null-coalescing-expression once again
NullCoalescingExpression.S.Parse(state);
}
ParseAll(
state,
QuestionTerminal.S,
Expression.S,
ColonTerminal.S,
Expression.S);
state.AddBack(Key, innerIndex, outerIndex);
return true;
}
public override bool Parse(SyntacticState state)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
// non-assignment-expression is required
if (!NonAssignmentExpression.S.Parse(state))
{
return(false);
}
// if unary-expression has been captured
// we should try to capture rest parts of assignment
if (state.CheckEntry(UnaryExpression.S.Key, innerIndex))
{
int inner = state.InnerPosition;
int outer = state.OuterPosition;
// the rest parts of assigment are assignment-operator
if (AssignmentOperator.S.Parse(state))
{
// and another expression (recursive call here)
if (S.Parse(state))
{
}
else
{
state.Reset(inner, outer);
}
}
}
state.AddBack(Key, innerIndex, outerIndex);
return(true);
}
public override bool Parse(SyntacticState state)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
// non-assignment-expression is required
if (!NonAssignmentExpression.S.Parse(state))
return false;
// if unary-expression has been captured
// we should try to capture rest parts of assignment
if (state.CheckEntry(UnaryExpression.S.Key, innerIndex))
{
int inner = state.InnerPosition;
int outer = state.OuterPosition;
// the rest parts of assigment are assignment-operator
if (AssignmentOperator.S.Parse(state))
{
// and another expression (recursive call here)
if (S.Parse(state))
{
}
else
{
state.Reset(inner, outer);
}
}
}
state.AddBack(Key, innerIndex, outerIndex);
return true;
}
public override bool Parse(SyntacticState state)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
// null-coalescing-expression is required
if (!NullCoalescingExpression.S.Parse(state))
{
return(false);
}
// if captured expression ends with "?"
LexicalEntry entry = state.GetInner(state.InnerPosition - 1);
if (state.GetOuter(entry) == "?")
{
// check whether "? and :" part goes after
bool full = ParseAll(
state,
QuestionTerminal.S,
Expression.S,
ColonTerminal.S,
Expression.S);
// if so, everything is OK
if (full)
{
state.AddBack(Key, innerIndex, outerIndex);
return(true);
}
// if not, make another attempt to parse conditional expression
// handling null-coalescing-expression without trailing "?"
state.Reset(innerIndex, outerIndex);
// if we could do that, we can return
if (ParseAll(
state,
NullCoalescingExpressionShorten.S,
QuestionTerminal.S,
Expression.S,
ColonTerminal.S,
Expression.S))
{
return(true);
}
// if not, parse initial null-coalescing-expression once again
NullCoalescingExpression.S.Parse(state);
}
ParseAll(
state,
QuestionTerminal.S,
Expression.S,
ColonTerminal.S,
Expression.S);
state.AddBack(Key, innerIndex, outerIndex);
return(true);
}
/// <summary>
/// Tries to parse a batch of similar syntactic items with specified delimiter.
/// </summary>
private bool ParseManyInternal(SyntacticState state, SyntacticItem part, SyntacticItem delimiter)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
if (!part.Parse(state))
return false;
while (true)
{
int lastInnerIndex = state.InnerPosition;
int lastOuterIndex = state.OuterPosition;
if (delimiter != null)
{
if (!delimiter.Parse(state))
break;
}
if (!part.Parse(state))
{
state.Reset(lastInnerIndex, lastOuterIndex);
break;
}
}
state.AddBack(Key, innerIndex, outerIndex);
return true;
}
/// <summary>
/// Tries to parse any of specified syntactic items.
/// </summary>
private bool ParseAnyInternal(SyntacticState state, params SyntacticItem[] parts)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
foreach (SyntacticItem part in parts)
{
if (part.Parse(state))
{
state.AddBack(Key, innerIndex, outerIndex);
return true;
}
}
return false;
}
/// <summary>
/// Tries to parse a consequent number of specified syntactic items.
/// </summary>
private bool ParseAllInternal(SyntacticState state, params SyntacticItem[] parts)
{
int innerIndex = state.InnerPosition;
int outerIndex = state.OuterPosition;
bool parsed = true;
foreach (SyntacticItem part in parts)
{
if (!part.Parse(state))
{
parsed = false;
break;
}
}
if (!parsed)
{
state.Reset(innerIndex, outerIndex);
return false;
}
state.AddBack(Key, innerIndex, outerIndex);
return true;
}
