| /******************************************************************************* |
| * Copyright (c) 2005 BEA Systems and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * BEA Systems - initial implementation |
| * |
| *******************************************************************************/ |
| /* Generated By:JJTree&JavaCC: Do not edit this line. JSPELParser.java */ |
| package org.eclipse.wst.jsdt.web.core.internal.java.jspel; |
| |
| public class JSPELParser/* @bgen(jjtree) */implements JSPELParserTreeConstants, |
| JSPELParserConstants {/* @bgen(jjtree) */ |
| protected JJTJSPELParserState jjtree = new JJTJSPELParserState(); |
| |
| void jjtreeOpenNodeScope(Node n) { |
| ((SimpleNode) n).setFirstToken(getToken(1)); |
| } |
| |
| void jjtreeCloseNodeScope(Node n) { |
| ((SimpleNode) n).setLastToken(getToken(0)); |
| } |
| |
| public static JSPELParser createParser(java.lang.String input) { |
| java.io.StringReader reader = new java.io.StringReader(input); |
| return new JSPELParser(reader); |
| } |
| |
| public void ReInit(java.lang.String input) { |
| java.io.StringReader reader = new java.io.StringReader(input); |
| ReInit(reader); |
| } |
| |
| final public ASTExpression Expression() throws ParseException { |
| /* @bgen(jjtree) Expression */ |
| ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| try { |
| if (jj_2_1(2147483647)) { |
| ChoiceExpression(); |
| } else { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case NULL: |
| case LPAREN: |
| case MINUS: |
| case NOT1: |
| case NOT2: |
| case EMPTY: |
| case IDENTIFIER: |
| OrExpression(); |
| break; |
| default: |
| jj_la1[0] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtc000 = false; |
| jjtreeCloseNodeScope(jjtn000); |
| { |
| if (true) { |
| return jjtn000; |
| } |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void OrExpression() throws ParseException { |
| /* @bgen(jjtree) #OrExpression(> 1) */ |
| ASTOrExpression jjtn000 = new ASTOrExpression(JJTOREXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t; |
| try { |
| AndExpression(); |
| label_1: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case OR1: |
| case OR2: |
| |
| break; |
| default: |
| jj_la1[1] = jj_gen; |
| break label_1; |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case OR1: |
| t = jj_consume_token(OR1); |
| break; |
| case OR2: |
| t = jj_consume_token(OR2); |
| break; |
| default: |
| jj_la1[2] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jjtn000.addOperatorToken(t); |
| AndExpression(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void AndExpression() throws ParseException { |
| /* @bgen(jjtree) #AndExpression(> 1) */ |
| ASTAndExpression jjtn000 = new ASTAndExpression(JJTANDEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t; |
| try { |
| EqualityExpression(); |
| label_2: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case AND1: |
| case AND2: |
| |
| break; |
| default: |
| jj_la1[3] = jj_gen; |
| break label_2; |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case AND1: |
| t = jj_consume_token(AND1); |
| break; |
| case AND2: |
| t = jj_consume_token(AND2); |
| break; |
| default: |
| jj_la1[4] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jjtn000.addOperatorToken(t); |
| EqualityExpression(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void EqualityExpression() throws ParseException { |
| /* @bgen(jjtree) #EqualityExpression(> 1) */ |
| ASTEqualityExpression jjtn000 = new ASTEqualityExpression( |
| JJTEQUALITYEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t; |
| try { |
| RelationalExpression(); |
| label_3: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case EQ1: |
| case EQ2: |
| case NEQ1: |
| case NEQ2: |
| |
| break; |
| default: |
| jj_la1[5] = jj_gen; |
| break label_3; |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case EQ1: |
| t = jj_consume_token(EQ1); |
| break; |
| case EQ2: |
| t = jj_consume_token(EQ2); |
| break; |
| case NEQ1: |
| t = jj_consume_token(NEQ1); |
| break; |
| case NEQ2: |
| t = jj_consume_token(NEQ2); |
| break; |
| default: |
| jj_la1[6] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jjtn000.addOperatorToken(t); |
| RelationalExpression(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void RelationalExpression() throws ParseException { |
| /* @bgen(jjtree) #RelationalExpression(> 1) */ |
| ASTRelationalExpression jjtn000 = new ASTRelationalExpression( |
| JJTRELATIONALEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t; |
| try { |
| AddExpression(); |
| label_4: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case GT1: |
| case GT2: |
| case LT1: |
| case LT2: |
| case LE1: |
| case LE2: |
| case GE1: |
| case GE2: |
| |
| break; |
| default: |
| jj_la1[7] = jj_gen; |
| break label_4; |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case LT1: |
| t = jj_consume_token(LT1); |
| break; |
| case LT2: |
| t = jj_consume_token(LT2); |
| break; |
| case GT1: |
| t = jj_consume_token(GT1); |
| break; |
| case GT2: |
| t = jj_consume_token(GT2); |
| break; |
| case GE1: |
| t = jj_consume_token(GE1); |
| break; |
| case GE2: |
| t = jj_consume_token(GE2); |
| break; |
| case LE1: |
| t = jj_consume_token(LE1); |
| break; |
| case LE2: |
| t = jj_consume_token(LE2); |
| break; |
| default: |
| jj_la1[8] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jjtn000.addOperatorToken(t); |
| AddExpression(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void AddExpression() throws ParseException { |
| /* @bgen(jjtree) #AddExpression(> 1) */ |
| ASTAddExpression jjtn000 = new ASTAddExpression(JJTADDEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t; |
| try { |
| MultiplyExpression(); |
| label_5: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case PLUS: |
| case MINUS: |
| |
| break; |
| default: |
| jj_la1[9] = jj_gen; |
| break label_5; |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case PLUS: |
| t = jj_consume_token(PLUS); |
| break; |
| case MINUS: |
| t = jj_consume_token(MINUS); |
| break; |
| default: |
| jj_la1[10] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jjtn000.addOperatorToken(t); |
| MultiplyExpression(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void MultiplyExpression() throws ParseException { |
| /* @bgen(jjtree) #MultiplyExpression(> 1) */ |
| ASTMultiplyExpression jjtn000 = new ASTMultiplyExpression( |
| JJTMULTIPLYEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t; |
| try { |
| UnaryExpression(); |
| label_6: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case MULTIPLY: |
| case DIVIDE1: |
| case DIVIDE2: |
| case MODULUS1: |
| case MODULUS2: |
| |
| break; |
| default: |
| jj_la1[11] = jj_gen; |
| break label_6; |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case MULTIPLY: |
| t = jj_consume_token(MULTIPLY); |
| break; |
| case DIVIDE1: |
| t = jj_consume_token(DIVIDE1); |
| break; |
| case DIVIDE2: |
| t = jj_consume_token(DIVIDE2); |
| break; |
| case MODULUS1: |
| t = jj_consume_token(MODULUS1); |
| break; |
| case MODULUS2: |
| t = jj_consume_token(MODULUS2); |
| break; |
| default: |
| jj_la1[12] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jjtn000.addOperatorToken(t); |
| UnaryExpression(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void ChoiceExpression() throws ParseException { |
| /* @bgen(jjtree) ChoiceExpression */ |
| ASTChoiceExpression jjtn000 = new ASTChoiceExpression( |
| JJTCHOICEEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| try { |
| OrExpression(); |
| jj_consume_token(COND); |
| OrExpression(); |
| jj_consume_token(COLON); |
| OrExpression(); |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void UnaryExpression() throws ParseException { |
| /* @bgen(jjtree) UnaryExpression */ |
| ASTUnaryExpression jjtn000 = new ASTUnaryExpression(JJTUNARYEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| try { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case MINUS: |
| case NOT1: |
| case NOT2: |
| case EMPTY: |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case NOT1: |
| jj_consume_token(NOT1); |
| break; |
| case NOT2: |
| jj_consume_token(NOT2); |
| break; |
| case MINUS: |
| jj_consume_token(MINUS); |
| break; |
| case EMPTY: |
| jj_consume_token(EMPTY); |
| break; |
| default: |
| jj_la1[13] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| UnaryExpression(); |
| break; |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case NULL: |
| case LPAREN: |
| case IDENTIFIER: |
| Value(); |
| break; |
| default: |
| jj_la1[14] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void Value() throws ParseException { |
| /* @bgen(jjtree) Value */ |
| ASTValue jjtn000 = new ASTValue(JJTVALUE); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| try { |
| ValuePrefix(); |
| label_7: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case DOT: |
| case LBRACKET: |
| |
| break; |
| default: |
| jj_la1[15] = jj_gen; |
| break label_7; |
| } |
| ValueSuffix(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void ValuePrefix() throws ParseException { |
| /* @bgen(jjtree) ValuePrefix */ |
| ASTValuePrefix jjtn000 = new ASTValuePrefix(JJTVALUEPREFIX); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| try { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case NULL: |
| Literal(); |
| break; |
| case LPAREN: |
| jj_consume_token(LPAREN); |
| Expression(); |
| jj_consume_token(RPAREN); |
| break; |
| default: |
| jj_la1[16] = jj_gen; |
| if (jj_2_2(3)) { |
| FunctionInvocation(); |
| } else { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case IDENTIFIER: |
| jj_consume_token(IDENTIFIER); |
| break; |
| default: |
| jj_la1[17] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void ValueSuffix() throws ParseException { |
| /* @bgen(jjtree) ValueSuffix */ |
| ASTValueSuffix jjtn000 = new ASTValueSuffix(JJTVALUESUFFIX); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token t = null; |
| try { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case DOT: |
| jj_consume_token(DOT); |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case IDENTIFIER: |
| t = jj_consume_token(IDENTIFIER); |
| break; |
| default: |
| jj_la1[18] = jj_gen; |
| |
| } |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtc000 = false; |
| jjtreeCloseNodeScope(jjtn000); |
| jjtn000.setPropertyNameToken(t); |
| break; |
| case LBRACKET: |
| jj_consume_token(LBRACKET); |
| Expression(); |
| jj_consume_token(RBRACKET); |
| break; |
| default: |
| jj_la1[19] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void FunctionInvocation() throws ParseException { |
| /* @bgen(jjtree) FunctionInvocation */ |
| ASTFunctionInvocation jjtn000 = new ASTFunctionInvocation( |
| JJTFUNCTIONINVOCATION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| Token prefix = null, name = null; |
| try { |
| prefix = jj_consume_token(IDENTIFIER); |
| jj_consume_token(COLON); |
| jjtn000.setFullFunctionName(prefix.image + ":"); |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case IDENTIFIER: |
| name = jj_consume_token(IDENTIFIER); |
| break; |
| default: |
| jj_la1[20] = jj_gen; |
| |
| } |
| if (null != prefix && null != name) { |
| jjtn000.setFullFunctionName(prefix.image + ":" |
| + (null == name ? "" : name.image)); |
| } else if (null != name) { |
| jjtn000.setFullFunctionName(name.image); |
| } |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case LPAREN: |
| jj_consume_token(LPAREN); |
| Expression(); |
| label_8: while (true) { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case COMMA: |
| |
| break; |
| default: |
| jj_la1[21] = jj_gen; |
| break label_8; |
| } |
| jj_consume_token(COMMA); |
| Expression(); |
| } |
| try { |
| jj_consume_token(RPAREN); |
| } catch (Exception e) { |
| |
| } |
| break; |
| default: |
| jj_la1[22] = jj_gen; |
| |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof RuntimeException) { |
| { |
| if (true) { |
| throw (RuntimeException) jjte000; |
| } |
| } |
| } |
| if (jjte000 instanceof ParseException) { |
| { |
| if (true) { |
| throw (ParseException) jjte000; |
| } |
| } |
| } |
| { |
| if (true) { |
| throw (Error) jjte000; |
| } |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final public void Literal() throws ParseException { |
| /* @bgen(jjtree) Literal */ |
| ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| jjtreeOpenNodeScope(jjtn000); |
| try { |
| switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) { |
| case TRUE: |
| jj_consume_token(TRUE); |
| break; |
| case FALSE: |
| jj_consume_token(FALSE); |
| break; |
| case INTEGER_LITERAL: |
| jj_consume_token(INTEGER_LITERAL); |
| break; |
| case FLOATING_POINT_LITERAL: |
| jj_consume_token(FLOATING_POINT_LITERAL); |
| break; |
| case STRING_LITERAL: |
| jj_consume_token(STRING_LITERAL); |
| break; |
| case NULL: |
| jj_consume_token(NULL); |
| break; |
| default: |
| jj_la1[23] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| jjtreeCloseNodeScope(jjtn000); |
| } |
| } |
| } |
| |
| final private boolean jj_2_1(int xla) { |
| jj_la = xla; |
| jj_lastpos = jj_scanpos = token; |
| try { |
| return !jj_3_1(); |
| } catch (LookaheadSuccess ls) { |
| return true; |
| } finally { |
| jj_save(0, xla); |
| } |
| } |
| |
| final private boolean jj_2_2(int xla) { |
| jj_la = xla; |
| jj_lastpos = jj_scanpos = token; |
| try { |
| return !jj_3_2(); |
| } catch (LookaheadSuccess ls) { |
| return true; |
| } finally { |
| jj_save(1, xla); |
| } |
| } |
| |
| final private boolean jj_3R_10() { |
| if (jj_scan_token(LPAREN)) { |
| return true; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_9() { |
| if (jj_scan_token(IDENTIFIER)) { |
| return true; |
| } |
| if (jj_scan_token(COLON)) { |
| return true; |
| } |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(47)) { |
| jj_scanpos = xsp; |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_10()) { |
| jj_scanpos = xsp; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3_2() { |
| if (jj_3R_9()) { |
| return true; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3_1() { |
| if (jj_scan_token(COND)) { |
| return true; |
| } |
| return false; |
| } |
| |
| public JSPELParserTokenManager token_source; |
| SimpleCharStream jj_input_stream; |
| public Token token, jj_nt; |
| private int jj_ntk; |
| private Token jj_scanpos, jj_lastpos; |
| private int jj_la; |
| public boolean lookingAhead = false; |
| // private boolean jj_semLA; |
| private int jj_gen; |
| final private int[] jj_la1 = new int[24]; |
| static private int[] jj_la1_0; |
| static private int[] jj_la1_1; |
| static { |
| jj_la1_0(); |
| jj_la1_1(); |
| } |
| |
| private static void jj_la1_0() { |
| jj_la1_0 = new int[] { 0x4001d60, 0x0, 0x0, 0x0, 0x0, 0x30c0000, |
| 0x30c0000, 0xf3c000, 0xf3c000, 0x0, 0x0, 0x0, 0x0, 0x0, |
| 0x4001d60, 0x40002000, 0x4001d60, 0x0, 0x0, 0x40002000, 0x0, |
| 0x10000000, 0x4000000, 0x1d60, }; |
| } |
| |
| private static void jj_la1_1() { |
| jj_la1_1 = new int[] { 0xa182, 0x1800, 0x1800, 0x600, 0x600, 0x0, 0x0, |
| 0x0, 0x0, 0x3, 0x3, 0x7c, 0x7c, 0x2182, 0xa182, 0x0, 0x0, |
| 0x8000, 0x8000, 0x0, 0x8000, 0x0, 0x0, 0x0, }; |
| } |
| |
| final private JJCalls[] jj_2_rtns = new JJCalls[2]; |
| private boolean jj_rescan = false; |
| private int jj_gc = 0; |
| |
| public JSPELParser(java.io.InputStream stream) { |
| jj_input_stream = new SimpleCharStream(stream, 1, 1); |
| token_source = new JSPELParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 24; i++) { |
| jj_la1[i] = -1; |
| } |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| jj_2_rtns[i] = new JJCalls(); |
| } |
| } |
| |
| public void ReInit(java.io.InputStream stream) { |
| jj_input_stream.ReInit(stream, 1, 1); |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| jj_gen = 0; |
| for (int i = 0; i < 24; i++) { |
| jj_la1[i] = -1; |
| } |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| jj_2_rtns[i] = new JJCalls(); |
| } |
| } |
| |
| public JSPELParser(java.io.Reader stream) { |
| jj_input_stream = new SimpleCharStream(stream, 1, 1); |
| token_source = new JSPELParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 24; i++) { |
| jj_la1[i] = -1; |
| } |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| jj_2_rtns[i] = new JJCalls(); |
| } |
| } |
| |
| public void ReInit(java.io.Reader stream) { |
| jj_input_stream.ReInit(stream, 1, 1); |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| jj_gen = 0; |
| for (int i = 0; i < 24; i++) { |
| jj_la1[i] = -1; |
| } |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| jj_2_rtns[i] = new JJCalls(); |
| } |
| } |
| |
| public JSPELParser(JSPELParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 24; i++) { |
| jj_la1[i] = -1; |
| } |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| jj_2_rtns[i] = new JJCalls(); |
| } |
| } |
| |
| public void ReInit(JSPELParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| jj_gen = 0; |
| for (int i = 0; i < 24; i++) { |
| jj_la1[i] = -1; |
| } |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| jj_2_rtns[i] = new JJCalls(); |
| } |
| } |
| |
| final private Token jj_consume_token(int kind) throws ParseException { |
| Token oldToken; |
| if ((oldToken = token).next != null) { |
| token = token.next; |
| } else { |
| token = token.next = token_source.getNextToken(); |
| } |
| jj_ntk = -1; |
| if (token.kind == kind) { |
| jj_gen++; |
| if (++jj_gc > 100) { |
| jj_gc = 0; |
| for (int i = 0; i < jj_2_rtns.length; i++) { |
| JJCalls c = jj_2_rtns[i]; |
| while (c != null) { |
| if (c.gen < jj_gen) { |
| c.first = null; |
| } |
| c = c.next; |
| } |
| } |
| } |
| return token; |
| } |
| token = oldToken; |
| jj_kind = kind; |
| throw generateParseException(); |
| } |
| |
| static private final class LookaheadSuccess extends java.lang.Error { |
| private static final long serialVersionUID = 1L; |
| } |
| |
| final private LookaheadSuccess jj_ls = new LookaheadSuccess(); |
| |
| final private boolean jj_scan_token(int kind) { |
| if (jj_scanpos == jj_lastpos) { |
| jj_la--; |
| if (jj_scanpos.next == null) { |
| jj_lastpos = jj_scanpos = jj_scanpos.next = token_source |
| .getNextToken(); |
| } else { |
| jj_lastpos = jj_scanpos = jj_scanpos.next; |
| } |
| } else { |
| jj_scanpos = jj_scanpos.next; |
| } |
| if (jj_rescan) { |
| int i = 0; |
| Token tok = token; |
| while (tok != null && tok != jj_scanpos) { |
| i++; |
| tok = tok.next; |
| } |
| if (tok != null) { |
| jj_add_error_token(kind, i); |
| } |
| } |
| if (jj_scanpos.kind != kind) { |
| return true; |
| } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) { |
| throw jj_ls; |
| } |
| return false; |
| } |
| |
| final public Token getNextToken() { |
| if (token.next != null) { |
| token = token.next; |
| } else { |
| token = token.next = token_source.getNextToken(); |
| } |
| jj_ntk = -1; |
| jj_gen++; |
| return token; |
| } |
| |
| final public Token getToken(int index) { |
| Token t = lookingAhead ? jj_scanpos : token; |
| for (int i = 0; i < index; i++) { |
| if (t.next != null) { |
| t = t.next; |
| } else { |
| t = t.next = token_source.getNextToken(); |
| } |
| } |
| return t; |
| } |
| |
| final private int jj_ntk() { |
| if ((jj_nt = token.next) == null) { |
| return (jj_ntk = (token.next = token_source.getNextToken()).kind); |
| } else { |
| return (jj_ntk = jj_nt.kind); |
| } |
| } |
| |
| private java.util.Vector jj_expentries = new java.util.Vector(); |
| private int[] jj_expentry; |
| private int jj_kind = -1; |
| private int[] jj_lasttokens = new int[100]; |
| private int jj_endpos; |
| |
| private void jj_add_error_token(int kind, int pos) { |
| if (pos >= 100) { |
| return; |
| } |
| if (pos == jj_endpos + 1) { |
| jj_lasttokens[jj_endpos++] = kind; |
| } else if (jj_endpos != 0) { |
| jj_expentry = new int[jj_endpos]; |
| for (int i = 0; i < jj_endpos; i++) { |
| jj_expentry[i] = jj_lasttokens[i]; |
| } |
| boolean exists = false; |
| for (java.util.Enumeration e = jj_expentries.elements(); e |
| .hasMoreElements();) { |
| int[] oldentry = (int[]) (e.nextElement()); |
| if (oldentry.length == jj_expentry.length) { |
| exists = true; |
| for (int i = 0; i < jj_expentry.length; i++) { |
| if (oldentry[i] != jj_expentry[i]) { |
| exists = false; |
| break; |
| } |
| } |
| if (exists) { |
| break; |
| } |
| } |
| } |
| if (!exists) { |
| jj_expentries.addElement(jj_expentry); |
| } |
| if (pos != 0) { |
| jj_lasttokens[(jj_endpos = pos) - 1] = kind; |
| } |
| } |
| } |
| |
| public ParseException generateParseException() { |
| jj_expentries.removeAllElements(); |
| boolean[] la1tokens = new boolean[51]; |
| for (int i = 0; i < 51; i++) { |
| la1tokens[i] = false; |
| } |
| if (jj_kind >= 0) { |
| la1tokens[jj_kind] = true; |
| jj_kind = -1; |
| } |
| for (int i = 0; i < 24; i++) { |
| if (jj_la1[i] == jj_gen) { |
| for (int j = 0; j < 32; j++) { |
| if ((jj_la1_0[i] & (1 << j)) != 0) { |
| la1tokens[j] = true; |
| } |
| if ((jj_la1_1[i] & (1 << j)) != 0) { |
| la1tokens[32 + j] = true; |
| } |
| } |
| } |
| } |
| for (int i = 0; i < 51; i++) { |
| if (la1tokens[i]) { |
| jj_expentry = new int[1]; |
| jj_expentry[0] = i; |
| jj_expentries.addElement(jj_expentry); |
| } |
| } |
| jj_endpos = 0; |
| jj_rescan_token(); |
| jj_add_error_token(0, 0); |
| int[][] exptokseq = new int[jj_expentries.size()][]; |
| for (int i = 0; i < jj_expentries.size(); i++) { |
| exptokseq[i] = (int[]) jj_expentries.elementAt(i); |
| } |
| return new ParseException(token, exptokseq, tokenImage); |
| } |
| |
| final public void enable_tracing() { |
| } |
| |
| final public void disable_tracing() { |
| } |
| |
| final private void jj_rescan_token() { |
| jj_rescan = true; |
| for (int i = 0; i < 2; i++) { |
| JJCalls p = jj_2_rtns[i]; |
| do { |
| if (p.gen > jj_gen) { |
| jj_la = p.arg; |
| jj_lastpos = jj_scanpos = p.first; |
| switch (i) { |
| case 0: |
| jj_3_1(); |
| break; |
| case 1: |
| jj_3_2(); |
| break; |
| } |
| } |
| p = p.next; |
| } while (p != null); |
| } |
| jj_rescan = false; |
| } |
| |
| final private void jj_save(int index, int xla) { |
| JJCalls p = jj_2_rtns[index]; |
| while (p.gen > jj_gen) { |
| if (p.next == null) { |
| p = p.next = new JJCalls(); |
| break; |
| } |
| p = p.next; |
| } |
| p.gen = jj_gen + xla - jj_la; |
| p.first = token; |
| p.arg = xla; |
| } |
| |
| static final class JJCalls { |
| int gen; |
| Token first; |
| int arg; |
| JJCalls next; |
| } |
| |
| } |