/** 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); }