/** the generated parser.
* Maintains a state and a value stack, currently with fixed maximum size.
* @param yyLex scanner.
* @return result of the last reduction, if any.
* @throws ExpressionCompileException on irrecoverable parse error.
*/
public Object yyparse(yyInput yyLex)
{
if (yyMax <= 0)
{
yyMax = 256; // initial size
}
int yyState = 0; // state stack ptr
int [] yyStates = new int[yyMax]; // state stack
Object yyVal = null; // value stack ptr
Object [] yyVals = new Object[yyMax]; // value stack
int yyToken = -1; // current input
int yyErrorFlag = 0; // #tks to shift
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for (;; ++yyTop)
{
if (yyTop >= yyStates.Length) // dynamically increase
{
int[] i = new int[yyStates.Length + yyMax];
System.Array.Copy(yyStates, i, 0);
yyStates = i;
Object[] o = new Object[yyVals.Length + yyMax];
System.Array.Copy(yyVals, o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
if (debug != null)
{
debug.push(yyState, yyVal);
}
yyDiscarded : for (;;) // discarding a token does not change stack
{
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) // else [default] reduce (yyN)
{
if (yyToken < 0)
{
yyToken = yyLex.advance() ? yyLex.token() : 0;
if (debug != null)
{
debug.lex(yyState, yyToken, GetTokenName(yyToken), yyLex.value());
}
}
if ((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0) &&
(yyN < yyTable.Length) && (yyCheck[yyN] == yyToken))
{
if (debug != null)
{
debug.shift(yyState, yyTable[yyN], yyErrorFlag - 1);
}
yyState = yyTable[yyN]; // shift to yyN
yyVal = yyLex.value();
yyToken = -1;
if (yyErrorFlag > 0)
{
--yyErrorFlag;
}
goto yyLoop;
}
if ((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0 &&
yyN < yyTable.Length && yyCheck[yyN] == yyToken)
{
yyN = yyTable[yyN]; // reduce (yyN)
}
else
{
switch (yyErrorFlag)
{
case 0:
yyerror("syntax error", yyExpecting(yyState));
if (debug != null)
{
debug.error("syntax error");
}
goto case 1;
case 1:
case 2:
yyErrorFlag = 3;
do
{
if ((yyN = yySindex[yyStates[yyTop]]) != 0 &&
(yyN += Token.yyErrorCode) >= 0 && yyN < yyTable.Length &&
yyCheck[yyN] == Token.yyErrorCode)
{
if (debug != null)
{
debug.shift(yyStates[yyTop], yyTable[yyN], 3);
}
yyState = yyTable[yyN];
yyVal = yyLex.value();
goto yyLoop;
}
if (debug != null)
{
debug.pop(yyStates[yyTop]);
}
} while (--yyTop >= 0);
if (debug != null)
{
debug.reject();
}
try {
yyVal = yyLex.value();
} catch {
throw new ExpressionCompileException("Syntax error.", yyLex.LastParsedTokenIndex);
}
throw new ExpressionCompileException(string.Format("Syntax error: {0}", yyVal),
yyLex.LastParsedTokenIndex);
case 3:
if (yyToken == 0)
{
if (debug != null)
{
debug.reject();
}
try {
yyVal = yyLex.value();
} catch {
throw new ExpressionCompileException("Syntax error at the end of the file.",
yyLex.LastParsedTokenIndex);
}
throw new ExpressionCompileException(string.Format("Syntax error at the end of the file: {0}", yyVal),
yyLex.LastParsedTokenIndex);
}
if (debug != null)
{
debug.discard(yyState, yyToken, GetTokenName(yyToken),
yyLex.value());
}
yyToken = -1;
goto yyDiscarded; // leave stack alone
}
}
}
int yyV = yyTop + 1 - yyLen[yyN];
if (debug != null)
{
debug.reduce(yyState, yyStates[yyV - 1], yyN, yyRule[yyN], yyLen[yyN]);
}
yyVal = yyDefault(yyV > yyTop ? null : yyVals[yyV]);
switch (yyN)
{
case 1:
#line 41 "Expressions.jay"
{
yyVal = new ConditionalOrOperator(yyVals[-2 + yyTop] as IBooleanExpression, yyVals[0 + yyTop] as IBooleanExpression);
}
break;
case 2:
#line 45 "Expressions.jay"
{
yyVal = new ConditionalAndOperator(yyVals[-2 + yyTop] as IBooleanExpression, yyVals[0 + yyTop] as IBooleanExpression);
}
break;
case 3:
#line 49 "Expressions.jay"
{
yyVal = new NegationOperator(yyVals[0 + yyTop] as IBooleanExpression);
}
break;
case 5:
#line 57 "Expressions.jay"
{
yyVal = yyVals[-1 + yyTop];
}
break;
case 9:
#line 71 "Expressions.jay"
{
yyVal = new FieldValueEqualsStringOperator(yyVals[-2 + yyTop] as IMessageExpression,
yyVals[0 + yyTop] as StringConstantExpression);
}
break;
case 10:
#line 76 "Expressions.jay"
{
yyVal = new MidEqualsStringOperator(yyVals[-7 + yyTop] as IMessageExpression,
yyVals[0 + yyTop] as StringConstantExpression, ( int )yyVals[-5 + yyTop], ( int )yyVals[-3 + yyTop]);
}
break;
case 11:
#line 81 "Expressions.jay"
{
yyVal = new FieldValueEqualsBinaryOperator(yyVals[-2 + yyTop] as IMessageExpression,
yyVals[0 + yyTop] as BinaryConstantExpression);
}
break;
case 12:
#line 86 "Expressions.jay"
{
yyVal = new MidEqualsBinaryOperator(yyVals[-7 + yyTop] as IMessageExpression,
yyVals[0 + yyTop] as BinaryConstantExpression, ( int )yyVals[-5 + yyTop], ( int )yyVals[-3 + yyTop]);
}
break;
case 13:
#line 91 "Expressions.jay"
{
yyVal = new MtiEqualsExpression(( int )yyVals[0 + yyTop], yyVals[-2 + yyTop] as IMessageExpression);
}
break;
case 14:
#line 99 "Expressions.jay"
{
yyVal = new MessageExpression(( int )yyVals[0 + yyTop]);
}
break;
case 17:
#line 109 "Expressions.jay"
{
yyVal = new MessageExpression();
}
break;
case 20:
#line 118 "Expressions.jay"
{
yyVal = new SubMessageExpression(( int )yyVals[-2 + yyTop], new MessageExpression());
}
break;
case 21:
#line 122 "Expressions.jay"
{
yyVal = new SubMessageExpression(( int )yyVals[-2 + yyTop], yyVals[0 + yyTop] as SubMessageExpression);
}
break;
case 22:
#line 129 "Expressions.jay"
{
yyVal = new ParentMessageExpression(new MessageExpression());
}
break;
case 23:
#line 133 "Expressions.jay"
{
yyVal = new ParentMessageExpression(yyVals[0 + yyTop] as SubMessageExpression);
}
break;
case 24:
#line 137 "Expressions.jay"
{
yyVal = new ParentMessageExpression(yyVals[0 + yyTop] as ParentMessageExpression);
}
break;
case 25:
#line 145 "Expressions.jay"
{
yyVal = new IsSetExpression(new MessageExpression(( int )yyVals[-1 + yyTop]));
}
break;
case 26:
#line 149 "Expressions.jay"
{
yyVal = new IsSetExpression(yyVals[-1 + yyTop] as SubMessageExpression);
}
break;
case 27:
#line 153 "Expressions.jay"
{
yyVal = new IsSetExpression(yyVals[-1 + yyTop] as ParentMessageExpression);
}
break;
case 28:
#line 160 "Expressions.jay"
{
yyVal = new SubMessageExpression(( int )yyVals[-2 + yyTop], new MessageExpression(( int )yyVals[0 + yyTop]));
}
break;
case 29:
#line 164 "Expressions.jay"
{
yyVal = new SubMessageExpression(( int )yyVals[-2 + yyTop], yyVals[0 + yyTop] as SubMessageExpression);
}
break;
case 30:
#line 171 "Expressions.jay"
{
yyVal = new ParentMessageExpression(new MessageExpression(( int )yyVals[0 + yyTop]));
}
break;
case 31:
#line 175 "Expressions.jay"
{
yyVal = new ParentMessageExpression(yyVals[0 + yyTop] as SubMessageExpression);
}
break;
case 32:
#line 179 "Expressions.jay"
{
yyVal = new ParentMessageExpression(yyVals[0 + yyTop] as ParentMessageExpression);
}
break;
#line 433 "-"
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if (yyState == 0 && yyM == 0)
{
if (debug != null)
{
debug.shift(0, yyFinal);
}
yyState = yyFinal;
if (yyToken < 0)
{
yyToken = yyLex.advance() ? yyLex.token() : 0;
if (debug != null)
{
debug.lex(yyState, yyToken, GetTokenName(yyToken), yyLex.value());
}
}
if (yyToken == 0)
{
if (debug != null)
{
debug.accept(yyVal);
}
return(yyVal);
}
goto yyLoop;
}
if (((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0) &&
(yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
{
yyState = yyTable[yyN];
}
else
{
yyState = yyDgoto[yyM];
}
if (debug != null)
{
debug.shift(yyStates[yyTop], yyState);
}
goto yyLoop;
}
}
}
Object yyparse (yyInput yyLex) {
if (yyMax <= 0) yyMax = 256;
int yyState = 0;
int [] yyStates = new int[yyMax];
Object yyVal = null;
Object [] yyVals = new Object[yyMax];
int yyToken = -1;
int yyErrorFlag = 0;
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for(;; ++yyTop) {
if(yyTop >= yyStates.Length) {
int[] i = new int[yyStates.Length + yyMax];
yyStates.CopyTo(i, 0);
yyStates = i;
Object[] o = new Object[yyVals.Length + yyMax];
yyVals.CopyTo(o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
yyDiscarded:
for(;;) {
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) {
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyToken)) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
yyToken = -1;
if (yyErrorFlag > 0) -- yyErrorFlag;
goto yyLoop;
}
if((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0
&& yyN < yyTable.Length && yyCheck[yyN] == yyToken)
yyN = yyTable[yyN];
else
switch(yyErrorFlag) {
case 0:
yyerror("syntax error");
goto case 1;
case 1: case 2:
yyErrorFlag = 3;
do {
if((yyN = yySindex[yyStates[yyTop]]) != 0
&& (yyN += Token.yyErrorCode) >= 0 && yyN < yyTable.Length
&& yyCheck[yyN] == Token.yyErrorCode) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
goto yyLoop;
}
} while (--yyTop >= 0);
yyerror("irrecoverable syntax error");
goto yyDiscarded;
case 3:
if (yyToken == 0)
yyerror("irrecoverable syntax error at end-of-file");
yyToken = -1;
goto yyDiscarded;
}
}
int yyV = yyTop + 1 - yyLen[yyN];
yyVal = yyV > yyTop ? null : yyVals[yyV];
switch(yyN) {
case 1:
#line 54 "grammar.y"
{ result = new CriteriaOperator[0]; }
break;
case 2:
#line 55 "grammar.y"
{ result = ((List<CriteriaOperator>)yyVals[-1+yyTop]).ToArray(); }
break;
case 3:
#line 59 "grammar.y"
{ yyVal = new List<CriteriaOperator>(new CriteriaOperator[] {(CriteriaOperator)yyVals[0+yyTop]}); }
break;
case 4:
#line 60 "grammar.y"
{ yyVal = yyVals[-2+yyTop]; ((List<CriteriaOperator>)yyVal).Add((CriteriaOperator)yyVals[0+yyTop]); }
break;
case 5:
#line 64 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 6:
#line 65 "grammar.y"
{
OperandProperty prop2 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop4 = (OperandProperty)yyVals[0+yyTop];
prop2.PropertyName = '<' + prop2.PropertyName + '>' + prop4.PropertyName;
yyVal = prop2;
}
break;
case 7:
#line 74 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 8:
#line 75 "grammar.y"
{ yyVal = new OperandProperty("^"); }
break;
case 9:
#line 79 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 10:
#line 80 "grammar.y"
{
OperandProperty prop1 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop3 = (OperandProperty)yyVals[0+yyTop];
prop1.PropertyName += '.' + prop3.PropertyName;
yyVal = prop1;
}
break;
case 11:
#line 89 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 12:
#line 93 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-5+yyTop], (CriteriaOperator)yyVals[-3+yyTop], agg.AggregateType, agg.AggregatedExpression);
}
break;
case 13:
#line 97 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-4+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 14:
#line 101 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Exists, null); }
break;
case 15:
#line 102 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, Aggregate.Exists, null); }
break;
case 18:
#line 110 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 19:
#line 111 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 20:
#line 112 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 21:
#line 113 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 22:
#line 114 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Min, null); }
break;
case 23:
#line 115 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Max, null); }
break;
case 24:
#line 116 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Avg, null); }
break;
case 25:
#line 117 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Sum, null); }
break;
case 26:
#line 121 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 27:
#line 122 "grammar.y"
{
string paramName = (string)yyVals[0+yyTop];
if(string.IsNullOrEmpty(paramName)) {
OperandValue param = new OperandValue();
resultParameters.Add(param);
yyVal = param;
} else {
bool paramNotFound = true;
foreach(OperandValue v in resultParameters) {
OperandParameter p = v as OperandParameter;
if(ReferenceEquals(p, null))
continue;
if(p.ParameterName != paramName)
continue;
paramNotFound = false;
resultParameters.Add(p);
yyVal = p;
break;
}
if(paramNotFound) {
OperandParameter param = new OperandParameter(paramName);
resultParameters.Add(param);
yyVal = param;
}
}
}
break;
case 28:
#line 148 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 29:
#line 149 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 30:
#line 150 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Multiply ); }
break;
case 31:
#line 151 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Divide ); }
break;
case 32:
#line 152 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Plus ); }
break;
case 33:
#line 153 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Minus ); }
break;
case 34:
#line 154 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Modulo ); }
break;
case 35:
#line 155 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseOr ); }
break;
case 36:
#line 156 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseAnd ); }
break;
case 37:
#line 157 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseXor ); }
break;
case 38:
#line 158 "grammar.y"
{
yyVal = new UnaryOperator( UnaryOperatorType.Minus, (CriteriaOperator)yyVals[0+yyTop] );
try {
if(yyVals[0+yyTop] is OperandValue) {
OperandValue operand = (OperandValue)yyVals[0+yyTop];
if(operand.Value is Int32) {
operand.Value = -(Int32)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int64) {
operand.Value = -(Int64)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Double) {
operand.Value = -(Double)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Decimal) {
operand.Value = -(Decimal)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int16) {
operand.Value = -(Int16)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is SByte) {
operand.Value = -(SByte)operand.Value;
yyVal = operand;
break;
}
}
} catch {}
}
break;
case 39:
#line 191 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.Plus, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 40:
#line 192 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.BitwiseNot, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 41:
#line 193 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Equal); }
break;
case 42:
#line 194 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.NotEqual); }
break;
case 43:
#line 195 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Greater); }
break;
case 44:
#line 196 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Less); }
break;
case 45:
#line 197 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.GreaterOrEqual); }
break;
case 46:
#line 198 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.LessOrEqual); }
break;
case 47:
#line 199 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like); }
break;
case 48:
#line 200 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new BinaryOperator( (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like)); }
break;
case 49:
#line 201 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 50:
#line 202 "grammar.y"
{ yyVal = GroupOperator.And((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 51:
#line 203 "grammar.y"
{ yyVal = GroupOperator.Or((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 52:
#line 204 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 53:
#line 205 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-2+yyTop]); }
break;
case 54:
#line 206 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop])); }
break;
case 55:
#line 207 "grammar.y"
{ yyVal = new InOperator((CriteriaOperator)yyVals[-2+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); }
break;
case 56:
#line 208 "grammar.y"
{ yyVal = new BetweenOperator((CriteriaOperator)yyVals[-6+yyTop], (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 57:
#line 209 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 58:
#line 210 "grammar.y"
{ yyVal = new FunctionOperator(FunctionOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 59:
#line 211 "grammar.y"
{ FunctionOperator fo = new FunctionOperator((FunctionOperatorType)yyVals[-1+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); lexer.CheckFunctionArgumentsCount(fo.OperatorType, fo.Operands.Count); yyVal = fo; }
break;
case 60:
#line 212 "grammar.y"
{ yyVal = null; }
break;
case 61:
#line 216 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 62:
#line 217 "grammar.y"
{ yyVal = new List<CriteriaOperator>(); }
break;
case 63:
#line 221 "grammar.y"
{
List<CriteriaOperator> lst = new List<CriteriaOperator>();
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
case 64:
#line 226 "grammar.y"
{
List<CriteriaOperator> lst = (List<CriteriaOperator>)yyVals[-2+yyTop];
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
#line default
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if(yyState == 0 && yyM == 0) {
yyState = yyFinal;
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if(yyToken == 0)
return yyVal;
goto yyLoop;
}
if(((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
yyState = yyTable[yyN];
else
yyState = yyDgoto[yyM];
goto yyLoop;
}
}
}
/** the generated parser, with debugging messages.
* Maintains a state and a value stack, currently with fixed maximum size.
* @param yyLex scanner.
* @param yydebug debug message writer implementing yyDebug, or null.
* @return result of the last reduction, if any.
* @throws ExpressionCompileException on irrecoverable parse error.
*/
public Object yyparse(yyInput yyLex, Object yyd)
{
this.debug = (yyDebug)yyd;
return(yyparse(yyLex));
}
/// <summary>
/// the generated parser, with debugging messages.
/// Maintains a dynamic state and value stack.
/// </summary>
/// <param name='yyLex'>scanner</param>
/// <returns>result of the last reduction, if any</returns>
/// <exceptions><c>yyException</c> on irrecoverable parse error</exceptions>
public object yyParse(yyInput yyLex)
{
if (yyMax <= 0)
{
yyMax = 256; // initial size
}
int yyState = 0; // state stack ptr
int [] yyStates = new int[yyMax]; // state stack
object yyVal = null; // value stack ptr
object [] yyVals = new object[yyMax]; // value stack
int yyToken = -1; // current input
int yyErrorFlag = 0; // #tokens to shift
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for (;; ++yyTop)
{
if (yyTop >= yyStates.Length) // dynamically increase
{
int[] i = new int[yyStates.Length + yyMax];
yyStates.CopyTo(i, 0);
yyStates = i;
object[] o = new object[yyVals.Length + yyMax];
yyVals.CopyTo(o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
if (yyDebug != null)
{
yyDebug.push(yyState, yyVal);
}
yyDiscarded : for (;;) // discarding a token does not change stack
{
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) // else [default] reduce (yyN)
{
if (yyToken < 0)
{
yyToken = yyLex.Advance() ? yyLex.Token : 0;
if (yyDebug != null)
{
yyDebug.lex(yyState, yyToken, yyName(yyToken), yyLex.Value);
}
}
if ((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0) &&
(yyN < yyTable.Length) && (yyCheck[yyN] == yyToken))
{
if (yyDebug != null)
{
yyDebug.shift(yyState, yyTable[yyN], yyErrorFlag - 1);
}
yyState = yyTable[yyN]; // shift to yyN
yyVal = yyLex.Value;
yyToken = -1;
if (yyErrorFlag > 0)
{
--yyErrorFlag;
}
goto yyLoop;
}
if ((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0 &&
yyN < yyTable.Length && yyCheck[yyN] == yyToken)
{
yyN = yyTable[yyN]; // reduce (yyN)
}
else
{
switch (yyErrorFlag)
{
case 0:
yyError("syntax error", yyExpecting(yyState));
if (yyDebug != null)
{
yyDebug.error("syntax error");
}
goto case 1;
case 1:
case 2:
yyErrorFlag = 3;
do
{
if ((yyN = yySindex[yyStates[yyTop]]) != 0 &&
(yyN += yyErrorCode) >= 0 && yyN < yyTable.Length &&
yyCheck[yyN] == yyErrorCode)
{
if (yyDebug != null)
{
yyDebug.shift(yyStates[yyTop], yyTable[yyN], 3);
}
yyState = yyTable[yyN];
yyVal = yyLex.Value;
goto yyLoop;
}
if (yyDebug != null)
{
yyDebug.pop(yyStates[yyTop]);
}
} while (--yyTop >= 0);
if (yyDebug != null)
{
yyDebug.reject();
}
throw new yyException("irrecoverable syntax error");
case 3:
if (yyToken == 0)
{
if (yyDebug != null)
{
yyDebug.reject();
}
throw new yyException("irrecoverable syntax error at end-of-file");
}
if (yyDebug != null)
{
yyDebug.discard(yyState, yyToken, yyName(yyToken),
yyLex.Value);
}
yyToken = -1;
goto yyDiscarded; // leave stack alone
}
}
}
int yyV = yyTop + 1 - yyLen[yyN];
if (yyDebug != null)
{
yyDebug.reduce(yyState, yyStates[yyV - 1], yyN, yyRule[yyN], yyLen[yyN]);
}
yyVal = yyDefault(yyV > yyTop ? null : yyVals[yyV]);
switch (yyN)
{
case 1:
#line 28 "arith.jay"
{ yyVal = ((double)yyVals[-2 + yyTop]) + ((double)yyVals[0 + yyTop]); }
break;
case 2:
#line 29 "arith.jay"
{ yyVal = ((double)yyVals[-2 + yyTop]) - ((double)yyVals[0 + yyTop]); }
break;
case 3:
#line 30 "arith.jay"
{ yyVal = ((double)yyVals[-2 + yyTop]) * ((double)yyVals[0 + yyTop]); }
break;
case 4:
#line 31 "arith.jay"
{ yyVal = ((double)yyVals[-2 + yyTop]) / ((double)yyVals[0 + yyTop]); }
break;
case 5:
#line 32 "arith.jay"
{ yyVal = yyVals[0 + yyTop]; }
break;
case 6:
#line 33 "arith.jay"
{ yyVal = -((double)yyVals[0 + yyTop]); }
break;
case 7:
#line 34 "arith.jay"
{ yyVal = ((double)yyVals[-1 + yyTop]); }
break;
case 10:
#line 38 "arith.jay"
{ System.Console.WriteLine("\t" + ((double)yyVals[-1 + yyTop])); }
break;
case 12:
#line 40 "arith.jay"
{ yyErrorFlag = 0; }
break;
#line 440 "-"
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if (yyState == 0 && yyM == 0)
{
if (yyDebug != null)
{
yyDebug.shift(0, yyFinal);
}
yyState = yyFinal;
if (yyToken < 0)
{
yyToken = yyLex.Advance() ? yyLex.Token : 0;
if (yyDebug != null)
{
yyDebug.lex(yyState, yyToken, yyName(yyToken), yyLex.Value);
}
}
if (yyToken == 0)
{
if (yyDebug != null)
{
yyDebug.accept(yyVal);
}
return(yyVal);
}
goto yyLoop;
}
if (((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0) &&
(yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
{
yyState = yyTable[yyN];
}
else
{
yyState = yyDgoto[yyM];
}
if (yyDebug != null)
{
yyDebug.shift(yyStates[yyTop], yyState);
}
goto yyLoop;
}
}
}
/// <summary>
/// the generated parser, with debugging messages.
/// Maintains a dynamic state and value stack.
/// </summary>
/// <param name='yyLex'>scanner</param>
/// <param name='yyDebug'>debug message writer implementing <c>yyDebug</c>,
/// or <c>null</c></param>
/// <returns>result of the last reduction, if any</returns>
/// <exceptions><c>yyException</c> on irrecoverable parse error</exceptions>
public object yyParse(yyInput yyLex, object yyDebug)
{
this.yyDebug = (yyDebug.yyDebug)yyDebug;
return(yyParse(yyLex));
}
/// <summary>
/// the generated parser, with debugging messages.
/// Maintains a dynamic state and value stack.
/// </summary>
/// <param name='yyLex'>scanner</param>
/// <returns>result of the last reduction, if any</returns>
/// <exceptions><c>yyException</c> on irrecoverable parse error</exceptions>
public object yyParse (yyInput yyLex) {
if (yyMax <= 0) yyMax = 256; // initial size
int yyState = 0; // state stack ptr
int [] yyStates = new int[yyMax]; // state stack
object yyVal = null; // value stack ptr
object [] yyVals = new object[yyMax]; // value stack
int yyToken = -1; // current input
int yyErrorFlag = 0; // #tokens to shift
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for (;; ++ yyTop) {
if (yyTop >= yyStates.Length) { // dynamically increase
int[] i = new int[yyStates.Length+yyMax];
yyStates.CopyTo (i, 0);
yyStates = i;
object[] o = new object[yyVals.Length+yyMax];
yyVals.CopyTo (o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
if (yyDebug != null) yyDebug.push(yyState, yyVal);
yyDiscarded: for (;;) { // discarding a token does not change stack
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) { // else [default] reduce (yyN)
if (yyToken < 0) {
yyToken = yyLex.Advance() ? yyLex.Token : 0;
if (yyDebug != null)
yyDebug.lex(yyState, yyToken, yyName(yyToken), yyLex.Value);
}
if ((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyToken)) {
if (yyDebug != null)
yyDebug.shift(yyState, yyTable[yyN], yyErrorFlag-1);
yyState = yyTable[yyN]; // shift to yyN
yyVal = yyLex.Value;
yyToken = -1;
if (yyErrorFlag > 0) -- yyErrorFlag;
goto yyLoop;
}
if ((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0
&& yyN < yyTable.Length && yyCheck[yyN] == yyToken)
yyN = yyTable[yyN]; // reduce (yyN)
else
switch (yyErrorFlag) {
case 0:
yyError("syntax error", yyExpecting(yyState));
if (yyDebug != null) yyDebug.error("syntax error");
goto case 1;
case 1: case 2:
yyErrorFlag = 3;
do {
if ((yyN = yySindex[yyStates[yyTop]]) != 0
&& (yyN += yyErrorCode) >= 0 && yyN < yyTable.Length
&& yyCheck[yyN] == yyErrorCode) {
if (yyDebug != null)
yyDebug.shift(yyStates[yyTop], yyTable[yyN], 3);
yyState = yyTable[yyN];
yyVal = yyLex.Value;
goto yyLoop;
}
if (yyDebug != null) yyDebug.pop(yyStates[yyTop]);
} while (-- yyTop >= 0);
if (yyDebug != null) yyDebug.reject();
throw new yyException("irrecoverable syntax error");
case 3:
if (yyToken == 0) {
if (yyDebug != null) yyDebug.reject();
throw new yyException("irrecoverable syntax error at end-of-file");
}
if (yyDebug != null)
yyDebug.discard(yyState, yyToken, yyName(yyToken),
yyLex.Value);
yyToken = -1;
goto yyDiscarded; // leave stack alone
}
}
int yyV = yyTop + 1-yyLen[yyN];
if (yyDebug != null)
yyDebug.reduce(yyState, yyStates[yyV-1], yyN, yyRule[yyN], yyLen[yyN]);
yyVal = yyDefault(yyV > yyTop ? null : yyVals[yyV]);
switch (yyN) {
case 2:
#line 18 "recover.jay"
{ yyErrorFlag = 0; Console.WriteLine("opt"); }
break;
case 3:
#line 19 "recover.jay"
{ yyErrorFlag = 0; Console.WriteLine("seq"); }
break;
case 4:
#line 20 "recover.jay"
{ yyErrorFlag = 0; Console.WriteLine("list"); }
break;
case 6:
#line 23 "recover.jay"
{ yyErrorFlag = 0; }
break;
case 9:
#line 27 "recover.jay"
{ yyErrorFlag = 0; }
break;
case 13:
#line 32 "recover.jay"
{ yyErrorFlag = 0; }
break;
case 16:
#line 35 "recover.jay"
{ yyErrorFlag = 0; }
break;
#line 443 "-"
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if (yyState == 0 && yyM == 0) {
if (yyDebug != null) yyDebug.shift(0, yyFinal);
yyState = yyFinal;
if (yyToken < 0) {
yyToken = yyLex.Advance() ? yyLex.Token : 0;
if (yyDebug != null)
yyDebug.lex(yyState, yyToken,yyName(yyToken), yyLex.Value);
}
if (yyToken == 0) {
if (yyDebug != null) yyDebug.accept(yyVal);
return yyVal;
}
goto yyLoop;
}
if (((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
yyState = yyTable[yyN];
else
yyState = yyDgoto[yyM];
if (yyDebug != null) yyDebug.shift(yyStates[yyTop], yyState);
goto yyLoop;
}
}
}
/// <summary>
/// the generated parser, with debugging messages.
/// Maintains a dynamic state and value stack.
/// </summary>
/// <param name='yyLex'>scanner</param>
/// <param name='yyDebug'>debug message writer implementing <c>yyDebug</c>,
/// or <c>null</c></param>
/// <returns>result of the last reduction, if any</returns>
/// <exceptions><c>yyException</c> on irrecoverable parse error</exceptions>
public object yyParse (yyInput yyLex, object yyDebug) {
this.yyDebug = (yyDebug.yyDebug)yyDebug;
return yyParse(yyLex);
}
